Microflow,

export function MqttVariableMessenger() {
	const { publish, subscribe, uniqueId } = useMqtt();
	const publishedVariableValues = useRef(new Map());
 
	useEffect(() => {
		subscribe(`microflow/${uniqueId}/variables/request`, topic => {
			publish(`microflow/${uniqueId}/variables/response`, publishedVariableValues);
		});
 
		subscribe(`microflow/${uniqueId}/variable/+/set`, async (topic, message) => {
			const variableId = topic.split('/').at(2);
			await sendMessageToFigma(SetLocalValiable(variableId, message.toString()));
		});
	}, [subscribe, publish, uniqueId]);
 
	// Listen to changes in variables from Figma variable panel
	useMessageListener(MESSAGE_TYPE.GET_LOCAL_VARIABLES, variables => {
		variables.forEach(async variable => {
			await publish(`microflow/${uniqueId}/variable/${variable.id}`, variable.value);
			publishedVariableValues.current.set(variable.id, variable.value);
		});
	});
 
	return null;
}

import { Board, BoardName, BOARDS } from './constants';
import { SerialConnection } from './SerialConnection';
 
export class Flasher {
	private readonly connection: SerialConnection;
	private readonly board: Board;
 
	constructor(boardName: BoardName, usbPortPath: string) {
		const board = BOARDS.find(board => board.name === boardName);
 
		if (!board) {
			throw new Error(`Board ${boardName} is not a know board`);
		}
 
		this.board = board;
		this.connection = new SerialConnection(board.baudRate, usbPortPath);
	}
 
	async flash(filePath: string) {
		try {
			const protocol = new this.board.protocol(this.connection, this.board);
			await protocol.flash(filePath);
		} catch (error) {
			throw error; // Rethrow the error so the caller can handle it
		} finally {
			await this.connection.close(); // Always close the port again
		}
	}
}

import type { Edge, Node } from '@xyflow/react';
 
export function generateCode(nodes: Node[], edges: Edge[]) {
    let code = `const Microflow = require("@microflow/components");`;
 
    code += `const nodes = new Map();`;
 
    code += `new Microflow.Board({ port: process.argv.at(-1); });`;
 
    nodes.forEach(node => {
    code += `const ${node.type}_${node.id} = new Microflow.${node.type}(${node.data});`;
    code += `nodes.set("${node.id}", ${node.type}_${node.id});`;
 
    const edgesGroupedByHandle = edges.reduce(
        (acc, edge) => ({
        ...acc,
        [edge.sourceHandle]: [...(acc[action.sourceHandle] || []), edge],
        }),
        {} as Record<string, Edge[]>,
    );
 
    Object.entries(edgesGroupedByHandle).forEach(([handle, groupedEdges]) => {
        code += `${node.type}_${node.id}.on("${handle}", () => {`;
 
        groupedEdges.forEach(edge => {
            const valueTriggers = [
                'set', 'check', 'show', 'rotate',
                'red', 'green', 'blue', 'opacity',
                'from', 'to', 'publish',
            ];
 
            const shouldSetValue = valueTriggers.includes(edge.targetHandle);
            let value = shouldSetValue ? `${node.type}_${node.id}.value` : undefined;
 
            if (node.type === 'RangeMap' && shouldSetValue) {
                value = `${node.type}_${node.id}.value[1]`;
            }
 
            const targetNode = nodes.find(node => node.id === edge.target);
            code += `${targetNode?.type}_${targetNode?.id}.${edge.targetHandle}(${value});`;
        });
 
        code += `}); // ${node.type}_${node.id} - ${action}`;
    });
 
    return code;
}

const Microflow = require("@microflow/components");
 
const nodes = new Map();
 
new Microflow.Board({ port: process.argv.at(-1) });
 
const Led_zuhhq2 = new Microflow.Led({"pin":13,"id":"zuhhq2"});
nodes.set("zuhhq2", Led_zuhhq2);
const Interval_4aeu4a = new Microflow.Interval({"interval":500,"id":"4aeu4a"});
nodes.set("4aeu4a", Interval_4aeu4a);
 
Interval_4aeu4a.on("change", () => {
    Led_zuhhq2.toggle(undefined);
}); // Interval_4aeu4a - change

import JohnnyFive, { ButtonOption } from 'johnny-five';
import { BaseComponent, BaseComponentOptions } from './BaseComponent';
 
export type ButtonData = Omit<ButtonOption, 'board'>;
export type ButtonValueType = boolean | number;
 
type ButtonOptions = BaseComponentOptions & ButtonData;
 
export class Button extends BaseComponent<ButtonValueType> {
	private readonly component: JohnnyFive.Button;
 
	constructor(options: ButtonOptions) {
		super(options, false);
 
		this.component = new JohnnyFive.Button(options);
 
		this.component.on('up', () => {
			this.value = false;
			this.eventEmitter.emit('inactive', this.value, false);
		});
		this.component.on('down', () => {
			this.value = true;
			this.eventEmitter.emit('active', this.value, false);
		});
		this.component.on('hold', () => {
			this.eventEmitter.emit('hold', this.value);
		});
	}
}