@lcap/nasl 1.0.1 → 1.0.2

package/src/concepts/Enum__.ts

@@ -125,10 +125,6 @@ export class Enum extends BaseNode {
         });
     }
 
-    
-
-    
-
     /**
     * 插入枚举项
     * @internal
@@ -161,8 +157,6 @@ export class Enum extends BaseNode {
         return enumItem;
     }
 
-    
-
     /**
      * 插入枚举项
      * @param enumItemOptions 枚举项参数
@@ -185,8 +179,6 @@ export class Enum extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加枚举项
      * @internal
@@ -206,8 +198,6 @@ export class Enum extends BaseNode {
         return this._insertEnumItemAt(options as any, index);
     }
 
-    
-
     /**
      * 添加枚举项
      * @param enumItemOptions 枚举项参数
@@ -231,9 +221,6 @@ export class Enum extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
      * 删除枚举项
      * @param enumItem 已有的枚举项实例
@@ -241,7 +228,7 @@ export class Enum extends BaseNode {
     removeEnumItem(enumItem: EnumItem): void;
 
     removeEnumItem(options: EnumItem) {
-        let enumItem: EnumItem = options;
+        const enumItem: EnumItem = options;
         return enumItem.delete();
     }
 
@@ -286,6 +273,11 @@ export class Enum extends BaseNode {
     @property()
     isLeaf: boolean = true;
 
+    getEnumItemExistingNames(excludedList: Array<EnumItem> = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.enumItems || []).filter((item) => !excludedSet.has(item)).map((item) => item.value);
+    }
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = `export class ${this.name} extends nasl.core.Enums {\n`;
@@ -351,7 +343,7 @@ export class Enum extends BaseNode {
     //================================================================================
 }
 
-classMap['Enum'] = Enum;
+classMap.Enum = Enum;
 export default Enum;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Identifier__.ts

@@ -38,8 +38,6 @@ export class Identifier extends LogicItem {
     @property()
     name: string = undefined;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -53,13 +51,6 @@ export class Identifier extends LogicItem {
         return super.from(source, parentNode, parentKey) as Identifier;
     }
 
-    
-    
-
-    
-
-    
-
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
@@ -224,7 +215,7 @@ export class Identifier extends LogicItem {
     //================================================================================
 }
 
-classMap['Identifier'] = Identifier;
+classMap.Identifier = Identifier;
 export default Identifier;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/InterfaceParam__.ts

@@ -309,11 +309,16 @@ export class InterfaceParam extends BaseNode {
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                if (typeNamespace === 'nasl.collection') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                    const properties = node.properties || [];
-                    completionChildren = properties;
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                for (let i = 0; i < properties.length; i++) {
+                    const item = properties[i];
+                    if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                        properties[i].typeAnnotation = this?.typeAnnotation?.typeArguments[0];
+                        properties[i].parentNode = this;
+                    }
                 }
+                completionChildren = properties;
             } else {
                 completionChildren = undefined;
             }

package/src/concepts/Param__.ts

@@ -305,7 +305,7 @@ export class Param extends BaseNode {
             typeAnnotation,
         };
         try {
-            this.completionChildren = this.getSelectRef();
+            this.completionChildren = this.getSelectRef(typeAnnotation);
         } catch (err) {
             this.completionChildren = [];
             console.log(err);
@@ -350,9 +350,9 @@ export class Param extends BaseNode {
     get isTreeLeaf() {
         return !this.hasChildren;
     }
-    getSelectRef() {
+    getSelectRef(newTypeAnnotation: TypeAnnotation) {
         try {
-            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            const { typeName, typeKind, typeNamespace } = newTypeAnnotation || this.typeAnnotation;
             let completionChildren;
             if (typeKind === 'reference') {
                 if (typeNamespace === 'nasl.ui') {
@@ -367,11 +367,18 @@ export class Param extends BaseNode {
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                if (typeNamespace === 'nasl.collection') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                    const properties = node.properties || [];
-                    completionChildren = properties;
+                // if (typeNamespace === 'nasl.collection' || typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.interface') {
+                // }
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                for (let i = 0; i < properties.length; i++) {
+                    const item = properties[i];
+                    if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                        properties[i].typeAnnotation = this?.typeAnnotation?.typeArguments[0];
+                        properties[i].parentNode = this;
+                    }
                 }
+                completionChildren = properties;
             } else {
                 completionChildren = undefined;
             }

package/src/concepts/ProcessElement__.ts

@@ -1348,7 +1348,8 @@ export class ProcessElement extends BaseNode {
         });
 
         if (this.type === 'UserTask'
-            || this.type === 'ExclusiveGateway') {
+            || this.type === 'ExclusiveGateway'
+            || this.type === 'AutoTask') {
             const prevTasks = getPreviousTask(this);
             let prevCode = `${tab3}const ${this.process.name} = {\n`;
             const processName = this.process.name;
@@ -1374,6 +1375,11 @@ export class ProcessElement extends BaseNode {
                     if (attr.name === 'destination') {
                         code += `${attr.destination.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode)},\n`;
                     }
+                    if (attr.name === 'assignee') {
+                        code += `assignee: function(): string[] {\n`
+                        code += `${attr.assignee.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode)}\n`;
+                        code += `},\n`;
+                    }
                 });
                 const logic = genUserTaskLogic(this);
                 // sourceMap 映射
@@ -1384,8 +1390,8 @@ export class ProcessElement extends BaseNode {
                 code += `${tab1}}`;
             }
 
-            if (this.type === 'ExclusiveGateway') {
-                prevCode += `\n${tab5}${this.name}:  elements.${this.name},\n`;
+            if(this.type === 'ExclusiveGateway' || this.type === 'AutoTask') {
+                prevCode += `\n${tab5}${this.name}:  elements.${this.name},\n`
                 prevCode += `${tab3}}\n`;
                 code += `${tab1}logic: ${this.logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: state.tabSize + 3 }), prevCode, true)},`;
             }

package/src/concepts/QueryAggregateExpression__.ts

@@ -138,7 +138,7 @@ export class QueryAggregateExpression extends LogicItem {
         //     code += `[__EMPTY_AGGREGATE_NAME__, '']`;
 
         // return code;
-        return `__${this.asName || '__EMPTY_AGGREGATE_ALIAS__'}`;
+        return `__${this.asName || 'EMPTY_AGGREGATE_ALIAS__'}`;
     }
 
     setName(asName: string) {

package/src/concepts/QueryFieldExpression__.ts

@@ -103,6 +103,10 @@ export class QueryFieldExpression extends LogicItem {
         };
     }
 
+    setName(asName: string) {
+        this.update({ asName });
+    }
+
     getValue() {
         const { entityAsName, propertyName } = this;
         return `${entityAsName}.${propertyName}`;

package/src/concepts/QueryGroupByExpression__.ts

@@ -1,3 +1,7 @@
+import { withSourceMap } from '../translator';
+import type CallQueryComponent from './CallQueryComponent__';
+import type QueryFieldExpression from './QueryFieldExpression__';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -125,6 +129,25 @@ export class QueryGroupByExpression extends LogicItem {
         };
     }
 
+    setEntityAsName(name: string) {
+        (this.groupElement as QueryFieldExpression).setEntityAsName(name);
+    }
+
+    setPropertyName(name: string) {
+        (this.groupElement as QueryFieldExpression).setPropertyName(name);
+    }
+
+    @withSourceMap()
+    toEmbeddedTS(): string {
+        // 判断老应用
+        if ((this.parentNode as CallQueryComponent).isAutoInfer()) {
+            // 2.11版本后 分组使用别名
+            return `__${(this.groupElement as QueryFieldExpression).asName || 'EMPTY_GROUP_BY_ALIAS__'}`;
+        } else {
+            return (this.groupElement as QueryFieldExpression).toEmbeddedTS();
+        }
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Return__.ts

@@ -252,9 +252,9 @@ export class Return extends BaseNode {
             code += ': undefined as ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
-        if (this.defaultValue) {
-            code += `: ${this.defaultValue}`;
-        }
+        // if (this.defaultValue) {
+        //     code += `: ${this.defaultValue}`;
+        // }
         return code;
     }
 
@@ -284,7 +284,7 @@ export class Return extends BaseNode {
         }
         // 处理下拉属性
         try {
-            this.completionChildren = this.getSelectRef();
+            this.completionChildren = this.getSelectRef(typeAnnotation);
         } catch (err) {
             this.completionChildren = [];
             console.log(err);
@@ -327,9 +327,9 @@ export class Return extends BaseNode {
     get isTreeLeaf() {
         return !this.hasChildren;
     }
-    getSelectRef() {
+    getSelectRef(newTypeAnnotation: TypeAnnotation) {
         try {
-            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            const { typeName, typeKind, typeNamespace } = newTypeAnnotation || this.typeAnnotation;
             let completionChildren;
             if (typeKind === 'reference') {
                 if (typeNamespace === 'nasl.ui') {
@@ -344,11 +344,16 @@ export class Return extends BaseNode {
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                if (typeNamespace === 'nasl.collection') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                    const properties = node.properties || [];
-                    completionChildren = properties;
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                for (let i = 0; i < properties.length; i++) {
+                    const item = properties[i];
+                    if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                        properties[i].typeAnnotation = this?.typeAnnotation?.typeArguments[0];
+                        properties[i].parentNode = this;
+                    }
                 }
+                completionChildren = properties;
             } else {
                 completionChildren = undefined;
             }

package/src/concepts/StringLiteral__.ts

@@ -94,14 +94,7 @@ export class StringLiteral extends LogicItem {
     toEmbeddedTS(state?: TranslatorState, isRequired?: boolean): string {
         let code = '';
         if (typeof this.value === 'string') {
-            if (!this.value.includes("'"))
-                code += `'${this.value}'`;
-            else if (!this.value.includes('"'))
-                code += `"${this.value}"`;
-            else if (!this.value.includes('`'))
-                code += `\`${this.value}\``;
-            else
-                code += `'${this.value.replace(/'/g, "\\'")}'`;
+            code += `'StringLiteral'`;
         } else {
             code += isRequired ? '__IDENTIFIER__' : `''`;
         }

package/src/concepts/StructureProperty__.ts

@@ -263,11 +263,11 @@ export class StructureProperty extends BaseNode {
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                if (typeNamespace === 'nasl.collection') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                    const properties = node.properties || [];
-                    completionChildren = properties;
-                }
+                // if (typeNamespace === 'nasl.collection' || typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.interface') {
+                // }
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                completionChildren = properties;
             } else {
                 completionChildren = undefined;
             }

package/src/concepts/TypeAnnotation__.ts

@@ -267,10 +267,18 @@ export class TypeAnnotation extends BaseNode {
         } else if (this.typeKind === 'reference') {
             return `${this.typeName}`;
         } else if (this.typeKind === 'generic') {
-            if (this.typeArguments && this.typeArguments.length)
-                return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.typeName || 'T')}>`;
-            else
-                return this.typeName;
+            let str = `${this.typeName}`;
+            const loop = (typeArguments: Array<TypeAnnotation>) => {
+                str += '<' + (typeArguments[0].typeName || 'T');
+                if (typeArguments[0].typeKind === 'generic') {
+                    if (this.typeArguments && this.typeArguments.length) {
+                        loop(typeArguments[0].typeArguments);
+                    }
+                }
+                str += '>';
+            };
+            loop(this.typeArguments);
+            return str;
         } else {
             return this.typeName;
         }

package/src/concepts/Variable__.ts

@@ -253,9 +253,9 @@ export class Variable extends BaseNode {
             code += ': undefined as ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
-        if (this.defaultValue) {
-            code += `: ${this.defaultValue}`;
-        }
+        // if (this.defaultValue) {
+        //     code += `: ${this.defaultValue}`;
+        // }
         return code;
     }
 
@@ -281,7 +281,7 @@ export class Variable extends BaseNode {
         }
         // 处理下拉属性
         try {
-            this.completionChildren = this.getSelectRef();
+            this.completionChildren = this.getSelectRef(typeAnnotation);
         } catch (err) {
             this.completionChildren = [];
             console.log(err);
@@ -324,9 +324,9 @@ export class Variable extends BaseNode {
     get isTreeLeaf() {
         return !this.hasChildren;
     }
-    getSelectRef() {
+    getSelectRef(newTypeAnnotation: TypeAnnotation) {
         try {
-            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            const { typeName, typeKind, typeNamespace } = newTypeAnnotation || this.typeAnnotation;
             let completionChildren;
             if (typeKind === 'reference') {
                 if (typeNamespace === 'nasl.ui') {
@@ -341,11 +341,16 @@ export class Variable extends BaseNode {
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                if (typeNamespace === 'nasl.collection') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                    const properties = node.properties || [];
-                    completionChildren = properties;
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                for (let i = 0; i < properties.length; i++) {
+                    const item = properties[i];
+                    if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                        properties[i].typeAnnotation = this?.typeAnnotation?.typeArguments[0];
+                        properties[i].parentNode = this;
+                    }
                 }
+                completionChildren = properties;
             } else {
                 completionChildren = undefined;
             }

package/src/concepts/ViewElement__.ts

@@ -864,7 +864,7 @@ export class ViewElement extends BaseNode {
     }
 
 
-    
+
 
     /**
     * 删除元素绑定属性
@@ -1120,7 +1120,7 @@ export class ViewElement extends BaseNode {
 
     haveScope(node: ViewElement): boolean {
         // uGallery 没有子集不需要scope
-        const dataSourcePcList = ['uTableView', 'uListView', 'uGridView', 'uCalendarView', 'uListComponents', 'uSelect'];
+        const dataSourcePcList = ['uTableView', 'uListView', 'uGridView', 'uCalendarView', 'uListComponents', 'uSelect', 'devopsDragTable'];
         const dataSourceH5List = ['vanRadioGroup', 'vanCheckboxGroup', 'vanListView', 'vanGridView', 'vanForComponents', 'lcapEchartsLine', 'lcapEchartsBar', 'lcapEchartsPie'];
         const dataSourceList = [...dataSourcePcList, ...dataSourceH5List];
         return dataSourceList.includes(node.toHump(node.tag));

package/src/concepts/View__.ts

@@ -654,10 +654,6 @@ export class View extends BaseNode {
     }
 
 
-    getLogicExistingNames(excludedList: Array<Logic> = []) {
-        const excludedSet = new Set(excludedList);
-        return (this.logics || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
     getLogicUniqueName(name = 'logic1') {
         return utils.unique(name, this.getLogicExistingNames(), undefined, false);
     }
@@ -1545,6 +1541,21 @@ export class View extends BaseNode {
         this.emit('change', $event);
     }
 
+    getLogicExistingNames(excludedList: Array<Logic> = []) {
+        const excludedSet = new Set(excludedList);
+        const varList: any[] = [];
+        if (Array.isArray(this.params)) {
+            varList.push(...this.params);
+        }
+        if (Array.isArray(this.variables)) {
+            varList.push(...this.variables);
+        }
+        if (Array.isArray(this.logics)) {
+            varList.push(...this.logics);
+        }
+        return varList.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+
     getVarExistingNames(excludedList: Array<Param | Variable> = []) {
         const excludedSet = new Set(excludedList);
         const varList: any[] = [];
@@ -1556,6 +1567,7 @@ export class View extends BaseNode {
         }
         if (Array.isArray(this.logics)) {
             this.logics.forEach((logic) => {
+                varList.push(logic);
                 if (Array.isArray(logic.params)) {
                     varList.push(...logic.params);
                 }

package/src/concepts/basics/stdlib/nasl.configuration.ts

@@ -8,7 +8,7 @@ export default new Namespace({
     name: 'configuration',
     logics: [
         new Logic({
-            name: 'getConfig',
+            name: 'getCustomConfig',
             params: [
                 new Param({
                     name: 'name',

package/src/concepts/basics/stdlib/nasl.interface.ts

@@ -10,7 +10,7 @@ import { primitiveTypeList } from '../types/coreTypeList';
 import { reference2TypeAnnotationList } from './reference2TypeAnnotationList';
 import TypeParam from '../../TypeParam__';
 
-const interfaceStructures = [
+export const interfaceStructures = [
     new Structure({
         name: 'ApiReturnOf',
         typeParams: [

package/src/concepts/basics/stdlib/nasl.util.ts

@@ -718,51 +718,35 @@ export default new Namespace({
             ],
         }),
         new Function({
-            name: 'GetProperties',
-            description: '获取应用配置参数',
+            name: 'CreatePageOf',
+            description: '将List<T>集合转换为分页集合PageOf<T>',
             params: [
                 new Param({
-                    name: 'name',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    useComponent: { type: 's-config-select' },
+                    name: 'list',
+                    typeAnnotation: TypeAnnotation.createGeneric('List', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
+                }),
+                new Param({
+                    name: 'page',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+                new Param({
+                    name: 'size',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+                }),
+                new Param({
+                    name: 'total',
+                    typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
             ],
             returns: [
                 new Return({
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
+                        typeArguments: [TypeAnnotation.createTypeParam('T')],
+                    }),
                 }),
             ],
         }),
-        // new Function({
-        //     name: 'CreatePageOf',
-        //     description: '将List<T>集合转换为分页集合PageOf<T>',
-        //     params: [
-        //         new Param({
-        //             name: 'list',
-        //             typeAnnotation: TypeAnnotation.createGeneric('List', {
-        //                 typeArguments: [TypeAnnotation.createTypeParam('T')],
-        //             }),
-        //         }),
-        //         new Param({
-        //             name: 'page',
-        //             typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-        //         }),
-        //         new Param({
-        //             name: 'size',
-        //             typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-        //         }),
-        //         new Param({
-        //             name: 'total',
-        //             typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-        //         }),
-        //     ],
-        //     returns: [
-        //         new Return({
-        //             typeAnnotation: TypeAnnotation.createPrimitive('PageOf', {
-        //                 typeArguments: [TypeAnnotation.createTypeParam('T')],
-        //             }),
-        //         }),
-        //     ],
-        // }),
     ],
 });

package/src/concepts/basics/stdlib/reference2TypeAnnotationList.ts

@@ -9,7 +9,7 @@ import Enum from '../../Enum__';
 import TypeAnnotation from '../../TypeAnnotation__';
 import { primitiveTypeList } from '../types/coreTypeList';
 
-export function reference2TypeAnnotationList(list: Array<Entity | Structure | Enum>, namespace: string) {
+export function reference2TypeAnnotationList(list: Array<Entity | Structure | Enum> = [], namespace: string) {
     return list.map((item) => {
         if (item instanceof Structure && item.typeParams?.length > 0) {
             return TypeAnnotation.createReference(item.name, {

package/src/concepts/basics/types/index.ts

@@ -18,3 +18,4 @@ primitiveTypeList.forEach((typeAnnotation) => {
 export { collectionStructures, collectionTypeList } from '../stdlib/nasl.collection';
 export { uiStructures, uiTypeList } from '../stdlib/nasl.ui';
 export { interfaceTypeList } from '../stdlib/nasl.interface';
+export { interfaceStructures } from '../stdlib/nasl.interface';

package/src/enums/KEYWORDS.ts

@@ -789,7 +789,6 @@ export const ENTITY_KEYWORDS = [
     'PROTECTED',
     'PUBLIC',
     'PURGE',
-    'Page',
     'Pageable',
     'PaginationUtil',
     'PutMapping',
@@ -912,14 +911,12 @@ export const ENTITY_KEYWORDS = [
     'SHUTDOWN',
     'SIGNAL',
     'SIMILAR',
-    'SIZE',
     'SKIP',
     'SKIP_UNUSABLE_INDEXES',
     'SLOW',
     'SMALLINT',
     'SNAPSHOT',
     'SOME',
-    'SORT',
     'SPATIAL',
     'SPECIFIC',
     'SPECIFICATION',
@@ -1197,8 +1194,4 @@ export const ENTITY_PROPERTY_KEYWORDS = [
     'PUBLIC',
     'STATIC',
     'YIELD',
-    'SIZE',
-    'SORT',
-    'CODE',
-    'PAGE',
 ];

package/src/manager/diagnostic.ts

@@ -10,7 +10,7 @@ import * as tsProtocol from 'typescript/lib/protocol';
 export interface Diagnostic {
     id?: string;
     severity: string;
-    originalDiagnostic: tsProtocol.DiagnosticWithFileName;
+    originalDiagnostic?: tsProtocol.DiagnosticWithFileName;
     message?: string;
     code?: number;
     node?: BaseNode;