@digipair/skill-web-editor 0.91.0-0 → 0.92.0

package/libs/skill-web-editor/src/lib/skill-web-editor.d.ts

@@ -0,0 +1 @@
+export * from './editor.element';

package/package.json

@@ -1,28 +1,12 @@
 {
   "name": "@digipair/skill-web-editor",
-  "version": "0.91.0-0",
-  "type": "module",
-  "main": "dist/libs/skill-web-editor/index.cjs.js",
-  "module": "dist/libs/skill-web-editor/index.esm.js",
-  "types": "dist/libs/skill-web-editor/index.esm.d.ts",
-  "exports": {
-    "./package.json": "./libs/skill-web-editor/package.json",
-    ".": {
-      "development": "./dist/libs/skill-web-editor/src/index.ts",
-      "types": "./dist/libs/skill-web-editor/index.esm.d.ts",
-      "import": "./dist/libs/skill-web-editor/index.esm.js",
-      "default": "./dist/libs/skill-web-editor/index.cjs.js"
-    }
-  },
+  "version": "0.92.0",
   "keywords": [
     "digipair",
     "web",
     "util"
   ],
-  "nx": {
-    "name": "skill-web-editor"
-  },
-  "dependencies": {
-    "@digipair/engine": "0.91.0-0"
-  }
-}
+  "dependencies": {},
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js"
+}

package/pins-to-blockly.cjs.js

@@ -0,0 +1,628 @@
+'use strict';
+
+var index = require('./index.cjs2.js');
+
+function getPinsBlockDefinition(library, methodData, pinsId) {
+    const blockDefinition = {
+        type: pinsId,
+        message0: library.info['x-icon'] + ' ' + methodData.summary,
+        args0: [],
+        message1: '',
+        args1: [],
+        message2: '',
+        args2: [],
+        message3: '',
+        args3: [],
+        colour: '#b3aeee',
+        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)),
+        '__CONDITION__/if',
+        '__CONDITION__/each'
+    ];
+    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_schema_items, _requiredParamInputs_i_schema_items_$ref, _requiredParamInputs_i_schema_items1;
+        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_schema_items = requiredParamInputs[i].schema.items) == null ? void 0 : _requiredParamInputs_i_schema_items.$ref) === 'https://schemas.digipair.ai/pinsSettings' || ((_requiredParamInputs_i_schema_items1 = requiredParamInputs[i].schema.items) == null ? void 0 : (_requiredParamInputs_i_schema_items_$ref = _requiredParamInputs_i_schema_items1.$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'] + ' ' + (methodData.summary || componentName),
+        args0: [],
+        message1: '',
+        args1: [],
+        colour: '#ffca28',
+        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,
+            summary: properties[propertyName].summary || propertyName,
+            schema: properties[propertyName]
+        }));
+    let messageIndex = 0;
+    parameters.forEach((parameter, _index)=>{
+        if (!requiredFields.includes(parameter.name)) {
+            mutatorToolbox.push(parameter.name);
+        } else {
+            var _parameter_schema, _parameter_schema_items, _parameter_schema_items1;
+            blockDefinition['args1'].push({
+                type: 'field_label',
+                name: 'NAME_INPUT',
+                text: parameter.summary + '*'
+            });
+            if (((_parameter_schema = parameter.schema) == null ? void 0 : _parameter_schema.type) === 'array' && (((_parameter_schema_items = parameter.schema.items) == null ? void 0 : _parameter_schema_items.$ref) === 'https://schemas.digipair.ai/pinsSettings' || ((_parameter_schema_items1 = parameter.schema.items) == null ? void 0 : _parameter_schema_items1.$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, tags) {
+    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_summary = library.info.summary) != null ? _library_info_summary : library.info.title,
+                    contents: [
+                        ...library.paths ? Object.entries(library.paths).filter(([_path, pins])=>pins.post.tags.some((tag)=>tags.includes(tag))).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).filter(([_componentName, schema])=>schema.tags.some((tag)=>tags.includes(tag))).sort((a, b)=>a[0].localeCompare(b[0])) // Tri alphabétique par componentName
+                        .map(([componentName])=>({
+                                kind: 'block',
+                                type: library.info.title + '/__COMPONENTS__/' + componentName
+                            })) : []
+                    ]
+                };
+            }).filter((library)=>library.contents.length > 0)
+        ]
+    };
+    return toolbox;
+}
+function convertPinsLibrariesToBlocklyLibraries(pinsLibraries) {
+    return pinsLibraries.map((schema)=>{
+        var _schema_paths;
+        return index._extends({}, schema, {
+            paths: index._extends({}, Object.entries((_schema_paths = schema.paths) != null ? _schema_paths : {}).reduce((acc, [key, path])=>index._extends({}, acc, {
+                    [key]: index._extends({}, path, {
+                        post: index._extends({}, path.post, {
+                            parameters: !path.post.parameters ? [] : [
+                                ...path.post.parameters,
+                                ...path.post.parameters.filter((item)=>{
+                                    var _item_schema, _item_schema_items, _item_schema_items_$ref, _item_schema_items1;
+                                    return ((_item_schema = item.schema) == null ? void 0 : _item_schema.type) === 'array' && (((_item_schema_items = item.schema.items) == null ? void 0 : _item_schema_items.$ref) === 'https://schemas.digipair.ai/pinsSettings' || ((_item_schema_items1 = item.schema.items) == null ? void 0 : (_item_schema_items_$ref = _item_schema_items1.$ref) == null ? void 0 : _item_schema_items_$ref.includes('#/components/schemas/')));
+                                }).map((item)=>index._extends({}, item, {
+                                        name: item.name + '__EVALUATE',
+                                        summary: (item.summary || item.name) + ' (evaluate)',
+                                        required: false,
+                                        schema: {
+                                            type: 'string'
+                                        }
+                                    }))
+                            ]
+                        })
+                    })
+                }), {})),
+            components: !schema.components ? {} : index._extends({}, schema.components, {
+                schemas: index._extends({}, Object.entries(schema.components.schemas || {}).reduce((acc, [key, component])=>index._extends({}, acc, {
+                        [key]: index._extends({}, component, {
+                            properties: !component.properties ? {} : index._extends({}, component.properties, Object.entries(component.properties).filter(([_propertyKey, propertyValue])=>{
+                                var _propertyValue_items, _propertyValue_items_$ref, _propertyValue_items1;
+                                return propertyValue.type === 'array' && (((_propertyValue_items = propertyValue.items) == null ? void 0 : _propertyValue_items.$ref) === 'https://schemas.digipair.ai/pinsSettings' || ((_propertyValue_items1 = propertyValue.items) == null ? void 0 : (_propertyValue_items_$ref = _propertyValue_items1.$ref) == null ? void 0 : _propertyValue_items_$ref.includes('#/components/schemas/')));
+                            }).reduce((acc, [propertyKey, property])=>index._extends({}, acc, {
+                                    [propertyKey + '__EVALUATE']: index._extends({}, property, {
+                                        summary: (property.summary || propertyKey) + ' (evaluate)',
+                                        required: false,
+                                        schema: {
+                                            type: 'string'
+                                        }
+                                    })
+                                }), {}))
+                        })
+                    }), {}))
+            }),
+            'x-scene-blocks': index._extends({}, Object.entries(schema['x-scene-blocks'] || {}).reduce((acc, [key, path])=>index._extends({}, acc, {
+                    [key]: index._extends({}, path, {
+                        metadata: !path.metadata ? [] : [
+                            ...path.metadata,
+                            ...path.metadata.filter((item)=>{
+                                var _item_schema, _item_schema_items, _item_schema_items_$ref, _item_schema_items1;
+                                return ((_item_schema = item.schema) == null ? void 0 : _item_schema.type) === 'array' && (((_item_schema_items = item.schema.items) == null ? void 0 : _item_schema_items.$ref) === 'https://schemas.digipair.ai/pinsSettings' || ((_item_schema_items1 = item.schema.items) == null ? void 0 : (_item_schema_items_$ref = _item_schema_items1.$ref) == null ? void 0 : _item_schema_items_$ref.includes('#/components/schemas/')));
+                            }).map((item)=>index._extends({}, item, {
+                                    name: item.name + '__EVALUATE',
+                                    summary: (item.summary || item.name) + ' (evaluate)',
+                                    required: false,
+                                    schema: {
+                                        type: 'string'
+                                    }
+                                }))
+                        ],
+                        parameters: !path.parameters ? [] : [
+                            ...path.parameters,
+                            ...path.parameters.filter((item)=>{
+                                var _item_schema, _item_schema_items, _item_schema_items_$ref, _item_schema_items1;
+                                return ((_item_schema = item.schema) == null ? void 0 : _item_schema.type) === 'array' && (((_item_schema_items = item.schema.items) == null ? void 0 : _item_schema_items.$ref) === 'https://schemas.digipair.ai/pinsSettings' || ((_item_schema_items1 = item.schema.items) == null ? void 0 : (_item_schema_items_$ref = _item_schema_items1.$ref) == null ? void 0 : _item_schema_items_$ref.includes('#/components/schemas/')));
+                            }).map((item)=>index._extends({}, item, {
+                                    name: item.name + '__EVALUATE',
+                                    summary: (item.summary || item.name) + ' (evaluate)',
+                                    required: false,
+                                    schema: {
+                                        type: 'string'
+                                    }
+                                }))
+                        ]
+                    })
+                }), {}))
+        });
+    });
+}
+function generateBlocklyBlockFromLibraries(pinsLibraries, blocksLegacy) {
+    const blocksLibrary = [
+        ...blocksLegacy
+    ];
+    const blocklyLibraries = convertPinsLibrariesToBlocklyLibraries(pinsLibraries);
+    for (const pinsLibrary of blocklyLibraries){
+        //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 blocklyLibraries){
+        //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 blocklyLibraries){
+        //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;
+                const block = getSceneBlockDefinition(pinsLibrary, endpointSceneblock, sceneBlockId);
+                blocksLibrary.push(block);
+            }
+        }
+    }
+    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, originParameters) {
+    const parameters = [
+        ...originParameters,
+        {
+            name: '__CONDITION__/if',
+            schema: {
+                type: 'boolean'
+            }
+        },
+        {
+            name: '__CONDITION__/each',
+            schema: {
+                type: 'array',
+                items: {
+                    type: 'object'
+                }
+            }
+        }
+    ];
+    const toolboxList = [];
+    for (const item of toolboxItem){
+        Blockly.Blocks[mutatorName + '/' + item] = {
+            init: function() {
+                this.appendDummyInput(item).appendField(item.includes('__EVENT__/') ? item.replace('__EVENT__/', '@') : item.includes('__CONDITION__/') ? item.replace('__CONDITION__/', '#') : 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) || /__INPUT$/g.test(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.replace(/__INPUT$/g, ''))) {
+                    this.removeInput(input);
+                }
+            }
+            for (const input of inputToEnable){
+                if (requiredFields.includes(input)) {
+                    continue;
+                }
+                if (!inputLoaded.includes(input.id)) {
+                    var _parameter_schema, _parameter_schema_items, _parameter_schema_items_$ref, _parameter_schema_items1;
+                    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_schema_items = parameter.schema.items) == null ? void 0 : _parameter_schema_items.$ref) === 'https://schemas.digipair.ai/pinsSettings' || ((_parameter_schema_items1 = parameter.schema.items) == null ? void 0 : (_parameter_schema_items_$ref = _parameter_schema_items1.$ref) == null ? void 0 : _parameter_schema_items_$ref.includes('#/components/schemas/')))) {
+                        this.appendDummyInput(input.id + '__INPUT').appendField(input.name);
+                        this.appendStatementInput(input.id);
+                    } else if (input.id === 'pins') {
+                        this.appendDummyInput(input.id + '__INPUT').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: '#212e3c',
+        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://schemas.digipair.ai/pinsSettings'
+                }
+            }
+        };
+        parameters.push(parameter);
+    }
+    const requiredParamInputs = parameters.filter((param)=>param.required === true);
+    const requiredFields = [
+        ...requiredParamInputs.map((param)=>param.name),
+        ...metadata.map((param)=>'metadata--' + param.name)
+    ];
+    requiredFields.push('');
+    // metadata
+    for(let i = 0; i < (metadata == null ? void 0 : metadata.length); i++){
+        var _parameter_schema, _parameter_schema_items, _parameter_schema_items_$ref, _parameter_schema_items1;
+        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 = parameter.schema.items) == null ? void 0 : _parameter_schema_items.$ref) === 'https://schemas.digipair.ai/pinsSettings' || ((_parameter_schema_items1 = parameter.schema.items) == null ? void 0 : (_parameter_schema_items_$ref = _parameter_schema_items1.$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_items2, _parameter_schema_items_$ref1, _parameter_schema_items3;
+        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_items2 = parameter.schema.items) == null ? void 0 : _parameter_schema_items2.$ref) === 'https://schemas.digipair.ai/pinsSettings' || ((_parameter_schema_items3 = parameter.schema.items) == null ? void 0 : (_parameter_schema_items_$ref1 = _parameter_schema_items3.$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;
+}
+
+exports.generateBlocklyBlockFromLibraries = generateBlocklyBlockFromLibraries;
+exports.generateToolboxFromLibraries = generateToolboxFromLibraries;
+exports.initializeMutator = initializeMutator;