@lcap/nasl 1.0.0-alpha.9 → 1.0.2

package/src/concepts/CallQueryComponent__.ts

@@ -4,6 +4,7 @@ import Entity from './Entity__';
 import Structure from './Structure__';
 import StructureProperty from './StructureProperty__';
 import CompletionProperty from './CompletionProperty__';
+import QueryFieldExpression from './QueryFieldExpression__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -82,6 +83,12 @@ export class CallQueryComponent extends LogicItem {
     @property('QueryLimitExpression')
     limit: QueryLimitExpression = undefined;
 
+    /**
+     * 查询组件的局部版本
+     */
+    @property()
+    ideVersion: string = undefined;
+
     
 
     /**
@@ -202,7 +209,7 @@ export class CallQueryComponent extends LogicItem {
         return (this.groupBy || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getQueryGroupByExpressionUniqueName(name = 'queryGroupByExpression1') {
-        return utils.unique(name, this.getQueryGroupByExpressionExistingNames());
+        return utils.unique(name, this.getQueryGroupByExpressionExistingNames(), undefined, false);
     }
 
     /**
@@ -241,7 +248,7 @@ export class CallQueryComponent extends LogicItem {
                 name: options,
             }, this, 'groupBy');
         } else if (options instanceof QueryGroupByExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryGroupByExpression = options;
             Object.assign(queryGroupByExpression, relationOptions);
         } else {
@@ -329,7 +336,7 @@ export class CallQueryComponent extends LogicItem {
 
     addQueryGroupByExpressionInGroupBy(options?: string | Partial<QueryGroupByExpression> | QueryGroupByExpression) {
         const node = this._addQueryGroupByExpressionInGroupBy(options as any);
-        const index = this.groupBy.length;
+        const index = this.groupBy.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -359,7 +366,7 @@ export class CallQueryComponent extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'orderBy' };
         let queryOrderByExpression: QueryOrderByExpression;
         if (options instanceof QueryOrderByExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryOrderByExpression = options;
             Object.assign(queryOrderByExpression, relationOptions);
         } else {
@@ -433,7 +440,7 @@ export class CallQueryComponent extends LogicItem {
 
     addQueryOrderByExpressionInOrderBy(options?: Partial<QueryOrderByExpression> | QueryOrderByExpression) {
         const node = this._addQueryOrderByExpressionInOrderBy(options as any);
-        const index = this.orderBy.length;
+        const index = this.orderBy.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -775,16 +782,47 @@ export class CallQueryComponent extends LogicItem {
         //   })`;
     }
 
+    isAutoInfer() {
+        return this.ideVersion === '2.11';
+    }
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = `(function(): nasl.collection.PageOf<`;
-        code += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, code))}> {\n`;
+        if (!this.typeAnnotation)
+            return `(function () {
+                return;
+            })()`;
+        let code = `(function(): `;
+        if (this.isAutoInfer()) {
+            code += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, code))} {\n`;
+        } else {
+            code += `nasl.collection.PageOf<`;
+            code += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, code))}> {\n`;
+        }
+        // 2.11版本后 分组使用别名
+        if (this.isAutoInfer()) {
+            // 分组别名（列别名）
+            this.groupBy.forEach((item, index, array) => {
+                code += indent(state.tabSize + 1);
+                const groupElement = item.groupElement as QueryFieldExpression;
+                if (groupElement.asName)
+                    code += `const __${groupElement.asName} = `;
+                if (groupElement.propertyName) {
+                    code += groupElement.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
+                    code += ';\n';
+                } else
+                    code += `__EMPTY_GROUP_BY_NAME__;\n`;
+
+                if (index === array.length - 1)
+                    code += '\n';
+            });
+        }
         // 聚合属性别名
         this.select.selectElements.forEach((item, index, array) => {
             code += indent(state.tabSize + 1);
             const { asName, aggregateName, aggregateParam } = item;
             if (asName)
-                code += `const ${asName} = `;
+                code += `const __${asName} = `;
             if (aggregateName) {
                 code += `nasl.langUtil.${aggregateName}(`;
                 code += aggregateParam.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
@@ -815,7 +853,7 @@ export class CallQueryComponent extends LogicItem {
         });
 
         // 分组属性（Group by）
-        code = this.toEmbeddedTSOfSubPart('GROUP_BY', this.groupBy.map((item) => item.groupElement), {
+        code = this.toEmbeddedTSOfSubPart('GROUP_BY', this.groupBy, {
             code,
             state,
         });
@@ -845,76 +883,251 @@ export class CallQueryComponent extends LogicItem {
         return code;
     }
 
-    genStructure() {
-        const { app } = this;
-        function genPropertyListOfFrom(node: QueryFromExpression | QueryJoinExpression, entities: any[] = []) {
-            if (!node)
-                return [];
+    genPropertyListOfFrom(node: QueryFromExpression | QueryJoinExpression, entities: any[] = []) {
+        if (!node)
+            return [];
 
-            const entityName = node.entityName;
-            entities.push({
-                concept: 'StructureProperty',
-                name: utils.firstLowerCase(entityName),
-                typeAnnotation: {
-                    concept: 'TypeAnnotation',
-                    typeKind: 'reference',
-                    typeName: entityName,
-                    typeNamespace: `${app.getNamespace()}.entities`,
-                },
+        const entityName = node.entityName;
+        entities.push({
+            concept: 'StructureProperty',
+            name: utils.firstLowerCase(entityName),
+            typeAnnotation: {
+                concept: 'TypeAnnotation',
+                typeKind: 'reference',
+                typeName: entityName,
+                typeNamespace: `${this.app.getNamespace()}.entities`,
+            },
+        });
+
+        for (const sub of node.joinParts) {
+            this.genPropertyListOfFrom(sub, entities);
+        }
+
+        return entities;
+    }
+
+    genPropertyListOfAggregate(node: CallQueryComponent) {
+        return node.select.selectElements
+            .filter((item) => item.aggregateName && item.asName)
+            .map((item) => {
+                let typeName;
+                if (['COUNT', 'COUNTD'].includes(item.aggregateName)) {
+                    typeName = 'Integer';
+                } else if (['AVG'].includes(item.aggregateName)) {
+                    typeName = 'Double';
+                } else {
+                    const { entityAsName, propertyName } = item.aggregateParam;
+                    const entity = this.app.entities.find((item: Entity) => item.name === entityAsName);
+                    const property = entity?.properties.find((item) => item.name === propertyName);
+                    typeName = property?.typeAnnotation.typeName;
+                }
+                return {
+                    concept: 'StructureProperty',
+                    name: item.asName,
+                    typeAnnotation: {
+                        concept: 'TypeAnnotation',
+                        typeKind: 'primitive',
+                        typeNamespace: 'nasl.core',
+                        typeName,
+                    },
+                };
             });
+    }
 
-            for (const sub of node.joinParts) {
-                genPropertyListOfFrom(sub, entities);
-            }
+    genPropertyListOfGroupBy(node: CallQueryComponent) {
+        return node.groupBy
+            .filter((item) => item.groupElement && (item.groupElement as QueryFieldExpression).propertyName && (item.groupElement as QueryFieldExpression).asName)
+            .map((item) => {
+                const { entityAsName, propertyName, asName } = item.groupElement as QueryFieldExpression;
+                const entity = this.app.entities.find((item: Entity) => item.name === entityAsName);
+                const property = entity?.properties.find((item) => item.name === propertyName);
+                const typeName = property?.typeAnnotation.typeName;
+                return {
+                    concept: 'StructureProperty',
+                    name: asName,
+                    typeAnnotation: {
+                        concept: 'TypeAnnotation',
+                        typeKind: 'primitive',
+                        typeName,
+                        typeNamespace: 'nasl.core',
+                    },
+                };
+            });
+    }
+
+    genStructure(structureName?: string, properties: any[] = []) {
+        return Structure.from({
+            concept: 'Structure',
+            name: structureName || this.typeAnnotation?.typeName || `${utils.firstUpperCase(this.logic.name)}Structure`,
+            origin: 'CallQueryComponent',
+            properties,
+        });
+    }
+
+    saveStructure() {
+        // 没有数据源时不初始化数据结构
+        if (!this.entityNames.length) {
+            return;
+        }
+
+        if (!this.isAutoInfer()) {
+            // 存量应用走之前的逻辑
+            return this.saveStructureNoInfer();
+        }
 
-            return entities;
+        const groupBy = this.groupBy;
+        const selectElements = this.select.selectElements;
+        let structureName;
+        let typeAnnotation;
+
+        // Structures
+        if (this.typeAnnotation) {
+            const { typeNamespace, typeName, typeArguments } = this.typeAnnotation;
+            if (typeNamespace === 'app.structures') {
+                structureName = typeName;
+                this.removeStructure(structureName);
+            } else if (typeNamespace === 'nasl.collection' && typeName === 'PageOf') {
+                // PageOf<Structures>
+                if (typeArguments[0].typeNamespace === 'app.structures') {
+                    structureName = typeArguments[0].typeName;
+                    this.removeStructure(structureName);
+                }
+            }
         }
 
-        function genPropertyListOfAggregate(node: CallQueryComponent) {
-            return node.select.selectElements
-                .filter((item) => item.aggregateName && item.asName)
-                .map((item) => {
+        structureName = structureName || utils.unique(`${utils.firstUpperCase(this.logic.name)}Structure`, this.app.getStructureExistingNames());
+        const groupByLength = groupBy.filter((item) => (item.groupElement as QueryFieldExpression)?.propertyName && (item.groupElement as QueryFieldExpression).asName).length;
+        const aggregateLength = selectElements.filter((item) => item.aggregateName && item.asName).length;
+
+        // 1. 有分组
+        if (groupByLength) {
+            if (!aggregateLength && groupByLength === 1) {
+                // 1.1 单分组无聚合：`PageOf<列的类型>`
+                const { entityAsName, propertyName } = groupBy[0].groupElement as any;
+                const entity = this.app.entities.find((item: Entity) => item.name === entityAsName);
+                const property = entity?.properties.find((item) => item.name === propertyName);
+                const typeName = property?.typeAnnotation.typeName;
+
+                typeAnnotation = TypeAnnotation.from({
+                    text: `PageOf<${typeName}>`,
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeName: 'PageOf',
+                    typeNamespace: `nasl.collection`,
+                    typeArguments: [
+                        TypeAnnotation.from({
+                            concept: 'TypeAnnotation',
+                            typeKind: 'primitive',
+                            typeName,
+                            typeNamespace: 'nasl.core',
+                        }, this.typeAnnotation, 'typeAnnotation'),
+                    ],
+                }, this, 'typeAnnotation');
+            } else {
+                // 1.2 多分组：`PageOf<Structure>`
+                const structure = this.genStructure(structureName, [
+                    ...this.genPropertyListOfGroupBy(this),
+                    ...this.genPropertyListOfAggregate(this),
+                ]);
+                this.app.addStructure(structure);
+
+                typeAnnotation = TypeAnnotation.from({
+                    text: `PageOf<${structureName}>`,
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeName: 'PageOf',
+                    typeNamespace: `nasl.collection`,
+                    typeArguments: [
+                        TypeAnnotation.from({
+                            concept: 'TypeAnnotation',
+                            typeKind: 'reference',
+                            typeName: structureName,
+                            typeNamespace: 'app.structures',
+                        }, this.typeAnnotation, 'typeAnnotation'),
+                    ],
+                }, this, 'typeAnnotation');
+            }
+        } else { // 2. 无分组
+            if (aggregateLength) {
+                if (aggregateLength === 1) {
+                    // 2.1 单聚合：`基本类型`
                     let typeName;
-                    if (['COUNT', 'COUNTD'].includes(item.aggregateName))
+                    if (['COUNT', 'COUNTD'].includes(selectElements[0].aggregateName)) {
+                        // 2.1.1. `COUNT`、`COUNTD` 返回 `Integer`
                         typeName = 'Integer';
-                    else {
-                        const { entityAsName, propertyName } = item.aggregateParam;
-                        const entity = app.entities.find((item: Entity) => item.name === entityAsName);
+                    } else if (['AVG'].includes(selectElements[0].aggregateName)) {
+                        // 2.1.2. `AVG` 返回 `Double`
+                        typeName = 'Double';
+                    } else {
+                        // 2.1.3. 其他返回列类型，包含：`Integer`、`Long`、`Double`
+                        const { entityAsName, propertyName } = selectElements[0].aggregateParam;
+                        const entity = this.app.entities.find((item: Entity) => item.name === entityAsName);
                         const property = entity?.properties.find((item) => item.name === propertyName);
                         typeName = property?.typeAnnotation.typeName;
                     }
-                    return {
-                        concept: 'StructureProperty',
-                        name: item.asName,
-                        typeAnnotation: {
+                    typeAnnotation = TypeAnnotation.from({
+                        concept: 'TypeAnnotation',
+                        typeKind: 'primitive',
+                        typeName,
+                        typeNamespace: 'nasl.core',
+                    }, this, 'typeAnnotation');
+                } else {
+                    // 2.2. 多聚合：`Structure`（自动创建 `Structure`）
+                    const structure = this.genStructure(structureName, [
+                        ...this.genPropertyListOfAggregate(this),
+                    ]);
+                    this.app.addStructure(structure);
+
+                    typeAnnotation = TypeAnnotation.from({
+                        concept: 'TypeAnnotation',
+                        typeKind: 'reference',
+                        typeName: structureName,
+                        typeNamespace: `app.structures`,
+                    }, this, 'typeAnnotation');
+                }
+            } else {
+                // 2.3. 无聚合(默认情况)：`PageOf<Structure>`（自动创建 `Structure`）
+                const structure = this.genStructure(structureName, [
+                    ...this.genPropertyListOfFrom(this.from),
+                    ...this.genPropertyListOfAggregate(this),
+                ]);
+                this.app.addStructure(structure);
+
+                typeAnnotation = TypeAnnotation.from({
+                    text: structureName,
+                    concept: 'TypeAnnotation',
+                    typeKind: 'generic',
+                    typeName: 'PageOf',
+                    typeNamespace: `nasl.collection`,
+                    typeArguments: [
+                        TypeAnnotation.from({
                             concept: 'TypeAnnotation',
-                            typeKind: 'primitive',
-                            typeNamespace: 'nasl.core',
-                            typeName,
-                        },
-                    };
-                });
+                            typeKind: 'reference',
+                            typeName: structureName,
+                            typeNamespace: 'app.structures',
+                        }, this.typeAnnotation, 'typeAnnotation'),
+                    ],
+                }, this, 'typeAnnotation');
+            }
         }
 
-        const structureName = this.typeAnnotation?.typeName || `${utils.firstUpperCase(this.logic.name)}Structure`;
-
-        return Structure.from({
-            concept: 'Structure',
-            name: structureName,
-            properties: [...genPropertyListOfFrom(this.from), ...genPropertyListOfAggregate(this)],
-        });
+        this.update({ typeAnnotation });
     }
 
-    saveStructure() {
-        const source = this.genStructure();
+    saveStructureNoInfer() {
+        const source = this.genStructure(null, [
+            ...this.genPropertyListOfFrom(this.from),
+            ...this.genPropertyListOfAggregate(this),
+        ]);
         if (this.typeAnnotation) {
             const structure = this.app.structures.find((item) => item.name === this.typeAnnotation.typeName);
             if (structure) {
-                const properties = source.properties.map((property) => StructureProperty.from(property, structure));
+                const properties = source.properties.map((property) => StructureProperty.from(property, structure, 'properties'));
                 structure.update({
                     properties,
                 });
-            }
+            } else
+                this.app.addStructure(source);
         } else {
             source.name = utils.unique(source.name, this.app.getStructureExistingNames());
             this.app.addStructure(source);
@@ -923,24 +1136,32 @@ export class CallQueryComponent extends LogicItem {
                 typeKind: 'reference',
                 typeName: source.name,
                 typeNamespace: `app.structures`,
-            }, this);
+            }, this, 'typeAnnotation');
             this.update({
                 typeAnnotation,
             });
         }
     }
 
-    removeStructure() {
+    removeStructure(structureName?: string) {
         try {
-            this.app.removeStructure(this.typeAnnotation?.typeName);
+            if (this.typeAnnotation) {
+                const { typeNamespace, typeName, typeArguments } = this.typeAnnotation;
+                if (typeNamespace === 'app.structures') {
+                    // Structures
+                    structureName = typeName;
+                    this.app.removeStructure(structureName);
+                } else if (typeNamespace === 'nasl.collection' && typeName === 'PageOf') {
+                    // PageOf<Structures>
+                    if (typeArguments[0].typeNamespace === 'app.structures') {
+                        structureName = typeArguments[0].typeName;
+                        this.app.removeStructure(structureName);
+                    }
+                }
+            }
         } catch {}
     }
 
-    delete() {
-        this.removeStructure();
-        super.delete();
-    }
-
     getEntityNames(node: QueryFromExpression | QueryJoinExpression, set = new Set()) {
         if (node?.entityName)
             set.add(node.entityName);
@@ -997,16 +1218,43 @@ export class CallQueryComponent extends LogicItem {
                 new CompletionProperty({
                     concept: 'CompletionProperty',
                     name: item.asName,
-                    value: item.asName,
+                    value: `inner.${item.asName}`,
                     expression: LogicItem.from({
                         concept: 'Identifier',
                         name: item.asName,
+                        namespace: 'inner',
+                    }),
+                }));
+        if (!children || children.length === 0)
+            return;
+
+        children.forEach((item) => {
+            item.icon = 'variable';
+        });
+        return { name: '聚合属性别名', icon: 'category', children, expanded: true };
+    }
+
+    getCompletionPropertyOfGroupByAsNames() {
+        const children = this.groupBy
+            ?.filter((item) => item.concept === 'QueryGroupByExpression' && (item.groupElement as QueryFieldExpression)?.asName)
+            .map((item) =>
+                new CompletionProperty({
+                    concept: 'CompletionProperty',
+                    name: (item.groupElement as QueryFieldExpression).asName,
+                    value: `inner.${(item.groupElement as QueryFieldExpression).asName}`,
+                    expression: LogicItem.from({
+                        concept: 'Identifier',
+                        name: (item.groupElement as QueryFieldExpression).asName,
+                        namespace: 'inner',
                     }),
                 }));
         if (!children || children.length === 0)
             return;
 
-        return { name: '聚合属性别名', children };
+        children.forEach((item) => {
+            item.icon = 'variable';
+        });
+        return { name: '分组属性别名', icon: 'category', children, expanded: true };
     }
 
     //================================================================================

package/src/concepts/Comment__.ts

@@ -67,7 +67,7 @@ export class Comment extends LogicItem {
     //================================================================================
 
     toJS(state?: TranslatorState): string {
-        return `\n${indent(state.tabSize)}// ${this.value}\n`;
+        return `/* ${this.value} */`;
     }
 
     public static getDefaultOptions() {
@@ -79,7 +79,11 @@ export class Comment extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = '';
-        code += `\n${indent(state.tabSize)}// ${this.value}\n`;
+        code += `\n${indent(state.tabSize)}
+        /**
+         * 注释不用翻译
+         */
+        \n`;
         return code;
     }
     //================================================================================

package/src/concepts/CompletionProperty__.ts

@@ -224,7 +224,7 @@ export class CompletionProperty extends BaseNode {
      * 子集
      */
     @property()
-    children: Array<LogicItem> = undefined;
+    children: Array<CompletionProperty> = undefined;
 
     /**
      * 表达式
@@ -236,6 +236,10 @@ export class CompletionProperty extends BaseNode {
      * 用于展示图标
      */
     icon: string = undefined;
+
+    isProcess: boolean = false;
+
+    noFurther: boolean = false;
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/ConfigGroup__.ts

@@ -84,7 +84,7 @@ export class ConfigGroup extends BaseNode {
         return (this.properties || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getConfigPropertyUniqueName(name = 'configProperty1') {
-        return utils.unique(name, this.getConfigPropertyExistingNames());
+        return utils.unique(name, this.getConfigPropertyExistingNames(), undefined, false);
     }
 
     /**
@@ -123,7 +123,7 @@ export class ConfigGroup extends BaseNode {
                 name: options,
             }, this, 'properties');
         } else if (options instanceof ConfigProperty) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             configProperty = options;
             Object.assign(configProperty, relationOptions);
         } else {
@@ -211,7 +211,7 @@ export class ConfigGroup extends BaseNode {
 
     addConfigProperty(options?: string | Partial<ConfigProperty> | ConfigProperty) {
         const node = this._addConfigProperty(options as any);
-        const index = this.properties.length;
+        const index = this.properties.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/ConfigProperty__.ts

@@ -90,7 +90,7 @@ export class ConfigProperty extends BaseNode {
         return (this.values || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getConfigPropertyValueUniqueName(name = 'configPropertyValue1') {
-        return utils.unique(name, this.getConfigPropertyValueExistingNames());
+        return utils.unique(name, this.getConfigPropertyValueExistingNames(), undefined, false);
     }
 
     /**
@@ -129,7 +129,7 @@ export class ConfigProperty extends BaseNode {
                 name: options,
             }, this, 'values');
         } else if (options instanceof ConfigPropertyValue) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             configPropertyValue = options;
             Object.assign(configPropertyValue, relationOptions);
         } else {
@@ -217,7 +217,7 @@ export class ConfigProperty extends BaseNode {
 
     addConfigPropertyValue(options?: string | Partial<ConfigPropertyValue> | ConfigPropertyValue) {
         const node = this._addConfigPropertyValue(options as any);
-        const index = this.values.length;
+        const index = this.values.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/Configuration__.ts

@@ -68,7 +68,7 @@ export class Configuration extends BaseNode {
         return (this.groups || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getConfigGroupUniqueName(name = 'configGroup1') {
-        return utils.unique(name, this.getConfigGroupExistingNames());
+        return utils.unique(name, this.getConfigGroupExistingNames(), undefined, false);
     }
 
     /**
@@ -107,7 +107,7 @@ export class Configuration extends BaseNode {
                 name: options,
             }, this, 'groups');
         } else if (options instanceof ConfigGroup) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             configGroup = options;
             Object.assign(configGroup, relationOptions);
         } else {
@@ -195,7 +195,7 @@ export class Configuration extends BaseNode {
 
     addConfigGroup(options?: string | Partial<ConfigGroup> | ConfigGroup) {
         const node = this._addConfigGroup(options as any);
-        const index = this.groups.length;
+        const index = this.groups.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/Constant__.ts

@@ -230,9 +230,21 @@ export class Constant extends BaseNode {
             code += ': ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
-        if (this.defaultValue) {
-            code += ` = ${this.defaultValue}`;
+        // if (this.defaultValue) {
+        //     code += ` = ${this.defaultValue}`;
+        // }
+        return code;
+    }
+    @withSourceMap()
+    toEmbeddedTSInProcess(state?: TranslatorState): string {
+        let code = this.name;
+        if (this.typeAnnotation) {
+            code += ': undefined as ';
+            code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
+        // if (this.defaultValue) {
+        //     code += ` : ${this.defaultValue}`;
+        // }
         return code;
     }
     //================================================================================