@ejfdelgado/ejflab-common 1.0.0

package/src/flowchart/steps/StepProcess.js

@@ -0,0 +1,163 @@
+const { StepBasic } = require("./StepBasic");
+const { SimpleObj } = require("../../SimpleObj");
+const { IdGen } = require("../../IdGen");
+const { encode, decode } = require("@msgpack/msgpack");
+
+class StepProcess extends StepBasic {
+    constructor(context, id, commandName, argsTxt) {
+        super(context, id, commandName, argsTxt);
+        super.alwaysEvaluateCanContinue = true;
+    }
+    async execFirst() {
+
+        const partsName = /^([^\.\d]+)(\d*)\.?([^'.]*)$/.exec(this.args[0]);
+        if (!partsName) {
+            console.log(`The processor name ${this.args[0]} does not match ^([^\.\d]+)(\d*)\.?([^'.]*)$`);
+            return false;
+        }
+        let method = "main";
+        const processorMethod = partsName[0];
+        const processorName = partsName[1];
+        const instanceNumber = partsName[2];
+        let processorInstance = partsName[1];
+        if (typeof partsName[2] == "string") {
+            processorInstance += instanceNumber;
+        }
+        if (typeof partsName[3] == "string" && partsName[3].trim().length > 0) {
+            method = partsName[3];
+        }
+        this.configuration = SimpleObj.getValue(this.context.data, `state.processors.${processorName}`, null);
+        if (!this.configuration) {
+            this.configuration = {};
+        }
+        let channel = this.configuration.channel;
+        if (!channel) {
+            // Gets channel from parent
+            channel = SimpleObj.getValue(this.context.data, `state.processors.channel`, "websocket");
+        }
+
+        let processorSocketId = null;
+        let postUrl = null;
+        const processorsModel = this.context.getProcessorsModel();
+        if (channel == "websocket") {
+            processorSocketId = SimpleObj.getValue(processorsModel.data, `state.processors.${processorName}.socket`, null);
+            if (!processorSocketId) {
+                console.log(`No client processor websocket for ${processorInstance}`);
+                return false;
+            }
+        } else if (channel == "post") {
+            postUrl = SimpleObj.getValue(processorsModel.data, `state.processors.${processorName}.postUrl`, null);
+            if (!postUrl) {
+                console.log(`No client postUrl for ${processorInstance}`);
+                return false;
+            }
+        }
+
+        // It reads the connection configuration
+        const model = this.context.getSuperContextModel();
+
+        const metadata = SimpleObj.getValue(model, `flowchart.flux.${processorInstance}.${method}.metadata`, {});
+        if ('timeout' in metadata) {
+            const timeout = parseFloat(metadata['timeout']);
+            if (!isNaN(timeout)) {
+                this.setTimeout(timeout);
+            }
+        }
+        if ('retries' in metadata) {
+            const retries = parseInt(metadata['retries']);
+            if (!isNaN(retries)) {
+                this.setMaxTries(retries);
+            }
+        }
+
+        const inputConnectionsConf = SimpleObj.getValue(model, `flowchart.flux.${processorInstance}.${method}.in`, null);
+
+        if (!inputConnectionsConf) {
+            console.log(`WARN: No input connection flux configuration for ${processorInstance}.${method}`);
+            //return false;
+        }
+
+        const inputs = [];
+        const outputs = [];
+        for (let i = 1; i < this.args.length; i++) {
+            const sourcePair = this.args[i];
+            const partsSource = /^(in|out):(b\.([^.]+)\.([^.]+)|d\.(.+))$/i.exec(sourcePair);
+            if (partsSource == null) {
+                console.log(`${sourcePair} doesn't match ^(in|out)\.(b\.([^.]+)\.([^.]+)|d\.(.+))$`);
+                return false;
+            }
+            if (partsSource[1] == "in") {
+                // It's an input
+                const buffer = this.readInputFrom(!partsSource[5], partsSource[3], partsSource[4], partsSource[5]);
+                if (buffer === undefined) {
+                    return false;
+                }
+                inputs.push(buffer);
+            } else {
+                // Its an output
+                outputs.push(partsSource[2]);
+            }
+        }
+
+        const namedInputs = {};
+        if (!!inputConnectionsConf) {
+            for (let i = 0; i < inputConnectionsConf.length; i++) {
+                const { key, val } = inputConnectionsConf[i];
+                const buffer = this.resolveArgument(val);
+                if (buffer === undefined) {
+                    return false;
+                }
+                namedInputs[key] = buffer;
+            }
+        }
+
+        const room = this.context.getRoom();
+        //console.log(`StepProcess processorName:${processorName} processorInstance:${processorInstance} processorMethod:${processorMethod} in room ${room}`);
+        this.messageUID = IdGen.num2ord(new Date().getTime());
+        this.pendingCall = `${room}-${this.id}-${this.messageUID}`;
+        this.context.registerPendingCall(this.pendingCall, this);
+        const payload = {
+            inputs,//Inputs
+            namedInputs,
+            outputs,//Outpus
+            method,
+            processorName,
+            processorInstance,
+            processorMethod,
+            id: this.pendingCall,
+            data: this.configuration[instanceNumber],
+            room
+        };
+
+        if (channel == "websocket") {
+            if (this.context.io) {
+                this.context.io.to(processorSocketId).emit("process", payload);
+            }
+        } else if (channel == "queue") {
+            // TODO use google library to sends via pub/sub
+            const url = this.configuration.topicUrl;
+        } else if (channel == "post") {
+            const axios = this.context.getSuperContext().getAxios();
+            const options = {
+                headers: { "Content-Type": "application/octet-stream" }
+            };
+            const encoded = encode(payload);
+            const buffer = Buffer.from(encoded);
+            const postResponse = await axios.post(`${postUrl}/process`, buffer, options);
+        } else {
+            console.log("No channel configuration found!");
+            return false;
+        }
+    }
+    async canContinue() {
+        if (!this.pendingCall) {
+            return false;
+        }
+        const isPending = this.context.existsPendingCall(this.pendingCall);
+        return !isPending;
+    }
+}
+
+module.exports = {
+    StepProcess
+};

package/src/flowchart/steps/StepReadSrc.js

@@ -0,0 +1,66 @@
+const { StepBasic } = require("./StepBasic");
+const { SimpleObj } = require("../../SimpleObj");
+const { IdGen } = require("../../IdGen");
+
+class StepReadSrc extends StepBasic {
+    pendingCall = null;
+    socketId = null;
+    sourceUID = null;
+    dataPath = null;
+    configuration = null;
+    constructor(context, id, commandName, argsTxt) {
+        super(context, id, commandName, argsTxt);
+        super.alwaysEvaluateCanContinue = false;
+    }
+    async execFirst() {
+        const sourcePair = this.args[0];
+        const parts = sourcePair.split(".");
+        this.sourceUID = parts[0];
+        if (parts.length >= 2) {
+            this.dataPath = parts[1];
+        }
+        const timelineId = this.args[1];
+        const timeline = this.context.getTimeLine(timelineId);
+        if (!timeline || typeof timeline.t != "number" || timeline.done) {
+            console.log(`Timeline ${timelineId} can't be used ${JSON.stringify(timeline)}`);
+        }
+        if (this.context.io) {
+            // Leo la ruta del sourceUID
+            this.configuration = SimpleObj.getValue(this.context.data, `state.sources.${this.sourceUID}`, null);
+            let localConfiguration = {};
+            if (this.dataPath) {
+                if (!(this.dataPath in this.configuration.data)) {
+                    console.log(`The source ${this.sourceUID} has no ${this.dataPath}`);
+                    return;
+                }
+                localConfiguration[this.dataPath] = this.configuration.data[this.dataPath];
+            } else {
+                localConfiguration = this.configuration.data;
+            }
+            this.socketId = this.configuration.socket;
+            if (this.socketId) {
+                this.messageUID = IdGen.num2ord(new Date().getTime());
+                this.pendingCall = `${this.id}-${this.messageUID}`;
+                this.context.registerPendingCall(this.pendingCall, this);
+                this.context.io.to(this.socketId).emit("readSrc", {
+                    configuration: localConfiguration,
+                    timeline,
+                    sourcePair,
+                    id: this.pendingCall,
+                });
+            }
+        }
+    }
+
+    async canContinue() {
+        if (!this.pendingCall) {
+            return false;
+        }
+        const isPending = this.context.existsPendingCall(this.pendingCall);
+        return !isPending;
+    }
+}
+
+module.exports = {
+    StepReadSrc
+};

package/src/flowchart/steps/StepSleep.js

@@ -0,0 +1,22 @@
+const { StepBasic } = require("./StepBasic");
+
+class StepSleep extends StepBasic {
+    startTime = null;
+    constructor(context, id, commandName, argsTxt) {
+        super(context, id, commandName, argsTxt);
+        super.alwaysEvaluateCanContinue = false;
+    }
+    async execFirst() {
+        this.startTime = new Date().getTime();
+    }
+
+    async canContinue() {
+        const minTime = this.args[0];
+        const diff = new Date().getTime() - this.startTime;
+        return diff >= minTime;
+    }
+}
+
+module.exports = {
+    StepSleep
+};

package/src/flowchart/steps/StepTimeLineEnds.js

@@ -0,0 +1,21 @@
+const { StepBasic } = require("./StepBasic");
+const { SimpleObj } = require("../../SimpleObj");
+
+class StepTimeLineEnds extends StepBasic {
+    async canContinue() {
+        const timeLineId = this.args[0];
+        const timeline = this.context.getTimeLine(timeLineId);
+        if (!timeline) {
+            return false;
+        }
+        const finished = !(timeline.t + timeline.period < timeline.end);
+        if (finished) {
+            SimpleObj.recreate(this.context.data, "scope.progress", 100);
+        }
+        return finished;
+    }
+}
+
+module.exports = {
+    StepTimeLineEnds
+};

package/src/flowchart/steps/StepTimeLineHasMore.js

@@ -0,0 +1,16 @@
+const { StepBasic } = require("./StepBasic");
+
+class StepTimeLineHasMore extends StepBasic {
+    async canContinue() {
+        const timeLineId = this.args[0];
+        const timeline = this.context.getTimeLine(timeLineId);
+        if (!timeline) {
+            return false;
+        }
+        return timeline.t + timeline.period < timeline.end;
+    }
+}
+
+module.exports = {
+    StepTimeLineHasMore
+};

package/src/gif/index.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { Frame as FrameI } from 'imagescript';
+interface Frame {
+    src: string | Uint8Array;
+    duration?: number;
+    background?: string | Uint8Array;
+}
+export declare class Gif {
+    width: number;
+    height: number;
+    frames: FrameI[];
+    loops: number;
+    quality: number;
+    constructor(width: number, height: number, quality?: number);
+    setLoops(loops: number): void;
+    setFrames(frames: Frame | Frame[]): Promise<void>;
+    addFrame(frame: Frame): Promise<void>;
+    encode(arrayBuffer?: boolean): Promise<Uint8Array | Buffer>;
+}
+export {};

package/src/gif/index.mjs

@@ -0,0 +1,85 @@
+import phin from 'phin';
+import { GIF, Frame as FrameI, decode, Image } from 'imagescript';
+import { checkTypes, checkNumber } from './utils/checkTypes.mjs';
+export class Gif {
+    width;
+    height;
+    frames;
+    loops;
+    quality;
+    constructor(width, height, quality) {
+        if (!width)
+            throw new Error('The width of the Gif is required');
+        if (!height)
+            throw new Error('The height of the Gif is required');
+        checkTypes(width, 'number', 'width');
+        checkTypes(height, 'number', 'height');
+        checkNumber(width, 'width');
+        checkNumber(height, 'height');
+        this.height = height;
+        this.width = width;
+        this.loops = -1;
+        this.quality = quality || 1;
+        this.frames = [];
+    }
+    setLoops(loops) {
+        if (!loops)
+            throw new Error('The loops are required');
+        if (isNaN(loops))
+            throw new Error('The loops needs to be a number');
+        if (loops <= -1)
+            throw new Error('The loops cant be less than -1');
+        this.loops = loops;
+    }
+    async setFrames(frames) {
+        if (!frames)
+            throw new Error('The frames are required');
+        if (!Array.isArray(frames))
+            frames = [frames];
+        if (!frames.length)
+            throw new Error('The frames are required');
+        if (frames.length <= 1)
+            throw new Error('You need to add more than one frame');
+        for (const frame of frames) {
+            await this.addFrame(frame);
+        }
+    }
+    async addFrame(frame) {
+        if (!frame)
+            throw new Error('The frame is required');
+        if (!frame.src)
+            throw new Error('The src is required');
+        const img = new Image(this.width, this.height);
+        if (typeof frame.background === 'string') {
+            const imageres = await phin(frame.background);
+            const buf = Buffer.from(imageres.body);
+            frame.background = new Uint8Array(buf);
+        }
+        if (typeof frame.src === 'string') {
+            const imageres = await phin(frame.src);
+            const buf = Buffer.from(imageres.body);
+            frame.src = new Uint8Array(buf);
+        }
+        if (frame.duration && isNaN(frame.duration))
+            throw new Error('The duration needs to be a number');
+        if (frame.duration && frame.duration <= 0)
+            throw new Error('The duration cant be less than 0');
+        frame.duration = frame.duration || 1000;
+        if (frame.background) {
+            const _background = await decode(frame.background, true);
+            if (_background instanceof GIF)
+                throw new Error('Gifs are not supported at this moment, please get the frames of the gif and put them as frames');
+            img.composite(_background);
+        }
+        const _img = await decode(frame.src, true);
+        if (_img instanceof GIF)
+            throw new Error('Gifs are not supported at this moment, please get the frames of the gif and put them as frames');
+        img.composite(_img);
+        this.frames.push(FrameI.from(img, frame.duration, 0, 0, FrameI.DISPOSAL_BACKGROUND));
+    }
+    async encode(arrayBuffer = false) {
+        const gif = new GIF(this.frames, this.loops);
+        const arrayBuf = await gif.encode(this.quality);
+        return arrayBuffer ? arrayBuf : Buffer.from(arrayBuf);
+    }
+}

package/src/gif/utils/checkTypes.d.ts

@@ -0,0 +1,2 @@
+export declare function checkTypes(v: any, type: string, name: string): void;
+export declare function checkNumber(v: any, name: string): void;

package/src/gif/utils/checkTypes.mjs

@@ -0,0 +1,11 @@
+export function checkTypes(v, type, name) {
+    if (typeof v !== type) {
+        throw new Error(`${name} needs to be a ${type}, recieved: ${typeof v}`);
+    }
+}
+export function checkNumber(v, name) {
+    if (isNaN(v))
+        throw new Error(`${name} needs to be a number, recieved: ${typeof v}`);
+    if (v <= 0)
+        throw new Error(`${v} needs to be a number greater than 0`);
+}