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);
			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;
}

    
      Copied!
      
      
    
  

    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; // This is important to rethrow the error so the caller can handle it
		} finally {
			await this.connection.close(); // Always close the port again
		}
	}
}

    
      Copied!
      
      
    
  

    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;
}

    
      Copied!
      
      
    
  

    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,"value":0,"id":"zuhhq2"});
nodes.set("zuhhq2", Led_zuhhq2);
const Interval_4aeu4a = new Microflow.Interval({"interval":500,"value":0,"id":"4aeu4a"});
nodes.set("4aeu4a", Interval_4aeu4a);

Interval_4aeu4a.on("change", () => {
  Led_zuhhq2.toggle(undefined);
}); // Interval_4aeu4a - change

    
      Copied!
      
      
    
  

    import JohnnyFive, { LedOption } from 'johnny-five';
import { BaseComponent, BaseComponentOptions } from './BaseComponent';

export type LedData = Omit<LedOption, 'board'>;
export type LedValueType = number;

type LedOptions = BaseComponentOptions & LedData;

export class Led extends BaseComponent<LedValueType> {
	private readonly component: JohnnyFive.Led;

	constructor(private readonly options: LedOptions) {
		super(options);
		this.component = new JohnnyFive.Led(options);
	}

	on(action: string, callback: (...args: any[]) => void) {
		if (action) {
			this.eventEmitter.on(action, callback);
			return;
		}

		this.component.on();
		this.value = 1;
	}

	off() {
		this.component.off();
		this.value = 0;
	}

	toggle() {
		this.component.toggle();
		this.value = this.value === 0 ? 1 : 0;
	}
}

    
      Copied!