@lcap/nasl 2.18.0-beta.4 → 2.18.0

package/src/concepts/dist/CallFunction__.js

@@ -0,0 +1,473 @@
+"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.CallFunction = void 0;
+var translator_1 = require("../translator");
+var Function__1 = require("./Function__");
+var Identifier__1 = require("./Identifier__");
+var getFunctions_1 = require("../server/getFunctions");
+var AnonymousFunction__1 = require("./AnonymousFunction__");
+var decorators_1 = require("../decorators");
+var BaseNode_1 = require("../common/BaseNode");
+var classMap_1 = require("../common/classMap");
+var TypeAnnotation__1 = require("./TypeAnnotation__");
+var Argument__1 = require("./Argument__");
+var LogicItem__1 = require("./LogicItem__");
+/**
+ * 调用函数
+ */
+var CallFunction = /** @class */ (function (_super) {
+    __extends(CallFunction, _super);
+    /**
+     * @param source 需要合并的部分参数
+     */
+    function CallFunction(source) {
+        var _this = this;
+        source = Object.assign({}, CallFunction_1.getDefaultOptions(), source);
+        _this = _super.call(this, source) || this;
+        /**
+         * 产品概念
+         */
+        _this.concept = 'CallFunction';
+        /**
+         * 调用函数标题
+         */
+        _this.label = '内置函数';
+        /**
+         * calleeNamespace
+         */
+        _this.calleeNamespace = undefined;
+        /**
+         * calleeName
+         */
+        _this.calleeName = undefined;
+        /**
+         * shortcut
+         */
+        _this.shortcut = undefined;
+        /**
+         * 类型参数
+         */
+        _this.typeArguments = null;
+        /**
+         * 实际参数
+         */
+        _this.arguments = [];
+        _super.prototype.subConstructor.call(_this, source);
+        return _this;
+    }
+    CallFunction_1 = CallFunction;
+    CallFunction.from = function (source, parentNode, parentKey) {
+        return _super.from.call(this, source, parentNode, parentKey);
+    };
+    CallFunction.prototype._insertTypeAnnotationAt = function (options, index) {
+        var typeAnnotationOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'typeArguments' };
+        var typeAnnotation;
+        if (options instanceof TypeAnnotation__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            typeAnnotation = options;
+            Object.assign(typeAnnotation, relationOptions);
+        }
+        else {
+            typeAnnotation = TypeAnnotation__1["default"].from(__assign(__assign({}, typeAnnotationOptions), options), this, 'typeArguments');
+        }
+        this.typeArguments.splice(index, 0, typeAnnotation);
+        return typeAnnotation;
+    };
+    CallFunction.prototype.insertTypeAnnotationAt = function (options, index) {
+        var node = this._insertTypeAnnotationAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'typeArguments'
+        });
+        return node;
+    };
+    CallFunction.prototype._addTypeAnnotation = function (options) {
+        var index = this.typeArguments.length;
+        return this._insertTypeAnnotationAt(options, index);
+    };
+    CallFunction.prototype.addTypeAnnotation = function (options) {
+        var node = this._addTypeAnnotation(options);
+        var index = this.typeArguments.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'typeArguments'
+        });
+        return node;
+    };
+    CallFunction.prototype._insertArgumentAt = function (options, index) {
+        var argumentOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'arguments' };
+        var argument;
+        if (options instanceof Argument__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            argument = options;
+            Object.assign(argument, relationOptions);
+        }
+        else {
+            argument = Argument__1["default"].from(__assign(__assign({}, argumentOptions), options), this, 'arguments');
+        }
+        this.arguments.splice(index, 0, argument);
+        return argument;
+    };
+    CallFunction.prototype.insertArgumentAt = function (options, index) {
+        var node = this._insertArgumentAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'arguments'
+        });
+        return node;
+    };
+    CallFunction.prototype._addArgument = function (options) {
+        var index = this.arguments.length;
+        return this._insertArgumentAt(options, index);
+    };
+    CallFunction.prototype.addArgument = function (options) {
+        var node = this._addArgument(options);
+        var index = this.arguments.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'arguments'
+        });
+        return node;
+    };
+    CallFunction.prototype.removeTypeAnnotation = function (options) {
+        var typeAnnotation = options;
+        return typeAnnotation["delete"]();
+    };
+    CallFunction.prototype.__removeTypeAnnotation = function (typeAnnotation) {
+        var parentKey = typeAnnotation.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: typeAnnotation
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(typeAnnotation);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === typeAnnotation) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    CallFunction.prototype.removeArgument = function (options) {
+        var argument = options;
+        return argument["delete"]();
+    };
+    CallFunction.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;
+    };
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    CallFunction.prototype.toVue = function (options) {
+        var _this = this;
+        var _a, _b, _c;
+        if ((options === null || options === void 0 ? void 0 : options.finalCode) === false) {
+            return this.toUI();
+        }
+        else {
+            var code_1 = "$utils['" + this.calleeName + "']";
+            code_1 += '(';
+            (_a = this.arguments) === null || _a === void 0 ? void 0 : _a.forEach(function (arg, index) {
+                var _a;
+                code_1 += arg === null || arg === void 0 ? void 0 : arg.toVue(options);
+                if (index !== ((_a = _this.arguments) === null || _a === void 0 ? void 0 : _a.length) - 1)
+                    code_1 += ', ';
+            });
+            if (this.typeArguments && this.typeArguments.length) {
+                if ((_b = this.arguments) === null || _b === void 0 ? void 0 : _b.length)
+                    code_1 += ', ';
+                (_c = this.typeArguments) === null || _c === void 0 ? void 0 : _c.forEach(function (arg, index) {
+                    var _a;
+                    code_1 += arg === null || arg === void 0 ? void 0 : arg.toJS().replace(/"/g, "'");
+                    if (index !== ((_a = _this.typeArguments) === null || _a === void 0 ? void 0 : _a.length) - 1)
+                        code_1 += ', ';
+                });
+            }
+            code_1 += ')';
+            return code_1;
+        }
+    };
+    CallFunction.prototype.toUI = function () {
+        var _this = this;
+        var _a, _b, _c;
+        var code = this.calleeName;
+        code += '(';
+        (_a = this.arguments) === null || _a === void 0 ? void 0 : _a.forEach(function (arg, index) {
+            var _a;
+            code += arg === null || arg === void 0 ? void 0 : arg.toUI();
+            if (index !== ((_a = _this.arguments) === null || _a === void 0 ? void 0 : _a.length) - 1)
+                code += ', ';
+        });
+        if (this.typeArguments && this.typeArguments.length) {
+            if ((_b = this.arguments) === null || _b === void 0 ? void 0 : _b.length)
+                code += ', ';
+            (_c = this.typeArguments) === null || _c === void 0 ? void 0 : _c.forEach(function (arg, index) {
+                var _a;
+                code += arg === null || arg === void 0 ? void 0 : arg.typeName;
+                if (index !== ((_a = _this.typeArguments) === null || _a === void 0 ? void 0 : _a.length) - 1)
+                    code += ', ';
+            });
+        }
+        code += ')';
+        return code;
+    };
+    CallFunction.prototype.toJS = function (state) {
+        var _this = this;
+        var _a, _b, _c;
+        var code = "this.$utils['" + this.calleeName + "']";
+        code += '(';
+        (_a = this.arguments) === null || _a === void 0 ? void 0 : _a.forEach(function (arg, index) {
+            var _a;
+            code += arg === null || arg === void 0 ? void 0 : arg.toJS(translator_1.shiftState(state, code));
+            if (index !== ((_a = _this.arguments) === null || _a === void 0 ? void 0 : _a.length) - 1)
+                code += ', ';
+        });
+        if (this.typeArguments && this.typeArguments.length) {
+            if ((_b = this.arguments) === null || _b === void 0 ? void 0 : _b.length)
+                code += ', ';
+            (_c = this.typeArguments) === null || _c === void 0 ? void 0 : _c.forEach(function (arg, index) {
+                var _a;
+                code += arg === null || arg === void 0 ? void 0 : arg.toJS(translator_1.shiftState(state, code));
+                if (index !== ((_a = _this.typeArguments) === null || _a === void 0 ? void 0 : _a.length) - 1)
+                    code += ', ';
+            });
+        }
+        code += ')';
+        var typeAnnotation = this.typeAnnotation || this.__TypeAnnotation;
+        var needGenInitFromSchema = typeAnnotation && !['primitive', 'union'].includes(typeAnnotation.typeKind);
+        if (needGenInitFromSchema) {
+            code = "this.$genInitFromSchema('" + (typeAnnotation === null || typeAnnotation === void 0 ? void 0 : typeAnnotation.sortedTypeKey) + "', " + code + ")";
+        }
+        return code;
+    };
+    CallFunction.prototype.toBrief = function () {
+        return this.arguments.map(function (a) { return a.toBrief(); }).join('<br />');
+    };
+    Object.defineProperty(CallFunction.prototype, "calleeKey", {
+        get: function () {
+            return this.calleeName ? "" + (this.calleeNamespace ? this.calleeNamespace + '.' : '') + this.calleeName : '__IDENTIFIER__';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CallFunction.prototype._setCallee = function (func) {
+        var _this = this;
+        var _a;
+        this.calleeNamespace = func === null || func === void 0 ? void 0 : func.getNamespace();
+        this.calleeName = func === null || func === void 0 ? void 0 : func.name;
+        this.arguments = [];
+        (_a = func === null || func === void 0 ? void 0 : func.params) === null || _a === void 0 ? void 0 : _a.forEach(function (param) {
+            _this._addArgument(undefined);
+        });
+    };
+    CallFunction.prototype.setCallee = function (func) {
+        var _this = this;
+        var calleeNamespace = func.getNamespace();
+        var calleeName = func.name;
+        var params = func.params.map(function (param) {
+            var relationOptions = { parentNode: _this, parentKey: 'arguments' };
+            var argument = Argument__1["default"].from({
+                keyword: param.name
+            }, _this);
+            if (param.defaultExpression instanceof Identifier__1["default"]) {
+                argument.expression = BaseNode_1["default"].from(param.defaultExpression, argument, 'expression');
+            }
+            if (param.defaultExpression instanceof Function__1["default"]) {
+                param.defaultExpression.returnExpression = null;
+                argument.expression = BaseNode_1["default"].from(param.defaultExpression, argument, 'expression');
+            }
+            Object.assign(argument, relationOptions);
+            return argument;
+        });
+        var typeArguments = null;
+        if (func.typeParams) {
+            typeArguments = func.typeParams.map(function () {
+                var relationOptions = { parentNode: _this, parentKey: 'typeArguments' };
+                var typeArgu = new TypeAnnotation__1["default"]();
+                Object.assign(typeArgu, relationOptions);
+                return typeArgu;
+            });
+        }
+        this.update({
+            calleeNamespace: calleeNamespace,
+            calleeName: calleeName,
+            arguments: params,
+            typeArguments: typeArguments,
+            folded: false
+        });
+        this.detectArgs();
+    };
+    CallFunction.prototype.detectArgs = function (obj) {
+        var _a;
+        var func = getFunctions_1.getBuildInFunction(this.calleeName);
+        var shouldJudge = !!func && [
+            'ListDistinctBy',
+            'MapDistinctBy',
+            'ListGroupBy',
+            'ListToMap',
+            'MapFilter',
+        ].includes(this.calleeName);
+        if (shouldJudge && Array.isArray(this.arguments)) {
+            var depParamIdx_1 = func.params.findIndex(function (param) { return ['list', 'map'].includes(param.name); });
+            if (depParamIdx_1 !== -1) {
+                var depArgExpression_1 = (_a = this.arguments) === null || _a === void 0 ? void 0 : _a[depParamIdx_1].expression;
+                this.arguments.forEach(function (arg, index) {
+                    if (depParamIdx_1 !== index && !depArgExpression_1) {
+                        arg.illegalTip = "\u8BF7\u5148\u6DFB\u52A0" + func.params[depParamIdx_1].name;
+                    }
+                    else {
+                        if (arg.illegalTip) {
+                            delete arg.illegalTip;
+                        }
+                    }
+                });
+            }
+        }
+    };
+    CallFunction.prototype.toEmbeddedTS = function (state) {
+        var _this = this;
+        var code = '';
+        var calleeKey = this.calleeKey;
+        if (calleeKey === 'nasl.util.Convert') {
+            // nasl.util.Convert(variable1)<nasl.core.String>();
+            // 单独处理
+            code = calleeKey;
+            code += '(';
+            this.arguments.forEach(function (arg, index) {
+                code += arg.toEmbeddedTS(translator_1.shiftState(state, code, { tabSize: 0 }));
+                if (index !== _this.arguments.length - 1)
+                    code += ', ';
+            });
+            code += ')';
+            // 如果有内容
+            var typeAnnotation = this.typeArguments[0];
+            code += "<";
+            code += typeAnnotation.toEmbeddedTS(translator_1.shiftState(state, code, { tabSize: 0 })) + ">()";
+        }
+        else {
+            code = this.calleeKey;
+            if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+                // 如果有内容
+                var typeAnnotation = this.typeArguments[0];
+                code += "<";
+                code += typeAnnotation.toEmbeddedTS(translator_1.shiftState(state, code, { tabSize: 0 })) + ">";
+            }
+            code += '(';
+            Array.isArray(this.arguments) && this.arguments.forEach(function (arg, index) {
+                code += arg.toEmbeddedTS(translator_1.shiftState(state, code, { tabSize: 0 }));
+                if (index !== _this.arguments.length - 1)
+                    code += ', ';
+            });
+            code += ')';
+        }
+        return code;
+    };
+    CallFunction.prototype.checkParamNameOfAnonymousFunction = function () {
+        var fns = this.arguments.map(function (arg) { return arg.expression; })
+            .filter(function (exp) { return exp instanceof AnonymousFunction__1["default"]; });
+        fns.forEach(function (fn) {
+            fn.checkParamName();
+        });
+    };
+    var CallFunction_1;
+    __decorate([
+        decorators_1.property()
+    ], CallFunction.prototype, "concept");
+    __decorate([
+        decorators_1.property()
+    ], CallFunction.prototype, "label");
+    __decorate([
+        decorators_1.property()
+    ], CallFunction.prototype, "calleeNamespace");
+    __decorate([
+        decorators_1.property()
+    ], CallFunction.prototype, "calleeName");
+    __decorate([
+        decorators_1.property()
+    ], CallFunction.prototype, "shortcut");
+    __decorate([
+        decorators_1.property('TypeAnnotation')
+    ], CallFunction.prototype, "typeArguments");
+    __decorate([
+        decorators_1.property('Argument')
+    ], CallFunction.prototype, "arguments");
+    __decorate([
+        translator_1.withSourceMap()
+    ], CallFunction.prototype, "toEmbeddedTS");
+    CallFunction = CallFunction_1 = __decorate([
+        decorators_1.concept('调用函数')
+    ], CallFunction);
+    return CallFunction;
+}(LogicItem__1["default"]));
+exports.CallFunction = CallFunction;
+classMap_1["default"].CallFunction = CallFunction;
+exports["default"] = CallFunction;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================