@digipair/skill-web-editor 0.4.2

package/pins-to-blockly.esm.js

@@ -0,0 +1,515 @@
+function getPinsBlockDefinition(library, methodData, pinsId) {
+    const blockDefinition = {
+        type: pinsId,
+        message0: library.info['x-icon'] + ' ' + methodData.summary,
+        args0: [],
+        message1: '',
+        args1: [],
+        message2: '',
+        args2: [],
+        message3: '',
+        args3: [],
+        colour: '#1e2835',
+        tooltip: 'library : ' + library.info.title,
+        inputsInline: false,
+        previousStatement: null,
+        nextStatement: null
+    };
+    const parameters = methodData.parameters;
+    const metadata = methodData.metadata || [];
+    const events = methodData['x-events'] || [];
+    const requiredParamInputs = parameters.filter((param)=>param.required === true);
+    const requiredEventInputs = [];
+    const requiredFields = requiredParamInputs.map((param)=>param.name);
+    if (methodData['x-events']) {
+        methodData['x-events'].forEach((event)=>{
+            if (event.required) {
+                requiredEventInputs.push(event);
+                requiredFields.push('__EVENT__/' + event.name);
+            }
+        });
+    }
+    requiredFields.push('');
+    const mutatorToolbox = parameters.map((param)=>param.name).filter((name)=>!requiredFields.includes(name));
+    if (methodData.tags) {
+        if (methodData.tags.includes('needPins') && !methodData.tags.includes('requirePins')) {
+            mutatorToolbox.push('pins');
+        } else if (methodData.tags.includes('needPins') && methodData.tags.includes('requirePins')) {
+            blockDefinition['message3'] += '%1 %2 %3';
+            blockDefinition['args3'].push({
+                type: 'field_label',
+                name: `NAME_INPUT`,
+                text: 'pins*'
+            });
+            blockDefinition['args3'].push({
+                type: 'input_dummy'
+            });
+            blockDefinition['args3'].push({
+                type: 'input_statement',
+                name: 'pins'
+            });
+            requiredFields.push('pins');
+        }
+    }
+    if (methodData['x-events']) {
+        for (const event of methodData['x-events']){
+            if (event.required === false || !event.required) {
+                mutatorToolbox.push('__EVENT__/' + event.name);
+            }
+        }
+    }
+    for(let i = 0; i < requiredParamInputs.length; i++){
+        var _requiredParamInputs_i_schema, _requiredParamInputs_i_schema1, _requiredParamInputs_i_schema_items_$ref, _requiredParamInputs_i_schema2;
+        const position = blockDefinition['args1'].length;
+        blockDefinition['args1'].push({
+            type: 'field_label',
+            name: `NAME_INPUT`,
+            text: (requiredParamInputs[i].summary || requiredParamInputs[i].name) + '*'
+        });
+        if (((_requiredParamInputs_i_schema = requiredParamInputs[i].schema) == null ? void 0 : _requiredParamInputs_i_schema.type) === 'array' && (((_requiredParamInputs_i_schema1 = requiredParamInputs[i].schema) == null ? void 0 : _requiredParamInputs_i_schema1.items.$ref) === 'https://www.pinser.world/schemas/pinsSettings' || ((_requiredParamInputs_i_schema2 = requiredParamInputs[i].schema) == null ? void 0 : (_requiredParamInputs_i_schema_items_$ref = _requiredParamInputs_i_schema2.items.$ref) == null ? void 0 : _requiredParamInputs_i_schema_items_$ref.includes('#/components/schemas/')))) {
+            blockDefinition['message1'] += ' %' + (position + 1) + ' %' + (position + 2) + ' %' + (position + 3);
+            blockDefinition['args1'].push({
+                type: 'input_dummy'
+            });
+            blockDefinition['args1'].push({
+                type: 'input_statement',
+                name: requiredParamInputs[i].name
+            });
+        } else {
+            blockDefinition['message1'] += ' %' + (position + 1) + ' %' + (position + 2);
+            blockDefinition['args1'].push({
+                type: 'input_value',
+                name: requiredParamInputs[i].name
+            });
+        }
+    }
+    for(let i = 0; i < requiredEventInputs.length; i++){
+        const position = blockDefinition['args2'].length;
+        blockDefinition['args2'].push({
+            type: 'field_label',
+            name: `NAME_INPUT`,
+            text: '@' + (requiredEventInputs[i].summary || requiredEventInputs[i].name) + '*'
+        });
+        blockDefinition['message2'] += ' %' + (position + 1) + ' %' + (position + 2) + ' %' + (position + 3);
+        blockDefinition['args2'].push({
+            type: 'input_dummy'
+        });
+        blockDefinition['args2'].push({
+            type: 'input_statement',
+            name: '__EVENT__/' + requiredEventInputs[i].name
+        });
+    }
+    if (mutatorToolbox.length > 0) {
+        blockDefinition.mutator = pinsId + '/mutator';
+        generateMutator(pinsId + '/mutator', mutatorToolbox, requiredFields, [
+            ...parameters,
+            ...metadata,
+            ...events
+        ]);
+    }
+    return blockDefinition;
+}
+function getComponentBlockDefinition(library, componentName, methodData, componentId) {
+    const blockDefinition = {
+        type: componentId,
+        message0: library.info['x-icon'] + ' ' + componentName,
+        args0: [],
+        message1: '',
+        args1: [],
+        colour: '#74dc04',
+        tooltip: 'library : ' + library.info.title,
+        inputsInline: false,
+        previousStatement: null,
+        nextStatement: null
+    };
+    const properties = methodData.properties;
+    const requiredFields = methodData.required || [];
+    requiredFields.push('');
+    const mutatorToolbox = [];
+    const parameters = Object.keys(properties).map((propertyName)=>({
+            name: propertyName,
+            schema: properties[propertyName]
+        }));
+    let messageIndex = 0;
+    parameters.forEach((parameter, _index)=>{
+        const propertyName = parameter.name;
+        if (!requiredFields.includes(propertyName)) {
+            mutatorToolbox.push(propertyName);
+        } else {
+            var _parameter_schema, _parameter_schema1, _parameter_schema2;
+            blockDefinition['args1'].push({
+                type: 'field_label',
+                name: 'NAME_INPUT',
+                text: propertyName + '*'
+            });
+            if (((_parameter_schema = parameter.schema) == null ? void 0 : _parameter_schema.type) === 'array' && (((_parameter_schema1 = parameter.schema) == null ? void 0 : _parameter_schema1.items.$ref) === 'https://www.pinser.world/schemas/pinsSettings' || ((_parameter_schema2 = parameter.schema) == null ? void 0 : _parameter_schema2.items.$ref.includes('#/components/schemas/')))) {
+                blockDefinition['message1'] += ' %' + (messageIndex * 2 + 1) + ' %' + (messageIndex * 2 + 2) + ' %' + (messageIndex * 2 + 3);
+                blockDefinition['args1'].push({
+                    type: 'input_dummy'
+                });
+                blockDefinition['args1'].push({
+                    type: 'input_statement',
+                    name: parameter.name
+                });
+            } else {
+                blockDefinition['message1'] += ' %' + (messageIndex * 2 + 1) + ' %' + (messageIndex * 2 + 2);
+                blockDefinition['args1'].push({
+                    type: 'input_value',
+                    name: parameter.name
+                });
+            }
+            messageIndex++;
+        }
+    });
+    if (mutatorToolbox.length > 0) {
+        blockDefinition.mutator = componentId + '/mutator';
+        generateMutator(componentId + '/mutator', mutatorToolbox, requiredFields, parameters);
+    }
+    return blockDefinition;
+}
+function generateToolboxFromLibraries(libraries) {
+    const sortedLibraries = libraries.sort((a, b)=>{
+        var _a_info_summary;
+        const title1 = (_a_info_summary = a.info.summary) != null ? _a_info_summary : a.info.title;
+        var _b_info_summary;
+        const title2 = (_b_info_summary = b.info.summary) != null ? _b_info_summary : b.info.title;
+        if (title1 < title2) {
+            return -1;
+        }
+        if (title1 > title2) {
+            return 1;
+        }
+        return 0;
+    });
+    const toolbox = {
+        kind: 'categoryToolbox',
+        contents: [
+            {
+                kind: 'category',
+                name: '⚙️ Common',
+                contents: [
+                    {
+                        kind: 'block',
+                        type: 'object'
+                    },
+                    {
+                        kind: 'block',
+                        type: 'member'
+                    },
+                    {
+                        kind: 'block',
+                        type: 'math_number'
+                    },
+                    {
+                        kind: 'block',
+                        type: 'text_multiline'
+                    },
+                    {
+                        kind: 'block',
+                        type: 'logic_boolean'
+                    },
+                    {
+                        kind: 'block',
+                        type: 'logic_null'
+                    },
+                    {
+                        kind: 'block',
+                        type: 'array'
+                    },
+                    {
+                        kind: 'block',
+                        type: 'array-input'
+                    }
+                ]
+            },
+            ...sortedLibraries.map((library)=>{
+                var _library_components;
+                var _library_info_summary;
+                return {
+                    kind: 'category',
+                    name: library.info['x-icon'] + ' ' + ((_library_info_summary = library.info.summary) != null ? _library_info_summary : library.info.title),
+                    contents: [
+                        ...library.paths ? Object.entries(library.paths).sort((a, b)=>a[0].localeCompare(b[0])) // Tri alphabétique par path
+                        .map(([path, _pins])=>({
+                                kind: 'block',
+                                type: library.info.title + '/__PINS__' + path
+                            })) : [],
+                        ...((_library_components = library.components) == null ? void 0 : _library_components.schemas) ? Object.entries(library.components.schemas).sort((a, b)=>a[0].localeCompare(b[0])) // Tri alphabétique par componentName
+                        .map(([componentName, _componentSchema])=>({
+                                kind: 'block',
+                                type: library.info.title + '/__COMPONENTS__/' + componentName
+                            })) : []
+                    ]
+                };
+            })
+        ]
+    };
+    return toolbox;
+}
+function generateBlocklyBlockFromLibraries(pinsLibraries, blocksLegacy) {
+    const blocksLibrary = [
+        ...blocksLegacy
+    ];
+    for (const pinsLibrary of pinsLibraries){
+        //search for pins blocks
+        for(const endpoint in pinsLibrary.paths){
+            if (Object.hasOwnProperty.call(pinsLibrary.paths, endpoint)) {
+                const endpointData = pinsLibrary.paths[endpoint];
+                const methodData = endpointData.post;
+                const pinsId = pinsLibrary.info.title + '/__PINS__' + endpoint;
+                blocksLibrary.push(getPinsBlockDefinition(pinsLibrary, methodData, pinsId));
+            }
+        }
+    }
+    for (const pinsLibrary of pinsLibraries){
+        //search for components blocks
+        if (!pinsLibrary.components || !pinsLibrary.components.schemas) {
+            continue;
+        }
+        for(const endpoint in pinsLibrary.components.schemas){
+            if (Object.hasOwnProperty.call(pinsLibrary.components.schemas, endpoint)) {
+                const endpointData = pinsLibrary.components.schemas[endpoint];
+                if (!endpointData || !endpointData.properties) {
+                    continue;
+                }
+                const componentId = pinsLibrary.info.title + '/__COMPONENTS__/' + endpoint;
+                const blockName = endpoint;
+                blocksLibrary.push(getComponentBlockDefinition(pinsLibrary, blockName, endpointData, componentId));
+            }
+        }
+    }
+    for (const pinsLibrary of pinsLibraries){
+        //search for scene blocks
+        for(const endpoint in pinsLibrary['x-scene-blocks']){
+            if (Object.hasOwnProperty.call(pinsLibrary['x-scene-blocks'], endpoint)) {
+                const endpointSceneblock = pinsLibrary['x-scene-blocks'][endpoint];
+                const sceneBlockId = pinsLibrary.info.title + '/__SCENEBLOCK__' + endpoint;
+                blocksLibrary.push(getSceneBlockDefinition(pinsLibrary, endpointSceneblock, sceneBlockId));
+            }
+        }
+    }
+    return blocksLibrary;
+}
+function initializeMutator() {
+    Blockly.Blocks['mutator_container'] = {
+        init: function() {
+            this.appendDummyInput().appendField('Inputs');
+            this.appendStatementInput('STACK');
+            this.setColour(230);
+            this.setTooltip('');
+            this.workspace.addChangeListener((event)=>{
+                if (event.type === Blockly.Events.BLOCK_MOVE) {
+                    let currentBlock = this.workspace.getBlockById(event.newParentId);
+                    while(currentBlock){
+                        if (currentBlock.id === this.id) {
+                            let firstBlock = this.getInputTargetBlock('STACK');
+                            const seenTypes = {};
+                            while(firstBlock){
+                                if (seenTypes[firstBlock.type]) {
+                                    firstBlock.unplug(true);
+                                } else {
+                                    seenTypes[firstBlock.type] = true;
+                                }
+                                firstBlock = firstBlock.getNextBlock();
+                            }
+                            break;
+                        }
+                        currentBlock = currentBlock.getSurroundParent();
+                    }
+                }
+            });
+        }
+    };
+}
+function generateMutator(mutatorName, toolboxItem, requiredFields, parameters) {
+    const toolboxList = [];
+    for (const item of toolboxItem){
+        Blockly.Blocks[mutatorName + '/' + item] = {
+            init: function() {
+                this.appendDummyInput(item).appendField(item.includes('__EVENT__/') ? item.replace('__EVENT__/', '@') : item);
+                this.setPreviousStatement(true);
+                this.setNextStatement(true);
+                this.setColour(0);
+            }
+        };
+        toolboxList.push(mutatorName + '/' + item);
+    }
+    toolboxList.sort((a, b)=>a.localeCompare(b));
+    Blockly.Extensions.registerMutator(mutatorName, {
+        saveExtraState: function() {
+            return {
+                itemList: this.itemList_ || []
+            };
+        },
+        loadExtraState: function(state) {
+            this.itemList_ = state['itemList'];
+            this.updateShape_();
+        },
+        decompose: function(workspace) {
+            const containerBlock = workspace.newBlock('mutator_container');
+            containerBlock.initSvg();
+            let connection = containerBlock.getInput('STACK').connection;
+            for(let i = 0; i < this.inputList.length; i++){
+                if (requiredFields.includes(this.inputList[i].name)) {
+                    continue;
+                }
+                const inputBlock = workspace.newBlock(mutatorName + '/' + this.inputList[i].name);
+                inputBlock.initSvg();
+                connection.connect(inputBlock.previousConnection);
+                connection = inputBlock.nextConnection;
+            }
+            return containerBlock;
+        },
+        compose: function(containerBlock) {
+            const inputConnectedArray = [];
+            let childBlock = containerBlock.getInputTargetBlock('STACK');
+            while(childBlock){
+                const inputName = childBlock.inputList[0].name;
+                let fieldName = '';
+                if (childBlock.inputList[0]) {
+                    const fieldRow = childBlock.inputList[0].fieldRow;
+                    if (fieldRow.length > 0) {
+                        fieldName = fieldRow[0].getText();
+                    }
+                }
+                inputConnectedArray.push({
+                    id: inputName,
+                    name: fieldName
+                });
+                childBlock = childBlock.nextConnection && childBlock.nextConnection.targetBlock();
+            }
+            this.itemList_ = inputConnectedArray;
+            this.updateShape_();
+        },
+        updateShape_: function() {
+            const inputToEnable = this.itemList_;
+            const inputLoaded = this.inputList.map((input)=>input.name);
+            const inputToEnableIds = inputToEnable.map((input)=>input.id);
+            for (const input of inputLoaded){
+                if (requiredFields.includes(input)) continue;
+                if (!inputToEnableIds.includes(input)) {
+                    this.removeInput(input);
+                }
+            }
+            for (const input of inputToEnable){
+                if (requiredFields.includes(input)) {
+                    continue;
+                }
+                if (!inputLoaded.includes(input.id)) {
+                    var _parameter_schema, _parameter_schema1, _parameter_schema_items_$ref, _parameter_schema2;
+                    const id = input.id.indexOf('/') < 0 ? input.id : input.id.split('/')[1];
+                    var _parameters_find;
+                    const parameter = (_parameters_find = parameters.find((param)=>param.name === id)) != null ? _parameters_find : {};
+                    if (((_parameter_schema = parameter.schema) == null ? void 0 : _parameter_schema.type) === 'array' && (((_parameter_schema1 = parameter.schema) == null ? void 0 : _parameter_schema1.items.$ref) === 'https://www.pinser.world/schemas/pinsSettings' || ((_parameter_schema2 = parameter.schema) == null ? void 0 : (_parameter_schema_items_$ref = _parameter_schema2.items.$ref) == null ? void 0 : _parameter_schema_items_$ref.includes('#/components/schemas/')))) {
+                        this.appendDummyInput().appendField(input.name);
+                        this.appendStatementInput(input.id);
+                    } else {
+                        this.appendValueInput(input.id).appendField(input.name);
+                    }
+                }
+            }
+        }
+    }, null, toolboxList);
+}
+function getSceneBlockDefinition(library, methodData, sceneBlockId) {
+    const blockDefinition = {
+        type: sceneBlockId,
+        message0: library.info['x-icon'] + ' ' + methodData.summary,
+        args0: [],
+        message1: '',
+        args1: [],
+        message2: '',
+        args2: [],
+        message3: '',
+        args3: [],
+        colour: 230,
+        tooltip: 'library : ' + library.info.title
+    };
+    const metadata = methodData.metadata || [];
+    const parameters = methodData.parameters || [];
+    if (methodData.tags && methodData.tags.includes('needPins')) {
+        const parameter = {
+            required: methodData.tags.includes('requirePins'),
+            name: 'EXECUTE_PINS',
+            summary: 'pins',
+            schema: {
+                type: 'array',
+                items: {
+                    $ref: 'https://www.pinser.world/schemas/pinsSettings'
+                }
+            }
+        };
+        parameters.push(parameter);
+    }
+    const requiredParamInputs = parameters.filter((param)=>param.required === true);
+    const requiredFields = requiredParamInputs.map((param)=>param.name);
+    requiredFields.push('');
+    // metadata
+    for(let i = 0; i < (metadata == null ? void 0 : metadata.length); i++){
+        var _parameter_schema, _parameter_schema_items_$ref;
+        var _metadata_find;
+        const parameter = (_metadata_find = metadata.find((param)=>param.name === metadata[i].name)) != null ? _metadata_find : {};
+        const position = blockDefinition['args1'].length;
+        blockDefinition['args1'].push({
+            type: 'field_label',
+            name: `NAME_INPUT_METADATA`,
+            text: (parameter.summary || parameter.name) + '*'
+        });
+        if (((_parameter_schema = parameter.schema) == null ? void 0 : _parameter_schema.type) === 'array' && (parameter.schema.items.$ref === 'https://www.pinser.world/schemas/pinsSettings' || ((_parameter_schema_items_$ref = parameter.schema.items.$ref) == null ? void 0 : _parameter_schema_items_$ref.includes('#/components/schemas/')))) {
+            blockDefinition['message1'] += ' %' + (position + 1) + ' %' + (position + 2) + ' %' + (position + 3);
+            blockDefinition['args1'].push({
+                type: 'input_dummy'
+            });
+            blockDefinition['args1'].push({
+                type: 'input_statement',
+                name: 'metadata--' + parameter.name
+            });
+        } else {
+            blockDefinition['message1'] += ' %' + (position + 1) + ' %' + (position + 2);
+            blockDefinition['args1'].push({
+                type: 'input_value',
+                name: 'metadata--' + parameter.name
+            });
+        }
+    }
+    // mutator toolbox
+    const mutatorToolbox = parameters.map((param)=>param.name).filter((name)=>!requiredFields.includes(name));
+    // parameters
+    for(let i = 0; i < requiredParamInputs.length; i++){
+        var _parameter_schema1, _parameter_schema_items_$ref1;
+        var _parameters_find;
+        const parameter = (_parameters_find = parameters.find((param)=>param.name === requiredParamInputs[i].name)) != null ? _parameters_find : {};
+        const position = blockDefinition['args3'].length;
+        blockDefinition['args3'].push({
+            type: 'field_label',
+            name: `NAME_INPUT`,
+            text: (parameter.summary || parameter.name) + '*'
+        });
+        if (((_parameter_schema1 = parameter.schema) == null ? void 0 : _parameter_schema1.type) === 'array' && (parameter.schema.items.$ref === 'https://www.pinser.world/schemas/pinsSettings' || ((_parameter_schema_items_$ref1 = parameter.schema.items.$ref) == null ? void 0 : _parameter_schema_items_$ref1.includes('#/components/schemas/')))) {
+            blockDefinition['message3'] += ' %' + (position + 1) + ' %' + (position + 2) + ' %' + (position + 3);
+            blockDefinition['args3'].push({
+                type: 'input_dummy'
+            });
+            blockDefinition['args3'].push({
+                type: 'input_statement',
+                name: parameter.name
+            });
+        } else {
+            blockDefinition['message3'] += ' %' + (position + 1) + ' %' + (position + 2);
+            blockDefinition['args3'].push({
+                type: 'input_value',
+                name: parameter.name
+            });
+        }
+    }
+    if (mutatorToolbox.length > 0) {
+        blockDefinition.mutator = sceneBlockId + '/mutator';
+        generateMutator(sceneBlockId + '/mutator', mutatorToolbox, requiredFields, [
+            ...parameters,
+            ...metadata || []
+        ]);
+    }
+    return blockDefinition;
+}
+
+export { generateBlocklyBlockFromLibraries, generateToolboxFromLibraries, initializeMutator };

package/schema.json

@@ -0,0 +1,93 @@
+{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "@digipair/skill-web-editor",
+    "description": "Edition de raisonnements IA.",
+    "version": "0.1.0",
+    "x-icon": "🚀"
+  },
+  "paths": {
+    "/digipair-editor": {
+      "post": {
+        "tags": [],
+        "summary": "Editeur de raisonnements",
+        "description": "Editeur no-code de raisonnements IA",
+        "parameters": [
+          {
+            "name": "digipair",
+            "summary": "Digipair",
+            "required": true,
+            "description": "Propriétaire du raisonnement",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "reasoning",
+            "summary": "Raisonnement",
+            "required": true,
+            "description": "Nom du raisonnement",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "x-events": [
+          {
+            "name": "save",
+            "summary": "Lors de la sauvegarde",
+            "required": false,
+            "description": "Action déclenchée lors de la sauvegarde du raisonnement",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "https://www.pinser.world/schemas/pinsSettings"
+              }
+            }
+          }
+        ]
+      }
+    },
+    "/information": {
+      "post": {
+        "tags": [],
+        "summary": "Affiche des information",
+        "description": "Affiche des informations sur l'editeur de raisonnements",
+        "parameters": [
+          {
+            "name": "message",
+            "summary": "Message",
+            "required": true,
+            "description": "Message à afficher",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "x-events": []
+      }
+    },
+    "/error": {
+      "post": {
+        "tags": [],
+        "summary": "Affiche une erreurs",
+        "description": "Affiche une erreur sur l'editeur de raisonnements",
+        "parameters": [
+          {
+            "name": "message",
+            "summary": "Message",
+            "required": true,
+            "description": "Message à afficher",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "x-events": []
+      }
+    }
+  },
+  "components": {
+    "schemas": {}
+  }
+}