@lcap/nasl 2.20.0-beta.2 → 2.20.0

package/src/concepts/dist/TypeAnnotation__.js

@@ -0,0 +1,834 @@
+"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;
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+exports.__esModule = true;
+exports.TypeAnnotation = exports.isUnion = exports.PRIMITIVE_TITLE = exports.PRIMITIVE_TYPE = void 0;
+var translator_1 = require("../translator");
+var generator_1 = require("../generator");
+var PRIMITIVE_TYPE;
+(function (PRIMITIVE_TYPE) {
+    PRIMITIVE_TYPE["Boolean"] = "Boolean";
+    PRIMITIVE_TYPE["Integer"] = "Integer";
+    PRIMITIVE_TYPE["Long"] = "Long";
+    PRIMITIVE_TYPE["Double"] = "Double";
+    PRIMITIVE_TYPE["Decimal"] = "Decimal";
+    PRIMITIVE_TYPE["String"] = "String";
+    PRIMITIVE_TYPE["Text"] = "Text";
+    PRIMITIVE_TYPE["Binary"] = "Binary";
+    PRIMITIVE_TYPE["Date"] = "Date";
+    PRIMITIVE_TYPE["Time"] = "Time";
+    PRIMITIVE_TYPE["DateTime"] = "DateTime";
+    PRIMITIVE_TYPE["Email"] = "Email";
+    PRIMITIVE_TYPE["Union"] = "Union";
+    PRIMITIVE_TYPE["Null"] = "Null";
+})(PRIMITIVE_TYPE = exports.PRIMITIVE_TYPE || (exports.PRIMITIVE_TYPE = {}));
+exports.PRIMITIVE_TITLE = {
+    Boolean: '布尔值',
+    Integer: '整数',
+    Long: '长整数',
+    Double: '小数',
+    Decimal: '精确小数',
+    String: '字符串',
+    Text: '长文本',
+    Binary: '二进制流',
+    Date: '日期',
+    Time: '时间',
+    DateTime: '日期时间',
+    Email: '电子邮箱',
+    Union: '联合类型'
+};
+/**
+ * 判断是否是联合类型
+ * @param typeAnnotation
+ * @returns
+ */
+function isUnion(typeAnnotation) {
+    return typeAnnotation
+        && typeAnnotation.typeKind === 'union'
+        && typeAnnotation.typeNamespace === 'nasl.core'
+        && typeAnnotation.typeName === 'Union';
+}
+exports.isUnion = isUnion;
+var decorators_1 = require("../decorators");
+var BaseNode_1 = require("../common/BaseNode");
+var classMap_1 = require("../common/classMap");
+var StructureProperty__1 = require("./StructureProperty__");
+/**
+ * 类型标注
+ */
+var TypeAnnotation = /** @class */ (function (_super) {
+    __extends(TypeAnnotation, _super);
+    /**
+     * @param source 需要合并的部分参数
+     */
+    function TypeAnnotation(source) {
+        var _this = this;
+        source = Object.assign({}, TypeAnnotation_1.getDefaultOptions(), source);
+        _this = _super.call(this, source) || this;
+        /**
+         * 产品概念
+         */
+        _this.concept = 'TypeAnnotation';
+        /**
+         * 类型种类
+         */
+        _this.typeKind = undefined;
+        /**
+         * 类型命名空间
+         */
+        _this.typeNamespace = undefined;
+        /**
+         * 类型名称
+         */
+        _this.typeName = undefined;
+        /**
+         * 类型参数
+         */
+        _this.typeArguments = null;
+        /**
+         * 返回类型
+         */
+        _this.returnType = null;
+        /**
+         * 是否是推断出来的
+         */
+        _this.inferred = undefined;
+        /**
+         * 匿名数据结构属性
+         */
+        _this.properties = null;
+        /**
+         * 规则对象
+         */
+        _this.ruleMap = undefined;
+        _super.prototype.subConstructor.call(_this, source);
+        return _this;
+    }
+    TypeAnnotation_1 = TypeAnnotation;
+    TypeAnnotation.from = function (source, parentNode, parentKey) {
+        return _super.from.call(this, source, parentNode, parentKey);
+    };
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    TypeAnnotation.prototype._delete = function () {
+        var _a, _b;
+        var params = null;
+        if (this.parentNode) {
+            params = (_b = (_a = this.parentNode) === null || _a === void 0 ? void 0 : _a.__removeTypeAnnotation) === null || _b === void 0 ? void 0 : _b.call(_a, this);
+        }
+        return params;
+    };
+    /**
+     * 设置规则对象
+     */
+    TypeAnnotation.prototype.setRuleMap = function (ruleMap) {
+        var object = {
+            ruleMap: ruleMap
+        };
+        this.update(__assign({}, object));
+    };
+    TypeAnnotation.prototype._insertTypeAnnotationInTypeArgumentsAt = function (options, index) {
+        var typeAnnotationOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'typeArguments' };
+        var typeAnnotation;
+        if (options instanceof TypeAnnotation_1) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            typeAnnotation = options;
+            Object.assign(typeAnnotation, relationOptions);
+        }
+        else {
+            typeAnnotation = TypeAnnotation_1.from(__assign(__assign({}, typeAnnotationOptions), options), this, 'typeArguments');
+        }
+        this.typeArguments.splice(index, 0, typeAnnotation);
+        return typeAnnotation;
+    };
+    TypeAnnotation.prototype.insertTypeAnnotationInTypeArgumentsAt = function (options, index) {
+        var node = this._insertTypeAnnotationInTypeArgumentsAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'typeArguments'
+        });
+        return node;
+    };
+    TypeAnnotation.prototype._addTypeAnnotationInTypeArguments = function (options) {
+        var index = this.typeArguments.length;
+        return this._insertTypeAnnotationInTypeArgumentsAt(options, index);
+    };
+    TypeAnnotation.prototype.addTypeAnnotationInTypeArguments = function (options) {
+        var node = this._addTypeAnnotationInTypeArguments(options);
+        var index = this.typeArguments.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'typeArguments'
+        });
+        return node;
+    };
+    TypeAnnotation.prototype._insertTypeAnnotationInReturnTypeAt = function (options, index) {
+        var typeAnnotationOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'returnType' };
+        var typeAnnotation;
+        if (options instanceof TypeAnnotation_1) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            typeAnnotation = options;
+            Object.assign(typeAnnotation, relationOptions);
+        }
+        else {
+            typeAnnotation = TypeAnnotation_1.from(__assign(__assign({}, typeAnnotationOptions), options), this, 'returnType');
+        }
+        this.returnType.splice(index, 0, typeAnnotation);
+        return typeAnnotation;
+    };
+    TypeAnnotation.prototype.insertTypeAnnotationInReturnTypeAt = function (options, index) {
+        var node = this._insertTypeAnnotationInReturnTypeAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'returnType'
+        });
+        return node;
+    };
+    TypeAnnotation.prototype._addTypeAnnotationInReturnType = function (options) {
+        var index = this.returnType.length;
+        return this._insertTypeAnnotationInReturnTypeAt(options, index);
+    };
+    TypeAnnotation.prototype.addTypeAnnotationInReturnType = function (options) {
+        var node = this._addTypeAnnotationInReturnType(options);
+        var index = this.returnType.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'returnType'
+        });
+        return node;
+    };
+    TypeAnnotation.prototype._insertStructurePropertyAt = function (options, index) {
+        var structurePropertyOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'properties' };
+        var structureProperty;
+        if (options instanceof StructureProperty__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            structureProperty = options;
+            Object.assign(structureProperty, relationOptions);
+        }
+        else {
+            structureProperty = StructureProperty__1["default"].from(__assign(__assign({}, structurePropertyOptions), options), this, 'properties');
+        }
+        this.properties.splice(index, 0, structureProperty);
+        return structureProperty;
+    };
+    TypeAnnotation.prototype.insertStructurePropertyAt = function (options, index) {
+        var node = this._insertStructurePropertyAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'properties'
+        });
+        return node;
+    };
+    TypeAnnotation.prototype._addStructureProperty = function (options) {
+        var index = this.properties.length;
+        return this._insertStructurePropertyAt(options, index);
+    };
+    TypeAnnotation.prototype.addStructureProperty = function (options) {
+        var node = this._addStructureProperty(options);
+        var index = this.properties.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'properties'
+        });
+        return node;
+    };
+    TypeAnnotation.prototype.removeTypeAnnotationInTypeArguments = function (options) {
+        var typeAnnotation = options;
+        return typeAnnotation["delete"]();
+    };
+    TypeAnnotation.prototype.removeTypeAnnotationInReturnType = function (options) {
+        var typeAnnotation = options;
+        return typeAnnotation["delete"]();
+    };
+    TypeAnnotation.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;
+    };
+    TypeAnnotation.prototype.removeStructureProperty = function (options) {
+        var structureProperty = options;
+        return structureProperty["delete"]();
+    };
+    TypeAnnotation.prototype.__removeStructureProperty = function (structureProperty) {
+        var parentKey = structureProperty.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: structureProperty
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(structureProperty);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === structureProperty) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    TypeAnnotation.prototype.toUI = function (state) {
+        return this.headTitle;
+    };
+    TypeAnnotation.prototype.traverse = function (callback, enter, leave, onJoin) {
+        var _this = this;
+        enter(this);
+        callback(this);
+        if (this.typeArguments && ['generic', 'union'].includes(this.typeKind)) {
+            var l_1 = this.typeArguments.length;
+            this.typeArguments.forEach(function (arg, idx) {
+                arg.traverse(callback, enter, leave, onJoin);
+                if (idx < l_1 - 1) {
+                    onJoin(_this, arg);
+                }
+            });
+        }
+        leave(this);
+    };
+    Object.defineProperty(TypeAnnotation.prototype, "typeKey", {
+        get: function () {
+            if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
+                return this.typeNamespace + "." + this.typeName;
+            }
+            else if (this.typeKind === 'generic') {
+                return this.typeNamespace + "." + this.typeName + "<" + (this.typeArguments || []).map(function (arg) { return arg.typeKey; }) + ">";
+            }
+            else if (this.typeKind === 'anonymousStructure') {
+                return "{ " + this.properties.map(function (_a) {
+                    var name = _a.name, typeAnnotation = _a.typeAnnotation;
+                    return (name + ": " + (typeAnnotation ? typeAnnotation.typeKey : 'any'));
+                }).join(', ') + " }";
+            }
+            else if (this.typeKind === 'union') {
+                return "" + this.typeArguments.map(function (arg) { return arg.typeKey; }).join(' | ');
+            }
+            else {
+                return this.typeName;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeAnnotation.prototype, "sortedTypeKey", {
+        // 排过序的类型标识
+        get: function () {
+            if (this.typeKind === 'anonymousStructure') {
+                // 按匿名数据结构的key排序
+                return "{" + this.properties.sort(function (_a, _b) {
+                    var name1 = _a.name;
+                    var name2 = _b.name;
+                    return name1 > name2 ? 1 : -1;
+                }).map(function (_a) {
+                    var name = _a.name, typeAnnotation = _a.typeAnnotation;
+                    return (name + ": " + (typeAnnotation ? typeAnnotation.sortedTypeKey : 'any'));
+                }).join(', ') + "}";
+            }
+            else if (this.typeKind === 'union') {
+                // 按返回的每个具体项排序
+                return "" + this.typeArguments.map(function (arg) { return arg.sortedTypeKey; }).sort(function (name1, name2) { return name1 > name2 ? 1 : -1; }).join(' | ');
+            }
+            var typeArr = [];
+            if (this.typeNamespace) {
+                typeArr.push(this.typeNamespace);
+            }
+            if (this.typeName) {
+                typeArr.push(this.typeName);
+            }
+            var typeKey = typeArr.join('.');
+            if (this.typeKind === 'generic') {
+                var code = typeKey;
+                code += '<';
+                if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+                    // 必须按typeArguments定义的顺序，否则实参位置不对
+                    code += "" + (this.typeArguments || []).map(function (arg) { return arg.sortedTypeKey; }).join(', ');
+                }
+                code += '>';
+                return code;
+            }
+            return typeKey;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeAnnotation.prototype, "headTitle", {
+        /**
+         * 用于展示的 type 标题
+         */
+        get: function () {
+            var _a, _b, _c, _d;
+            if (this.typeKind === 'primitive') {
+                return this.typeName + " " + (exports.PRIMITIVE_TITLE[this.typeName] || '');
+            }
+            else if (this.typeKind === 'reference') {
+                var typeNamespace = this === null || this === void 0 ? void 0 : this.typeNamespace;
+                var typeTitle = this.typeName;
+                if (typeNamespace && this.rootNode) {
+                    var entity = (_b = (_a = this.rootNode).findNodeByCompleteName) === null || _b === void 0 ? void 0 : _b.call(_a, [typeNamespace, this === null || this === void 0 ? void 0 : this.typeName].join('.'));
+                    if ((entity === null || entity === void 0 ? void 0 : entity.concept) === 'Entity') {
+                        var dataSourceName = (_c = entity.dataSource) === null || _c === void 0 ? void 0 : _c.name;
+                        if (dataSourceName) {
+                            typeTitle += "\uFF08" + dataSourceName + "\uFF09";
+                        }
+                    }
+                }
+                return typeTitle;
+            }
+            else if (this.typeKind === 'generic') {
+                if (this.typeArguments && this.typeArguments.length)
+                    return this.typeName + "<" + (this.typeArguments || []).map(function (arg) { return arg.headTitle || arg.name || 'T'; }).join(', ') + ">";
+                else
+                    return this.typeName;
+            }
+            else if (this.typeKind === 'anonymousStructure') {
+                return "{ " + ((_d = this.properties) === null || _d === void 0 ? void 0 : _d.map(function (_a) {
+                    var name = _a.name, typeAnnotation = _a.typeAnnotation;
+                    return (name + ": " + typeAnnotation.headTitle);
+                }).join(', ')) + " }";
+            }
+            else if (this.typeKind === 'union') {
+                return "" + this.typeArguments.map(function (arg) { return arg.typeTitle || arg.name; }).join(' 或 ');
+            }
+            else {
+                return this.typeName;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeAnnotation.prototype, "typeTitle", {
+        /**
+         * 用于展示的 type 标题
+         */
+        get: function () {
+            var _a;
+            if (this.typeKind === 'primitive') {
+                return this.typeName + " " + (exports.PRIMITIVE_TITLE[this.typeName] || '');
+            }
+            else if (this.typeKind === 'reference') {
+                return this.typeName;
+            }
+            else if (this.typeKind === 'generic') {
+                return this.typeName + "<" + this.typeArguments.map(function (arg) { return arg.typeTitle || arg.name || 'T'; }).join(', ') + ">";
+            }
+            else if (this.typeKind === 'anonymousStructure') {
+                return "{ " + ((_a = this.properties) === null || _a === void 0 ? void 0 : _a.map(function (_a) {
+                    var name = _a.name, typeAnnotation = _a.typeAnnotation;
+                    return (name + ": " + (typeAnnotation ? typeAnnotation.typeTitle : 'any'));
+                }).join(', ')) + " }";
+            }
+            else if (this.typeKind === 'union') {
+                return "" + this.typeArguments.map(function (arg) { return arg.typeTitle || arg.name; }).join(' 或 ');
+            }
+            else {
+                return this.typeName;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeAnnotation.prototype, "typeTitleList", {
+        get: function () {
+            var _a, _b;
+            var typeTitleList = [];
+            if (this.typeKind === 'anonymousStructure') {
+                typeTitleList.push({ key: '{' });
+                var length_1 = (_a = this.properties) === null || _a === void 0 ? void 0 : _a.length;
+                (_b = this.properties) === null || _b === void 0 ? void 0 : _b.forEach(function (_a, index) {
+                    var name = _a.name, typeAnnotation = _a.typeAnnotation;
+                    if (index === length_1 - 1) {
+                        typeTitleList.push({ key: name, value: "" + (typeAnnotation ? typeAnnotation.typeTitle : 'any') });
+                    }
+                    else {
+                        typeTitleList.push({ key: name, value: "" + (typeAnnotation ? typeAnnotation.typeTitle : 'any'), dot: ',' });
+                    }
+                });
+                typeTitleList.push({ key: '}' });
+            }
+            else {
+                typeTitleList.push({ key: this.typeTitle });
+            }
+            return typeTitleList;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TypeAnnotation.createPrimitive = function (typeName, source) {
+        if (PRIMITIVE_TYPE[typeName]) {
+            return this.from(Object.assign({
+                typeKind: typeName === 'Union' ? 'union' : 'primitive',
+                typeName: typeName,
+                typeNamespace: 'nasl.core'
+            }, source));
+        }
+    };
+    TypeAnnotation.createReference = function (typeName, source) {
+        return this.from(Object.assign({
+            typeKind: 'reference',
+            typeName: typeName,
+            typeNamespace: 'nasl.core'
+        }, source));
+    };
+    TypeAnnotation.createGeneric = function (typeName, source) {
+        return this.from(Object.assign({
+            typeKind: 'generic',
+            typeName: typeName,
+            typeNamespace: 'nasl.collection'
+        }, source));
+    };
+    TypeAnnotation.createTypeParam = function (typeName, source) {
+        return this.from(Object.assign({
+            typeKind: 'typeParam',
+            typeName: typeName
+        }, source));
+    };
+    TypeAnnotation.createTypeAnonymousStructure = function (properties, source) {
+        return this.from(Object.assign({
+            typeKind: 'anonymousStructure',
+            properties: properties
+        }, source));
+    };
+    /**
+     * 设置类型属性名称
+     */
+    TypeAnnotation.prototype.setTypeName = function (typeName) {
+        var object = {
+            typeName: typeName
+        };
+        this.update(__assign({}, object));
+    };
+    /**
+     * 设置类型属性名称
+     */
+    TypeAnnotation.prototype.setTypeNamespace = function (typeNamespace) {
+        var object = {
+            typeNamespace: typeNamespace
+        };
+        this.update(__assign({}, object));
+    };
+    Object.defineProperty(TypeAnnotation.prototype, "tsCalleeNamespace", {
+        get: function () {
+            if (this.typeNamespace) {
+                var tsCalleeNamespace = this.typeNamespace;
+                tsCalleeNamespace = tsCalleeNamespace.replace(/\.[0-9]/g, function (m) { return m.replace('.', '.$'); });
+                tsCalleeNamespace = tsCalleeNamespace.replace(/-/g, '_');
+                return tsCalleeNamespace;
+            }
+            return '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TypeAnnotation.prototype.toVue = function (state) {
+        return JSON.stringify(this);
+    };
+    TypeAnnotation.prototype.toJS = function (state) {
+        return JSON.stringify(this);
+    };
+    TypeAnnotation.prototype.toEmbeddedTS = function (state) {
+        var _this = this;
+        if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
+            if (this.typeKind === 'reference' && this.typeNamespace && this.typeNamespace.endsWith('enums')) {
+                return this.tsCalleeNamespace + "." + this.typeName;
+            }
+            return this.tsCalleeNamespace + "." + this.typeName;
+        }
+        else if (this.typeKind === 'generic') {
+            var code_1 = this.tsCalleeNamespace + "." + this.typeName + "<";
+            (this.typeArguments || []).forEach(function (arg, index) {
+                code_1 += arg.toEmbeddedTS(translator_1.shiftState(state, code_1, { inline: true }));
+                if (index !== _this.typeArguments.length - 1)
+                    code_1 += ', ';
+            });
+            code_1 += '>';
+            return code_1;
+        }
+        else if (this.typeKind === 'union') {
+            var code_2 = '';
+            (this.typeArguments || []).forEach(function (arg, index) {
+                code_2 += arg.toEmbeddedTS(translator_1.shiftState(state, code_2, { inline: true }));
+                if (index !== _this.typeArguments.length - 1)
+                    code_2 += ' | ';
+            });
+            return code_2;
+        }
+        else if (this.typeKind === 'anonymousStructure') {
+            var code_3 = "{ __name: \"AStructure_" + this.hash + "\", ";
+            (this.properties || []).forEach(function (property, i) {
+                var _a;
+                code_3 += property.name + ": ";
+                code_3 += "" + (property.typeAnnotation ? property.typeAnnotation.toEmbeddedTS(translator_1.shiftState(state, code_3, { inline: true, tabSize: ((state === null || state === void 0 ? void 0 : state.tabSize) || 0) + 1 })) : 'any');
+                code_3 += i < ((_a = _this.properties) === null || _a === void 0 ? void 0 : _a.length) - 1 ? ', ' : ' }';
+            });
+            return code_3;
+        }
+        else {
+            if (this.tsCalleeNamespace && this.typeName) {
+                return this.tsCalleeNamespace + "." + this.typeName;
+            }
+            else if (this.typeName) {
+                return this.typeName;
+            }
+            else {
+                return '__IDENTIFIER__';
+            }
+        }
+    };
+    Object.defineProperty(TypeAnnotation.prototype, "anonymousStructureTypeDesc", {
+        /**
+         * 用于标准化数据结构，便于计算 anonymousStructure 的 __name
+         */
+        get: function () {
+            if (this.typeKind === 'generic') {
+                return this.typeName + "<" + this.typeArguments.map(function (arg) { return arg.anonymousStructureTypeDesc || arg.name || 'T'; }).join(', ') + ">";
+            }
+            else if (this.typeKind === 'anonymousStructure') {
+                return "{ " + __spreadArrays(this.properties).sort(function (_a, _b) {
+                    var aName = _a.name;
+                    var bName = _b.name;
+                    if (aName > bName)
+                        return 1;
+                    return aName < bName ? -1 : 0;
+                }).map(function (_a) {
+                    var name = _a.name, typeAnnotation = _a.typeAnnotation;
+                    return (name + ": " + (typeAnnotation ? typeAnnotation.anonymousStructureTypeDesc : 'any'));
+                }).join(', ') + " }";
+            }
+            else {
+                return this.typeName;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeAnnotation.prototype, "hash", {
+        /**
+         * hash 用于比较 anonymousStructure 是否相同
+         */
+        get: function () {
+            return generator_1.genHash(this.anonymousStructureTypeDesc);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TypeAnnotation.prototype.getDefaultValue = function (value) {
+        var code = '';
+        if (this.typeKind === 'primitive') {
+            if (this.typeName === 'String') {
+                code = "   \"" + value + "\" ";
+            }
+            else {
+                if (['Text'].includes(this.typeName)) {
+                    code = "  new " + this.typeNamespace + "." + this.typeName + "(\"" + value + "\")";
+                }
+                else if (['Boolean'].includes(this.typeName)) {
+                    code = value;
+                }
+                else {
+                    code = " new " + this.typeNamespace + "." + this.typeName + "(" + value + ")";
+                }
+            }
+        }
+        else {
+            code = " " + this.typeNamespace + "." + this.typeName + "['" + value + "']";
+        }
+        return code;
+    };
+    /**
+     *
+     * @param code 233
+     *
+     */
+    TypeAnnotation.recognize = function (code) {
+        if (typeof code === 'string') {
+            var EmailReg = /^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/;
+            var TimeReg = /^(\d{1,2})(:\d{1,2})?:(\d{1,2})$/;
+            var DateReg = /^\d{1,4}(\/|-)\d{1,2}(\/|-)\d{1,2}$/;
+            var DateTimeReg = /^\d{1,4}(\/|-)\d{1,2}(\/|-)\d{1,2}\s(\d{1,2})(:\d{1,2})?:(\d{1,2})$/;
+            var BooleanReg = /(false|true|\u662f|\u5426)/i;
+            if (EmailReg.test(code)) {
+                return this.createPrimitive('Email');
+            }
+            else if (TimeReg.test(code)) {
+                return this.createPrimitive('Time');
+            }
+            else if (BooleanReg.test(code)) {
+                return this.createPrimitive('Boolean');
+            }
+            else if (DateReg.test(code)) {
+                return this.createPrimitive('Date');
+            }
+            else if (DateTimeReg.test(code)) {
+                return this.createPrimitive('DateTime');
+            }
+            else if (!isNaN(Number(code))) {
+                if (code.indexOf('.') !== -1) {
+                    return this.createPrimitive('Double');
+                    // return this.createPrimitive('Decimal');
+                }
+                if (code.length > 8) {
+                    return this.createPrimitive('Long');
+                }
+                return this.createPrimitive('Integer');
+            }
+            else if (code.length > 255) {
+                return this.createPrimitive('Text');
+            }
+            return this.createPrimitive('String');
+        }
+        else {
+            return this.createPrimitive('Integer');
+        }
+    };
+    // 增加插入泛型子类型
+    TypeAnnotation.prototype.typeArgumentsPush = function (typeItem) {
+        if (typeItem instanceof TypeAnnotation_1) {
+            this.typeArguments.push(TypeAnnotation_1.from(typeItem, {
+                parentNode: this,
+                parentKey: 'typeArguments'
+            }));
+        }
+    };
+    // 是否是复合类型 List|Map|entities|structures
+    TypeAnnotation.prototype.isComplexType = function () {
+        var namespaceType = this.typeNamespace.split('.').pop();
+        return ['Map', 'List'].includes(this.typeName) || (this.typeKind === 'reference' && ['entities', 'structures'].includes(namespaceType));
+    };
+    Object.defineProperty(TypeAnnotation.prototype, "sign", {
+        /*  类型签名 */
+        get: function () {
+            var _this = this;
+            var str = '';
+            if (['Map', 'List'].includes(this.typeName)) {
+                str += this.typeName + '<';
+                (this.typeArguments || []).forEach(function (item, index) {
+                    str += item.sign;
+                    if (index + 1 !== _this.typeArguments.length) {
+                        str += ',';
+                    }
+                });
+                str += '>';
+            }
+            else {
+                str += this.typeName;
+            }
+            return str;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    var TypeAnnotation_1;
+    __decorate([
+        decorators_1.property()
+    ], TypeAnnotation.prototype, "concept");
+    __decorate([
+        decorators_1.property()
+    ], TypeAnnotation.prototype, "typeKind");
+    __decorate([
+        decorators_1.property()
+    ], TypeAnnotation.prototype, "typeNamespace");
+    __decorate([
+        decorators_1.property()
+    ], TypeAnnotation.prototype, "typeName");
+    __decorate([
+        decorators_1.property('TypeAnnotation')
+    ], TypeAnnotation.prototype, "typeArguments");
+    __decorate([
+        decorators_1.property('TypeAnnotation')
+    ], TypeAnnotation.prototype, "returnType");
+    __decorate([
+        decorators_1.property()
+    ], TypeAnnotation.prototype, "inferred");
+    __decorate([
+        decorators_1.property('StructureProperty')
+    ], TypeAnnotation.prototype, "properties");
+    __decorate([
+        decorators_1.property()
+    ], TypeAnnotation.prototype, "ruleMap");
+    __decorate([
+        translator_1.withSourceMap()
+    ], TypeAnnotation.prototype, "toEmbeddedTS");
+    TypeAnnotation = TypeAnnotation_1 = __decorate([
+        decorators_1.concept('类型标注')
+    ], TypeAnnotation);
+    return TypeAnnotation;
+}(BaseNode_1["default"]));
+exports.TypeAnnotation = TypeAnnotation;
+classMap_1["default"].TypeAnnotation = TypeAnnotation;
+exports["default"] = TypeAnnotation;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================