@lcap/nasl 2.18.0-beta.4 → 2.18.0

package/src/concepts/Param__.ts

@@ -304,7 +304,7 @@ export class Param extends BaseNode {
     }
 
     isEnum() {
-        return this.typeAnnotation?.typeNamespace.endsWith('.enums');
+        return this.typeAnnotation?.typeNamespace?.endsWith('.enums');
     }
 
     @withSourceMap()

package/src/concepts/Return__.ts

@@ -292,7 +292,7 @@ export class Return extends BaseNode {
         return code;
     }
     isEnum() {
-        return this.typeAnnotation?.typeNamespace.endsWith('.enums');
+        return this.typeAnnotation?.typeNamespace?.endsWith('.enums');
     }
     @withSourceMap()
     toEmbeddedTSInProcess(state?: TranslatorState): string {

package/src/concepts/Variable__.ts

@@ -291,7 +291,7 @@ export class Variable extends BaseNode {
         return code;
     }
     isEnum() {
-        return this.typeAnnotation?.typeNamespace.endsWith('.enums');
+        return this.typeAnnotation?.typeNamespace?.endsWith('.enums');
     }
     getNamespace() {
         if (this.parentNode && (this.parentNode as Namespace).getNamespace) {

package/src/concepts/basics/stdlib/dist/reference2TypeAnnotationList.js

@@ -0,0 +1,24 @@
+"use strict";
+exports.__esModule = true;
+exports.reference2TypeAnnotationList = void 0;
+var Structure__1 = require("../../Structure__");
+var TypeAnnotation__1 = require("../../TypeAnnotation__");
+function reference2TypeAnnotationList(list, namespace) {
+    if (list === void 0) { list = []; }
+    return list.map(function (item) {
+        var _a;
+        if (item instanceof Structure__1["default"] && ((_a = item.typeParams) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            return TypeAnnotation__1["default"].createReference(item.name, {
+                typeKind: 'generic',
+                typeNamespace: namespace,
+                typeArguments: item.typeParams.map(function (typeParam) { return new TypeAnnotation__1["default"]({ name: typeParam.name }); })
+            });
+        }
+        else {
+            return TypeAnnotation__1["default"].createReference(item.name, {
+                typeNamespace: namespace
+            });
+        }
+    });
+}
+exports.reference2TypeAnnotationList = reference2TypeAnnotationList;

package/src/concepts/dist/Anchor__.js

@@ -0,0 +1,179 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+exports.__esModule = true;
+exports.Anchor = void 0;
+var translator_1 = require("../translator");
+var decorators_1 = require("../decorators");
+var utils = require("../utils");
+var classMap_1 = require("../common/classMap");
+var LogicItem__1 = require("./LogicItem__");
+/**
+ * 锚点参数
+ */
+var Anchor = /** @class */ (function (_super) {
+    __extends(Anchor, _super);
+    /**
+     * @param source 需要合并的部分参数
+     */
+    function Anchor(source) {
+        var _this = this;
+        source = Object.assign({}, Anchor_1.getDefaultOptions(), source);
+        _this = _super.call(this, source) || this;
+        /**
+         * 产品概念
+         */
+        _this.concept = 'Anchor';
+        /**
+         * 参数值
+         */
+        _this.expression = undefined;
+        _super.prototype.subConstructor.call(_this, source);
+        return _this;
+    }
+    Anchor_1 = Anchor;
+    Anchor.from = function (source, parentNode, parentKey) {
+        return _super.from.call(this, source, parentNode, parentKey);
+    };
+    /**
+     * 设置参数值
+     */
+    Anchor.prototype.setExpression = function (expression) {
+        expression._delete();
+        var relationOptions = { parentNode: this, parentKey: 'expression' };
+        Object.assign(expression, relationOptions);
+        var object = {
+            expression: expression
+        };
+        this.update(__assign({}, object));
+    };
+    Anchor.prototype.removeExpression = function (options) {
+        var expression;
+        if (typeof options === 'string') {
+            expression = this.expression;
+            if (!expression) {
+                throw new Error('找不到逻辑项 ' + options);
+            }
+        }
+        else {
+            expression = options;
+        }
+        return expression["delete"]();
+    };
+    Anchor.prototype.__removeLogicItem = function (logicItem) {
+        var parentKey = logicItem.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: logicItem
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(logicItem);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === logicItem) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    Anchor.prototype.toVue = function (options) {
+        return this.expression ? this.expression.toVue(options) : '';
+    };
+    Anchor.prototype.toUI = function (state) {
+        var code = '';
+        if (this.expression) {
+            code += this.expression.toUI(translator_1.shiftState(state, code));
+        }
+        else {
+            code += '';
+        }
+        return code;
+    };
+    Anchor.prototype.toJS = function (state) {
+        var code = '';
+        if (this.expression) {
+            code += this.expression.toJS(translator_1.shiftState(state, code));
+        }
+        else {
+            code += '';
+        }
+        return code;
+    };
+    Anchor.prototype.toBrief = function () {
+        var expr = utils.toBriefExpr(this.expression);
+        return "<span style=\"color: #AAAAAA\">\u951A\u70B9 = </span><span style=\"color: #FFFFFF\">" + expr + "</span>";
+    };
+    Anchor.prototype.toEmbeddedTS = function (state, isHaveKeyWord) {
+        var code = '';
+        if (isHaveKeyWord) {
+            code += "_anchor: ";
+        }
+        if (this.expression) {
+            code += this.expression.toEmbeddedTS(translator_1.shiftState(state, code), false);
+        }
+        else {
+            code += 'undefined';
+        }
+        return code;
+    };
+    var Anchor_1;
+    __decorate([
+        decorators_1.property()
+    ], Anchor.prototype, "concept");
+    __decorate([
+        decorators_1.property('LogicItem')
+    ], Anchor.prototype, "expression");
+    __decorate([
+        translator_1.withSourceMap()
+    ], Anchor.prototype, "toEmbeddedTS");
+    Anchor = Anchor_1 = __decorate([
+        decorators_1.concept('锚点参数')
+    ], Anchor);
+    return Anchor;
+}(LogicItem__1["default"]));
+exports.Anchor = Anchor;
+classMap_1["default"].Anchor = Anchor;
+exports["default"] = Anchor;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/dist/Assignment__.js

@@ -0,0 +1,301 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+exports.__esModule = true;
+exports.Assignment = void 0;
+var translator_1 = require("../translator");
+var Identifier__1 = require("./Identifier__");
+var BatchAssignment__1 = require("./BatchAssignment__");
+var SelectMembers__1 = require("./SelectMembers__");
+var AssignmentLine__1 = require("./AssignmentLine__");
+var decorators_1 = require("../decorators");
+var classMap_1 = require("../common/classMap");
+var LogicItem__1 = require("./LogicItem__");
+/**
+ * 赋值语句
+ */
+var Assignment = /** @class */ (function (_super) {
+    __extends(Assignment, _super);
+    /**
+     * @param source 需要合并的部分参数
+     */
+    function Assignment(source) {
+        var _this = this;
+        source = Object.assign({}, Assignment_1.getDefaultOptions(), source);
+        _this = _super.call(this, source) || this;
+        /**
+         * 产品概念
+         */
+        _this.concept = 'Assignment';
+        /**
+         * 赋值语句标题
+         */
+        _this.label = '赋值';
+        /**
+         * 左边项
+         */
+        _this.left = undefined;
+        /**
+         * 右边项
+         */
+        _this.right = undefined;
+        _super.prototype.subConstructor.call(_this, source);
+        return _this;
+    }
+    Assignment_1 = Assignment;
+    Assignment.from = function (source, parentNode, parentKey) {
+        return _super.from.call(this, source, parentNode, parentKey);
+    };
+    /**
+     * 设置左边项
+     */
+    Assignment.prototype.setLeft = function (left) {
+        left._delete();
+        var relationOptions = { parentNode: this, parentKey: 'left' };
+        Object.assign(left, relationOptions);
+        var object = {
+            left: left
+        };
+        this.update(__assign({}, object));
+    };
+    /**
+     * 设置右边项
+     */
+    Assignment.prototype.setRight = function (right) {
+        right._delete();
+        var relationOptions = { parentNode: this, parentKey: 'right' };
+        Object.assign(right, relationOptions);
+        var object = {
+            right: right
+        };
+        this.update(__assign({}, object));
+    };
+    Assignment.prototype.removeLeft = function (options) {
+        var left;
+        if (typeof options === 'string') {
+            left = this.left;
+            if (!left) {
+                throw new Error('找不到逻辑项 ' + options);
+            }
+        }
+        else {
+            left = options;
+        }
+        return left["delete"]();
+    };
+    Assignment.prototype.removeRight = function (options) {
+        var right;
+        if (typeof options === 'string') {
+            right = this.right;
+            if (!right) {
+                throw new Error('找不到逻辑项 ' + options);
+            }
+        }
+        else {
+            right = options;
+        }
+        return right["delete"]();
+    };
+    Assignment.prototype.__removeLogicItem = function (logicItem) {
+        var parentKey = logicItem.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: logicItem
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(logicItem);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === logicItem) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    Assignment.getDefaultOptions = function () {
+        return {
+            left: {
+                concept: 'Identifier',
+                name: ''
+            }
+        };
+    };
+    Assignment.prototype.replaceBatchAssignment = function () {
+        var _this = this;
+        var _a = this, parentKey = _a.parentKey, parentNode = _a.parentNode, logic = _a.logic;
+        var index;
+        var leftMembers = [];
+        // 左边变量变换
+        var leftObject = Object.assign({}, this.left);
+        if (leftObject.concept === 'MemberExpression') {
+            while (leftObject.object) {
+                leftMembers.unshift(leftObject);
+                leftObject = Object.assign({}, leftObject.object);
+            }
+        }
+        // 右边变量变换
+        var rightMembers = [];
+        var rightObject = Object.assign({}, this.right);
+        if (rightObject.concept === 'MemberExpression') {
+            while (rightObject.object) {
+                rightMembers.unshift(rightObject);
+                rightObject = Object.assign({}, rightObject.object);
+            }
+        }
+        // 自动连线
+        var leftIndex = leftMembers.length ? [0, leftMembers.length - 1] : [0];
+        var rightIndex = rightMembers.length ? [0, rightMembers.length - 1] : [0];
+        // 切换成批量赋值
+        var leftSelect = new SelectMembers__1["default"]({
+            expression: leftObject,
+            members: leftMembers
+        });
+        var rightSelect = new SelectMembers__1["default"]({
+            expression: rightObject,
+            members: rightMembers
+        });
+        var assignmentLine = new AssignmentLine__1["default"]({
+            leftIndex: leftIndex,
+            rightIndex: rightIndex
+        });
+        var batchObject = this.right ? {
+            left: leftSelect,
+            rights: [rightSelect],
+            assignmentLines: [assignmentLine]
+        } : {
+            left: leftSelect,
+            rights: [],
+            assignmentLines: []
+        };
+        var batchAssignment = new BatchAssignment__1["default"](__assign(__assign({}, batchObject), { offsetX: this.offsetX, offsetY: this.offsetY }));
+        this.app.emit('collect:start', {
+            actionMsg: '普通赋值切换批量赋值'
+        });
+        if (parentNode.concept === 'Logic') {
+            if (parentKey === 'body') {
+                index = logic.body.findIndex(function (item) { return item === _this; });
+                logic.insertItemInBodyAt(batchAssignment, index);
+            }
+            else {
+                index = logic.playground.findIndex(function (item) { return item === _this; });
+                logic.insertItemInPlaygroundAt(batchAssignment, index);
+            }
+        }
+        else {
+            index = parentNode[parentKey].findIndex(function (item) { return item === _this; });
+            var firstUpperText = parentKey[0].toUpperCase() + parentKey.slice(1, parentKey.length);
+            if (parentNode["insertItemIn" + firstUpperText + "At"])
+                parentNode["insertItemIn" + firstUpperText + "At"](batchAssignment, index);
+            else
+                parentNode.insertItemAt(batchAssignment, index);
+        }
+        this["delete"]();
+        this.app.emit('collect:end');
+        return batchAssignment;
+    };
+    Assignment.prototype.toVue = function (options) {
+        var code = '';
+        code += this.left ? this.left.toVue(options) : '';
+        code += ' = ';
+        code += this.right ? this.right.toVue(options) : '';
+        code += ';';
+        return code;
+    };
+    Assignment.prototype.toUI = function (state) {
+        var code = '';
+        code += this.left ? this.left.toUI(translator_1.shiftState(state, code, { inline: true })) : '';
+        code += ' = ';
+        code += this.right ? this.right.toUI(translator_1.shiftState(state, code, { inline: true })) : '';
+        code += ';';
+        return code;
+    };
+    Assignment.prototype.toJS = function (state) {
+        var code = '';
+        code += this.left ? this.left.toJS(translator_1.shiftState(state, code, { inline: true })) : '';
+        if (this.right) {
+            code += ' = ';
+            code += this.right.toJS(translator_1.shiftState(state, code, {
+                inline: true
+            }));
+        }
+        return code;
+    };
+    Assignment.prototype.toEmbeddedTS = function (state) {
+        var code = 'nasl.core.assign(';
+        code += this.left ? this.left.toEmbeddedTS(translator_1.shiftState(state, code, { inline: true })) : '__LEFT__';
+        code += ',';
+        // 因为右侧枚举要赋值就得new 一下；
+        if (this.right && this.right instanceof Identifier__1["default"] && this.right.namespace && this.right.namespace.endsWith('enums')) {
+            code += 'new ';
+        }
+        code += (this.right && this.right.toEmbeddedTS) ? this.right.toEmbeddedTS(translator_1.shiftState(state, code, { inline: true })) : '__RIGHT__';
+        code += ');';
+        return code;
+    };
+    var Assignment_1;
+    __decorate([
+        decorators_1.property()
+    ], Assignment.prototype, "concept");
+    __decorate([
+        decorators_1.property()
+    ], Assignment.prototype, "label");
+    __decorate([
+        decorators_1.property('LogicItem')
+    ], Assignment.prototype, "left");
+    __decorate([
+        decorators_1.property('LogicItem')
+    ], Assignment.prototype, "right");
+    __decorate([
+        translator_1.withSourceMap()
+    ], Assignment.prototype, "toEmbeddedTS");
+    Assignment = Assignment_1 = __decorate([
+        decorators_1.concept('赋值语句')
+    ], Assignment);
+    return Assignment;
+}(LogicItem__1["default"]));
+exports.Assignment = Assignment;
+classMap_1["default"].Assignment = Assignment;
+exports["default"] = Assignment;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================