@lcap/nasl 3.4.0-beta.6 → 3.5.0-alpha.1

package/src/concepts/WhileStatement__.ts

@@ -14,25 +14,24 @@ import {
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
-import BaseNode from '../common/BaseNode';
 import LogicItem from './LogicItem__';
 
 /**
  * While 循环分支
  */
-@className
 @concept('While 循环分支')
-// @ts-ignore
 export class WhileStatement extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'WhileStatement';
+  static readonly ConceptName: string = 'WhileStatement';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -47,7 +46,6 @@ export class WhileStatement extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  // @ts-ignore
   test!: LogicItem;
 
   /**
@@ -105,8 +103,9 @@ export class WhileStatement extends LogicItem {
   _insertItemAt(options: Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'body' };
+    const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (options instanceof LogicItem) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);

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

@@ -1,6 +1,4 @@
 import Namespace from '../../Namespace__';
-import Structure from '../../Structure__';
-import TypeAnnotation from '../../TypeAnnotation__';
 
 import naslCore from './nasl.core';
 import naslCollection from './nasl.collection';
@@ -17,25 +15,73 @@ import naslLogging from './nasl.logging';
 import naslIo from './nasl.io';
 import naslEvent from './nasl.event';
 
+import { initialize as authInit } from './nasl.auth';
+import { initialize as browserInit } from './nasl.browser';
+import { initialize as collectionInit } from './nasl.collection';
+import { initialize as configurationInit } from './nasl.configuration';
+import { initialize as coreInit } from './nasl.core';
+import { initialize as eventInit } from './nasl.event';
+import { initialize as httpInit } from './nasl.http';
+import { initialize as interfaceInit } from './nasl.interface';
+import { initialize as ioInit } from './nasl.io';
+import { initialize as loggingInit } from './nasl.logging';
+import { initialize as processInit } from './nasl.process';
+import { initialize as uiInit } from './nasl.ui';
+import { initialize as utilInit } from './nasl.util';
+import { initialize as validationInit } from './nasl.validation';
+
 export { reference2TypeAnnotationList } from './reference2TypeAnnotationList';
+
+/**
+ * 内置库
+ *
+ * @description 因为循环引用的问题，不推荐直接引用此静态变量，请使用`getStdlibNamespace`方法获取。
+ * @deprecated
+ */
 export const stdlibNamespace = new Namespace({
-    name: 'nasl',
-    path: 'nasl',
-    children: [
-        naslCore,
-        naslCollection,
-        naslInterface,
-        naslUi,
-        naslUtil,
-        naslProcess,
-        naslValidation,
-        naslBrowser,
-        naslAuth,
-        naslConfiguration,
-        naslLogging,
-        naslIo,
-        naslHttp,
-        naslEvent
-    ],
+  name: 'nasl',
+  path: 'nasl',
+  children: [
+    naslCore,
+    naslCollection,
+    naslInterface,
+    naslUi,
+    naslUtil,
+    naslProcess,
+    naslValidation,
+    naslBrowser,
+    naslAuth,
+    naslConfiguration,
+    naslLogging,
+    naslIo,
+    naslHttp,
+    naslEvent
+  ],
 });
+
 export default stdlibNamespace;
+
+/**
+ * 获取内置库数据
+ */
+export function getStdlibNamespace() {
+  return stdlibNamespace;
+}
+
+/** @internal */
+export function initialize() {
+  authInit();
+  browserInit();
+  collectionInit();
+  configurationInit();
+  coreInit();
+  eventInit();
+  httpInit();
+  interfaceInit();
+  ioInit();
+  loggingInit();
+  processInit();
+  uiInit();
+  utilInit();
+  validationInit();
+}

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

@@ -1,160 +1,178 @@
 import Namespace from '../../Namespace__';
-import Param from '../../Param__';
-import Return from '../../Return__';
-import Logic from '../../Logic__';
-import TypeAnnotation from '../../TypeAnnotation__';
-import Structure from '../../Structure__';
-import StructureProperty from '../../StructureProperty__';
+import type TypeAnnotation from '../../TypeAnnotation__';
+import type Structure from '../../Structure__';
 import { reference2TypeAnnotationList } from './reference2TypeAnnotationList';
+import { getConceptConstructor } from '../../../decorators';
 
-export const authStructures = [
+export const authStructures: Structure[] = [];
+export const authTypeList: TypeAnnotation[] = [];
+
+const authNamespace = new Namespace({
+  name: 'auth',
+  structures: authStructures,
+  logics: [],
+});
+
+export default authNamespace;
+
+/** @internal */
+export function initialize() {
+  const Structure = getConceptConstructor('Structure');
+  const StructureProperty = getConceptConstructor('StructureProperty');
+  const TypeAnnotation = getConceptConstructor('TypeAnnotation');
+  const Logic = getConceptConstructor('Logic');
+  const Param = getConceptConstructor('Param');
+  const Return = getConceptConstructor('Return');
+
+  authStructures.push(
     new Structure({
-        name: 'LCAPCurrentUserInfo',
-        properties: [
-            new StructureProperty({
-                name: 'status',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'nickName',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'userName',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'email',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'userId',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'phone',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'createTime',
-                typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-            }),
-            new StructureProperty({
-                name: 'updateTime',
-                typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-            }),
-            new StructureProperty({
-                name: 'source',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-        ],
+      name: 'LCAPCurrentUserInfo',
+      properties: [
+        new StructureProperty({
+          name: 'status',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'nickName',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'userName',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'email',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'userId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'phone',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'createTime',
+          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        }),
+        new StructureProperty({
+          name: 'updateTime',
+          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        }),
+        new StructureProperty({
+          name: 'source',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
     }),
     new Structure({
-        name: 'LCAPUser',
-        properties: [
-            new StructureProperty({
-                name: 'userName',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'userId',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'extendFiledMap',
-                typeAnnotation: TypeAnnotation.createGeneric('map', {
-                    typeArguments: [
-                        // TypeAnnotation.createPrimitive('String'),
-                        // TypeAnnotation.createPrimitive('String'),
-                        TypeAnnotation.createTypeParam('K'),
-                        TypeAnnotation.createTypeParam('V'),
-                    ],
-                }),
-            }),
-        ],
+      name: 'LCAPUser',
+      properties: [
+        new StructureProperty({
+          name: 'userName',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'userId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'extendFiledMap',
+          typeAnnotation: TypeAnnotation.createGeneric('map', {
+            typeArguments: [
+              // TypeAnnotation.createPrimitive('String'),
+              // TypeAnnotation.createPrimitive('String'),
+              TypeAnnotation.createTypeParam('K'),
+              TypeAnnotation.createTypeParam('V'),
+            ],
+          }),
+        }),
+      ],
     }),
-];
+  );
 
-export const authTypeList: Array<TypeAnnotation> = reference2TypeAnnotationList(authStructures, 'nasl.auth');
+  authTypeList.push(
+    ...reference2TypeAnnotationList(authStructures, 'nasl.auth'),
+  );
 
-export default new Namespace({
-    name: 'auth',
-    structures: authStructures,
-    logics: [
-        new Logic({
-            name: 'hasAuth',
-            params: [
-                new Param({
-                    name: 'authPath',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                }),
-            ],
-            returns: [],
-        }),
-        new Logic({
-            name: 'logout',
-            params: [],
-            returns: [],
-        }),
-        new Logic({
-            name: 'encryptByAES',
-            params: [
-                new Param({
-                    name: 'string',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                }),
-            ],
-            returns: [],
-        }),
-        new Logic({
-            name: 'decryptByAES',
-            params: [
-                new Param({
-                    name: 'string',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                }),
-            ],
-            returns: [],
-        }),
-        new Logic({
-            name: 'getUserList',
-            params: [
-                new Param({
-                    name: 'userNameFilter',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                }),
-                new Param({
-                    name: 'limit',
-                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-                }),
-                new Param({
-                    name: 'offset',
-                    typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-                }),
-            ],
-            returns: [
-                new Return({
-                    name: 'result',
-                    typeAnnotation: TypeAnnotation.createGeneric('List', {
-                        typeArguments: [TypeAnnotation.createTypeParam('T')],
-                    }),
-                }),
-            ],
+  const logics = [
+    new Logic({
+      name: 'hasAuth',
+      params: [
+        new Param({
+          name: 'authPath',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
         }),
-        new Logic({
-            name: 'getCurrentUser',
-            description: '获取当前登录用户信息，需在登录后调用',
-            returns: [
-                new Return({
-                    name: 'result',
-                    typeAnnotation: TypeAnnotation.from({
-                        concept: 'TypeAnnotation',
-                        typeKind: 'reference',
-                        typeName: 'LCAPCurrentUserInfo',
-                        typeNamespace: `nasl.auth`,
-                    }),
-                }),
-            ],
+      ],
+      returns: [],
+    }),
+    new Logic({
+      name: 'logout',
+      params: [],
+      returns: [],
+    }),
+    new Logic({
+      name: 'encryptByAES',
+      params: [
+        new Param({
+          name: 'string',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
         }),
-    ],
-});
+      ],
+      returns: [],
+    }),
+    new Logic({
+      name: 'decryptByAES',
+      params: [
+        new Param({
+          name: 'string',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+      returns: [],
+    }),
+    new Logic({
+      name: 'getUserList',
+      params: [
+        new Param({
+          name: 'userNameFilter',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new Param({
+          name: 'limit',
+          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        }),
+        new Param({
+          name: 'offset',
+          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        }),
+      ],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createGeneric('List', {
+            typeArguments: [TypeAnnotation.createTypeParam('T')],
+          }),
+        }),
+      ],
+    }),
+    new Logic({
+      name: 'getCurrentUser',
+      description: '获取当前登录用户信息，需在登录后调用',
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.from({
+            concept: 'TypeAnnotation',
+            typeKind: 'reference',
+            typeName: 'LCAPCurrentUserInfo',
+            typeNamespace: `nasl.auth`,
+          }),
+        }),
+      ],
+    }),
+  ];
+
+  logics.forEach((logic) => authNamespace.addLogic(logic));
+}