@lcap/nasl 2.20.1-beta.2 → 2.21.0-beta.1

package/src/templator/dist/utils.js

@@ -0,0 +1,527 @@
+"use strict";
+exports.__esModule = true;
+exports.NaslNode = exports.NaslQueryExpression = exports.NaslLogicItem = exports.NaslCollectionTypeAnnotation = exports.NaslTypeAnnotation = exports.NaslUITypeAnnotation = exports.NaslCoreTypeAnnotation = exports.genUniqueQueryNameGroup = exports.genMemberExpression = exports.genLogicParam = exports.getFirstDisplayedProperty = exports.getParamFromLogic = exports.getExpression = exports.filterProperty = void 0;
+var __1 = require("..");
+exports.filterProperty = function (key) { return function (property) {
+    if (property.display) {
+        return property.display[key];
+    }
+    else {
+        return !['id', 'createdTime', 'updatedTime'].includes(property.name);
+    }
+}; };
+/**
+ * 生成表达式的代码
+ * @param property 实体属性
+ * @param expression 表达式
+ */
+function getExpression(property, expression) {
+    var typeAnnotation = (property || {}).typeAnnotation;
+    var _a = typeAnnotation || {}, propertyTypeName = _a.typeName, propertyTypeNamespace = _a.typeNamespace;
+    if (propertyTypeName === 'DateTime')
+        return "$utils['FormatDateTime'](" + expression + ", 'YYYY-MM-DD HH:mm:ss')";
+    else if (propertyTypeName === 'Date')
+        return "$utils['FormatDate'](" + expression + ", 'YYYY-MM-DD')";
+    else {
+        var namespaceArr = propertyTypeNamespace.split('.');
+        var type = namespaceArr.pop();
+        if (type === 'enums') {
+            return "$utils['EnumValueToText'](" + expression + ", '__enumTypeAnnotation_" + propertyTypeNamespace + "." + propertyTypeName + "')";
+        }
+        else {
+            return "" + (expression || "''");
+        }
+    }
+}
+exports.getExpression = getExpression;
+/**
+ * 从 Logic 中获取变量
+ * @param resolver
+ * @param paramName
+ */
+function getParamFromLogic(logic, paramName) {
+    var params = logic.params;
+    return params.find(function (item) { return item.name === paramName; });
+}
+exports.getParamFromLogic = getParamFromLogic;
+function getFirstDisplayedProperty(entity) {
+    var property = entity.properties.find(function (property) { return !property.readonly; });
+    if (!property)
+        property = entity.properties[0];
+    return property;
+}
+exports.getFirstDisplayedProperty = getFirstDisplayedProperty;
+function genArgumentMemberExpression(arr) {
+    var expressionNode;
+    var propertyName = arr.pop();
+    if (arr.length >= 1) {
+        expressionNode = exports.NaslLogicItem.MemberExpression({
+            object: genArgumentMemberExpression(arr),
+            property: exports.NaslLogicItem.Identifier({
+                name: propertyName
+            })
+        });
+    }
+    else {
+        return exports.NaslLogicItem.Identifier({
+            name: propertyName
+        });
+    }
+    return expressionNode;
+}
+/**
+ * 生成逻辑 Param
+ * @param paramIdOrName 参数 id 或引用名称
+ * @param expression 表达式
+ * @param schemaChildren 数据结构
+ */
+function genLogicParam(paramIdOrName, expression) {
+    return exports.NaslLogicItem.Argument({
+        keyword: paramIdOrName,
+        expression: genArgumentMemberExpression(expression.split('.'))
+    });
+}
+exports.genLogicParam = genLogicParam;
+/**
+ * 生成接口 Param
+ * @param paramIdOrName 参数 id 或引用名称
+ * @param expression 表达式
+ * @param schemaChildren 数据结构
+ */
+function genMemberExpression(expression, schemaRefs) {
+    if (schemaRefs === void 0) { schemaRefs = []; }
+    var arr = expression.split('.');
+    var expressionNode;
+    arr.forEach(function (name, index) {
+        var currentNode = exports.NaslLogicItem.Identifier({
+            name: name
+        });
+        if (expressionNode) {
+            expressionNode = exports.NaslLogicItem.MemberExpression({
+                object: expressionNode,
+                property: exports.NaslLogicItem.Identifier({
+                    name: name
+                })
+            });
+        }
+        else {
+            expressionNode = currentNode;
+        }
+    });
+    return expressionNode;
+}
+exports.genMemberExpression = genMemberExpression;
+function capFirstLetter(word) {
+    if (!word)
+        return word;
+    return word[0].toUpperCase() + word.slice(1);
+}
+/**
+ * 生成数据查询唯一的命名组
+ * @param viewName 页面名称
+ * @param componentName 组件名称
+ * @param suffix 其它后缀，比如实体名等等
+ * @param defaultInView 是否在页面逻辑中用 load 简写
+ */
+function genUniqueQueryNameGroup(scope, view, componentName, defaultInView, suffix) {
+    if (componentName === void 0) { componentName = ''; }
+    if (defaultInView === void 0) { defaultInView = true; }
+    if (suffix === void 0) { suffix = ''; }
+    var result = {};
+    result.viewLogicLoad = view.getLogicUniqueName("load" + (defaultInView ? '' : capFirstLetter(componentName)) + (suffix ? capFirstLetter(suffix) : ''));
+    result.logic = scope.getLogicUniqueName("load" + capFirstLetter(view.name) + (componentName ? capFirstLetter(componentName) : '') + (suffix ? capFirstLetter(suffix) : ''));
+    result.structure = scope.getStructureUniqueName(__1.utils.firstUpperCase(result.logic + 'Structure'));
+    return result;
+}
+exports.genUniqueQueryNameGroup = genUniqueQueryNameGroup;
+function genNaslCoreTypeAnnotation(typeName, text) {
+    if (text === void 0) { text = ''; }
+    return {
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'primitive',
+        typeNamespace: 'nasl.core',
+        typeName: typeName,
+        text: text
+    };
+}
+function genNaslUITypeAnnotation(typeName) {
+    return {
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'reference',
+        typeNamespace: 'nasl.ui',
+        typeName: typeName
+    };
+}
+function genNaslCollectionTypeAnnotation(typeName) {
+    return function (typeArguments) { return ({
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'generic',
+        typeNamespace: 'nasl.collection',
+        typeName: typeName,
+        typeArguments: typeArguments
+    }); };
+}
+function genNaslUIGenericTypeAnnotation(typeName) {
+    return function (typeArguments) { return ({
+        concept: 'TypeAnnotation',
+        name: '',
+        typeKind: 'generic',
+        typeNamespace: 'nasl.ui',
+        typeName: typeName,
+        typeArguments: typeArguments
+    }); };
+}
+exports.NaslCoreTypeAnnotation = {
+    Boolean: genNaslCoreTypeAnnotation('Boolean'),
+    Integer: genNaslCoreTypeAnnotation('Integer', 'Integer 整数'),
+    Double: genNaslCoreTypeAnnotation('Double'),
+    Decimal: genNaslCoreTypeAnnotation('Decimal'),
+    Long: genNaslCoreTypeAnnotation('Long', 'Long 长整数'),
+    String: genNaslCoreTypeAnnotation('String', 'String 字符串'),
+    Text: genNaslCoreTypeAnnotation('Text'),
+    Binary: genNaslCoreTypeAnnotation('Binary'),
+    Date: genNaslCoreTypeAnnotation('Date'),
+    Time: genNaslCoreTypeAnnotation('Time'),
+    DateTime: genNaslCoreTypeAnnotation('DateTime'),
+    Email: genNaslCoreTypeAnnotation('Email')
+};
+exports.NaslUITypeAnnotation = {
+    DataSourceParams: genNaslUITypeAnnotation('DataSourceParams'),
+    EventTarget: genNaslUITypeAnnotation('EventTarget'),
+    MouseEvent: genNaslUITypeAnnotation('MouseEvent'),
+    FocusEvent: genNaslUITypeAnnotation('FocusEvent'),
+    ChangeEvent: genNaslUITypeAnnotation('ChangeEvent'),
+    NavigateEvent: genNaslUITypeAnnotation('NavigateEvent'),
+    ChangeItemEvent: genNaslUITypeAnnotation('ChangeItemEvent'),
+    ChangeItemsEvent: genNaslUITypeAnnotation('ChangeItemsEvent'),
+    CascadeCapsulesEvent: genNaslUITypeAnnotation('CascadeCapsulesEvent'),
+    CollapseEvent: genNaslUITypeAnnotation('CollapseEvent'),
+    SliderEvent: genNaslUITypeAnnotation('SliderEvent'),
+    DateEvent: genNaslUITypeAnnotation('DateEvent'),
+    OperatorItemEvent: genNaslUITypeAnnotation('OperatorItemEvent'),
+    ValidateEvent: genNaslUITypeAnnotation('ValidateEvent'),
+    PaginationEvent: genNaslUITypeAnnotation('PaginationEvent'),
+    DurationEvent: genNaslUITypeAnnotation('DurationEvent'),
+    TransferEvent: genNaslUITypeAnnotation('TransferEvent'),
+    TreeChangeEvent: genNaslUITypeAnnotation('TreeChangeEvent'),
+    CheckedEvent: genNaslUITypeAnnotation('CheckedEvent'),
+    UploadEvent: genNaslUITypeAnnotation('UploadEvent'),
+    UploadErrorEvent: genNaslUITypeAnnotation('UploadErrorEvent'),
+    SortEvent: genNaslUITypeAnnotation('SortEvent'),
+    PoiInfo: genNaslUITypeAnnotation('PoiInfo'),
+    File: genNaslUITypeAnnotation('File'),
+    Current: genNaslUIGenericTypeAnnotation('Current')
+};
+exports.NaslTypeAnnotation = {
+    Reference: function (_a) {
+        var typeNamespace = _a.typeNamespace, typeName = _a.typeName;
+        return ({
+            concept: 'TypeAnnotation',
+            name: '',
+            typeKind: 'reference',
+            typeNamespace: typeNamespace,
+            typeName: typeName
+        });
+    },
+    AnonymousStructure: function (properties) { return ({
+        concept: 'TypeAnnotation',
+        typeKind: 'anonymousStructure',
+        properties: [{
+                concept: 'StructureProperty',
+                name: 'list',
+                typeAnnotation: {
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeName: 'List',
+                    typeNamespace: 'nasl.collection',
+                    typeArguments: [{
+                            concept: 'TypeAnnotation',
+                            typeKind: 'anonymousStructure',
+                            properties: properties
+                        }]
+                }
+            }, {
+                concept: 'StructureProperty',
+                name: 'total',
+                typeAnnotation: {
+                    concept: 'TypeAnnotation',
+                    typeKind: 'primitive',
+                    typeNamespace: 'nasl.core',
+                    typeName: 'Integer'
+                }
+            }]
+    }); }
+};
+exports.NaslCollectionTypeAnnotation = {
+    List: genNaslCollectionTypeAnnotation('List'),
+    PageOf: genNaslCollectionTypeAnnotation('PageOf')
+};
+exports.NaslLogicItem = {
+    // 开始
+    Start: {
+        concept: 'Start',
+        name: '',
+        label: '开始',
+        kind: 'Statement'
+    },
+    // 结束
+    End: {
+        concept: 'End',
+        name: '',
+        label: '结束',
+        kind: 'Statement'
+    },
+    // 调用逻辑
+    CallLogic: function (_a) {
+        var calleeNamespace = _a.calleeNamespace, calleeName = _a.calleeName, _b = _a.label, label = _b === void 0 ? '调用逻辑' : _b, _c = _a.shortcut, shortcut = _c === void 0 ? false : _c, args = _a.arguments;
+        return ({
+            concept: 'CallLogic',
+            name: '',
+            label: label,
+            kind: 'Statement',
+            shortcut: shortcut,
+            calleeNamespace: calleeNamespace,
+            calleeName: calleeName,
+            arguments: args
+        });
+    },
+    // 内置函数
+    CallFunction: function (_a) {
+        var _b = _a.calleeNamespace, calleeNamespace = _b === void 0 ? 'nasl.util' : _b, calleeName = _a.calleeName, _c = _a.label, label = _c === void 0 ? '内置函数' : _c, _d = _a.shortcut, shortcut = _d === void 0 ? false : _d, _e = _a.arguments, args = _e === void 0 ? [] : _e;
+        return ({
+            concept: 'CallFunction',
+            name: '',
+            label: '调用逻辑',
+            kind: 'Expression',
+            calleeNamespace: calleeNamespace,
+            calleeName: calleeName,
+            arguments: args
+        });
+    },
+    // 参数
+    Argument: function (_a) {
+        var keyword = _a.keyword, expression = _a.expression;
+        return ({
+            concept: 'Argument',
+            name: '',
+            kind: 'Statement',
+            keyword: keyword,
+            expression: expression
+        });
+    },
+    // 成员表达式
+    MemberExpression: function (_a) {
+        var object = _a.object, property = _a.property;
+        return ({
+            concept: 'MemberExpression',
+            name: '',
+            kind: 'Expression',
+            object: object,
+            property: property
+        });
+    },
+    // 变量
+    Identifier: function (_a) {
+        var name = _a.name;
+        return ({
+            concept: 'Identifier',
+            kind: 'Expression',
+            name: name
+        });
+    },
+    // 字面量
+    StringLiteral: function (_a) {
+        var value = _a.value;
+        return ({
+            concept: 'StringLiteral',
+            name: '',
+            kind: 'Expression',
+            value: value
+        });
+    },
+    Assignment: function (_a) {
+        var left = _a.left, right = _a.right;
+        return ({
+            concept: 'Assignment',
+            name: '',
+            label: '赋值',
+            kind: 'Statement',
+            left: left,
+            right: right
+        });
+    },
+    IfStatement: function (_a) {
+        var test = _a.test, consequent = _a.consequent, alternate = _a.alternate;
+        return ({
+            concept: 'IfStatement',
+            name: '',
+            kind: 'Statement',
+            test: test,
+            consequent: consequent,
+            alternate: alternate
+        });
+    },
+    // 二元
+    BinaryExpression: function (_a) {
+        var operator = _a.operator, left = _a.left, _b = _a.label, label = _b === void 0 ? '算术运算' : _b, right = _a.right;
+        return ({
+            concept: 'BinaryExpression',
+            name: '',
+            kind: 'Expression',
+            label: label,
+            operator: operator,
+            left: left,
+            right: right
+        });
+    }
+};
+exports.NaslQueryExpression = {
+    QueryFieldExpression: function (_a) {
+        var label = _a.label, isDotStar = _a.isDotStar, entityAsName = _a.entityAsName, propertyName = _a.propertyName;
+        return ({
+            concept: 'QueryFieldExpression',
+            name: '',
+            label: label,
+            kind: 'Expression',
+            isDotStar: isDotStar,
+            entityAsName: entityAsName,
+            propertyName: propertyName
+        });
+    },
+    QueryFromExpression: function (_a) {
+        var entityNamespace = _a.entityNamespace, entityName = _a.entityName, joinParts = _a.joinParts;
+        return ({
+            concept: 'QueryFromExpression',
+            name: '',
+            kind: 'Expression',
+            entityNamespace: entityNamespace,
+            entityName: entityName,
+            joinParts: joinParts
+        });
+    },
+    QueryJoinExpression: function (_a) {
+        var label = _a.label, entityNamespace = _a.entityNamespace, entityName = _a.entityName, joinType = _a.joinType, onExpressions = _a.onExpressions, joinParts = _a.joinParts;
+        return ({
+            concept: 'QueryJoinExpression',
+            label: label,
+            name: '',
+            kind: 'Expression',
+            entityNamespace: entityNamespace,
+            entityName: entityName,
+            joinType: joinType,
+            onExpressions: onExpressions,
+            joinParts: joinParts
+        });
+    },
+    QuerySelectExpression: function (_a) {
+        var label = _a.label, distinct = _a.distinct, star = _a.star, selectElements = _a.selectElements;
+        return ({
+            concept: 'QuerySelectExpression',
+            name: '',
+            kind: 'Expression',
+            label: label,
+            distinct: distinct,
+            star: star,
+            selectElements: selectElements
+        });
+    },
+    QueryOrderByExpression: function (_a) {
+        var label = _a.label, order = _a.order, orderElement = _a.orderElement;
+        return ({
+            concept: 'QueryOrderByExpression',
+            label: label,
+            order: order,
+            orderElement: orderElement
+        });
+    },
+    QueryLimitExpression: function (_a) {
+        var label = _a.label, pageElement = _a.pageElement, pageSizeElement = _a.pageSizeElement;
+        return ({
+            concept: 'QueryLimitExpression',
+            name: '',
+            kind: 'Expression',
+            label: label,
+            pageElement: pageElement,
+            pageSizeElement: pageSizeElement
+        });
+    },
+    CallQueryComponent: function (_a) {
+        var label = _a.label, typeAnnotation = _a.typeAnnotation, select = _a.select, from = _a.from, where = _a.where, limit = _a.limit, groupBy = _a.groupBy, having = _a.having, orderBy = _a.orderBy, logicName = _a.logicName, structureName = _a.structureName, ideVersion = _a.ideVersion;
+        return ({
+            concept: 'CallQueryComponent',
+            name: '',
+            label: label,
+            kind: 'Statement',
+            typeAnnotation: typeAnnotation,
+            select: select,
+            from: from,
+            where: where,
+            limit: limit,
+            groupBy: groupBy,
+            having: having,
+            orderBy: orderBy,
+            logicName: logicName,
+            structureName: structureName,
+            ideVersion: ideVersion
+        });
+    }
+};
+exports.NaslNode = {
+    Logic: function (_a) {
+        var name = _a.name, params = _a.params, returns = _a.returns, variables = _a.variables, body = _a.body, description = _a.description, playground = _a.playground;
+        return ({
+            concept: 'Logic',
+            name: name,
+            params: params,
+            returns: returns,
+            variables: variables,
+            body: body,
+            description: description,
+            playground: playground
+        });
+    },
+    Structure: function (_a) {
+        var name = _a.name, properties = _a.properties, origin = _a.origin;
+        return ({
+            concept: 'Structure',
+            name: name,
+            properties: properties,
+            origin: origin
+        });
+    },
+    StructureProperty: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'StructureProperty',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    },
+    Variable: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'Variable',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    },
+    Param: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'Param',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    },
+    Return: function (_a) {
+        var name = _a.name, typeAnnotation = _a.typeAnnotation;
+        return ({
+            concept: 'Return',
+            name: name,
+            typeAnnotation: typeAnnotation
+        });
+    }
+};

package/src/templator/genEditTableBlock.ts

@@ -111,7 +111,7 @@ export function genEditTableTemplate(entity: Entity, nameGroup: NameGroup, selec
 
     return `<u-table-view ref="${nameGroup.viewElementMainView}" :data-source="${nameGroup.viewLogicLoad}" data-schema="${nameGroup.structure}"
         value-field="${nameGroup.viewVariableEntity}.id"
-        :pageable="true" :remote-paging="true" :show-sizer="true" :default-column-width="300" editable>
+        :pagination="true" :show-sizer="true" :default-column-width="300" editable>
     <u-table-view-column type="index" width="60"><template #title><u-text text="序号"></u-text></template><template #cell="current"></template></u-table-view-column>
 
     ${properties.map((property) => genEditTableColumnTemplate(entity, property, nameGroup, selectNameGroupMap) + '\n').join('')}

package/src/templator/genQueryComponent.ts

@@ -166,11 +166,11 @@ export function genQueryLogic(allEntities: Array<Entity>, nameGroup: NameGroup,
         params: [
             NaslNode.Param({
                 name: 'page',
-                typeAnnotation: NaslCoreTypeAnnotation.Integer,
+                typeAnnotation: NaslCoreTypeAnnotation.Long,
             }),
             NaslNode.Param({
                 name: 'size',
-                typeAnnotation: NaslCoreTypeAnnotation.Integer,
+                typeAnnotation: NaslCoreTypeAnnotation.Long,
             }),
         ],
         returns: [
@@ -276,10 +276,10 @@ export async function joinEntity(callQueryComponent: CallQueryComponent, entity:
             typeName: entity.name,
         }),
     }), recordStructure, 'properties');
-    
-    if(recordStructure instanceof Structure)
+
+    if (recordStructure instanceof Structure)
         recordStructure.addProperty(structureProperty);
-    else if(recordStructure instanceof TypeAnnotation)
+    else if (recordStructure instanceof TypeAnnotation)
         recordStructure.properties.push(structureProperty);
 
     const newJoinPartLogicItem = QueryJoinExpression.from(queryJoinExpression, callQueryComponent, 'joinParts');

package/src/templator/genTableBlock.ts

@@ -63,7 +63,7 @@ export function genTableTemplate(entity: Entity, nameGroup: NameGroup, modifyabl
 
     return `<u-table-view ref="${nameGroup.viewElementMainView}" :data-source="${nameGroup.viewLogicLoad}" data-schema="${nameGroup.structure}"
         value-field="${nameGroup.viewVariableEntity}.id"
-        :pageable="true" :remote-paging="true" :show-sizer="true">
+        :pagination="true" :show-sizer="true">
     <u-table-view-column type="index" width="60"><template #title><u-text text="序号"></u-text></template><template #cell="current"></template></u-table-view-column>
 
     ${properties.map((property) => genTableColumnTemplate(property, currentName) + '\n').join('')}
@@ -258,7 +258,7 @@ export function genTableColumnBlock(property: EntityProperty, oldNode: ViewEleme
 
     return `
 <template>
-    <u-table-view ref="${nameGroup.viewElementMainView}" :data-source="${nameGroup.viewLogicLoad}" :pageable="true" :remote-paging="true" :show-sizer="true" data-schema="${nameGroup.structure}">
+    <u-table-view ref="${nameGroup.viewElementMainView}" :data-source="${nameGroup.viewLogicLoad}" :pagination="true" :show-sizer="true" data-schema="${nameGroup.structure}">
         ${properties.map((property) => genTableColumnTemplate(property) + '\n').join('')}
     </u-table-view>
 </template>

package/src/templator/utils.ts

@@ -189,17 +189,17 @@ function genNaslUIGenericTypeAnnotation(typeName: string) {
 
 export const NaslCoreTypeAnnotation = {
     Boolean: genNaslCoreTypeAnnotation('Boolean'),
-    Integer: genNaslCoreTypeAnnotation('Integer', 'Integer 整数'),
-    Double: genNaslCoreTypeAnnotation('Double'),
+    // Integer: genNaslCoreTypeAnnotation('Integer', 'Integer 整数'),
+    // Double: genNaslCoreTypeAnnotation('Double'),
     Decimal: genNaslCoreTypeAnnotation('Decimal'),
-    Long: genNaslCoreTypeAnnotation('Long', 'Long 长整数'),
-    String: genNaslCoreTypeAnnotation('String', 'String 字符串'),
-    Text: genNaslCoreTypeAnnotation('Text'),
+    Long: genNaslCoreTypeAnnotation('Long', ' Integer 整数'),
+    String: genNaslCoreTypeAnnotation('String', 'String 文本'),
+    // Text: genNaslCoreTypeAnnotation('Text'),
     Binary: genNaslCoreTypeAnnotation('Binary'),
     Date: genNaslCoreTypeAnnotation('Date'),
     Time: genNaslCoreTypeAnnotation('Time'),
     DateTime: genNaslCoreTypeAnnotation('DateTime'),
-    Email: genNaslCoreTypeAnnotation('Email'),
+    // Email: genNaslCoreTypeAnnotation('Email'),
 };
 
 export const NaslUITypeAnnotation = {
@@ -262,7 +262,7 @@ export const NaslTypeAnnotation = {
                 concept: 'TypeAnnotation',
                 typeKind: 'primitive',
                 typeNamespace: 'nasl.core',
-                typeName: 'Integer',
+                typeName: 'Long',
             },
         }],
     }),

package/ts-worker/lib/Messager.js

@@ -138,6 +138,7 @@ class Messager {
      * @override
      */
     onMessageReceived(e) {
+        console.log('onMessageReceived: ', e);
         if (!e.data)
             return;
         this.onDataReceived(e.data);
@@ -147,6 +148,7 @@ class Messager {
      * @override
      */
     onDataReceived(data) {
+        console.log('onDataReceived: ', data);
         if (data.protocol !== this.options.protocol)
             return;
         if (data.type === 'response') {
@@ -158,15 +160,18 @@ class Messager {
         }
         if (data.command) {
             const func = this.options.context[data.command];
+            console.log('func: ', this.options.context, func);
             if (!func)
                 // 函数不存在时不 response
                 return;
 
             let res;
-            if (typeof func === 'function')
+            if (typeof func === 'function') {
                 res = func.call(this.options.context, ...data.args, data.id);
-            else
+            } else {
                 res = func;
+            }
+
             if (data.type === 'request') {
                 return Promise.resolve(res)
                     .then((result) => {

package/ts-worker/src/index.js

@@ -141,6 +141,7 @@ const context = {
     },
     // 在初始化之前添加文件
     addFile(file) {
+        console.log('ts-worker addFile');
         this.system.writeFile(file.file, file.fileContent);
     },
     /**