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

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

@@ -1,168 +1,180 @@
 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 TypeParam from '../../TypeParam__';
+import { getConceptConstructor } from '../../../decorators';
 
-export const httpStructures = [
+export const httpStructures: Structure[] = [];
+export const httpTypeList: TypeAnnotation[] = [];
+
+const httpNamespace = new Namespace({
+  name: 'http',
+  structures: httpStructures,
+  logics: [],
+});
+
+export default httpNamespace;
+
+/** @internal */
+export function initialize() {
+  const Logic = getConceptConstructor('Logic');
+  const Structure = getConceptConstructor('Structure');
+  const StructureProperty = getConceptConstructor('StructureProperty');
+  const TypeAnnotation = getConceptConstructor('TypeAnnotation');
+  const TypeParam = getConceptConstructor('TypeParam');
+
+  httpStructures.push(
     new Structure({
-        name: 'HttpCookie',
-        properties: [
-            new StructureProperty({
-                name: 'name',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'value',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'domain',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'cookiePath',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'sameSite',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'httpOnly',
-                typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
-            }),
-            new StructureProperty({
-                name: 'secure',
-                typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
-            }),
-            new StructureProperty({
-                name: 'maxAge',
-                typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-            }),
-        ],
+      name: 'HttpCookie',
+      properties: [
+        new StructureProperty({
+          name: 'name',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'value',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'domain',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'cookiePath',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'sameSite',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'httpOnly',
+          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+        }),
+        new StructureProperty({
+          name: 'secure',
+          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+        }),
+        new StructureProperty({
+          name: 'maxAge',
+          typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+        }),
+      ],
     }),
     new Structure({
-        name: 'HttpResponse',
-        typeParams: [
-            new TypeParam({
-                name: 'T',
-            }),
-        ],
-        properties: [
-            new StructureProperty({
-                name: 'status',
-                typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
-            }),
-            new StructureProperty({
-                name: 'body',
-                typeAnnotation: TypeAnnotation.createTypeParam('T'),
-            }),
-            new StructureProperty({
-                name: 'headers',
-                typeAnnotation: TypeAnnotation.createGeneric('Map', {
-                    typeArguments: [
-                        TypeAnnotation.createPrimitive('String'),
-                        TypeAnnotation.createPrimitive('String'),
-                        // TypeAnnotation.createTypeParam('K'),
-                        // TypeAnnotation.createTypeParam('V'),
-                    ],
-                }),
-            }), new StructureProperty({
-                name: 'cookies',
-                typeAnnotation: TypeAnnotation.createGeneric('Map', {
-                    typeArguments: [
-                        TypeAnnotation.createPrimitive('String'),
-                        // TypeAnnotation.createTypeParam('K'),
-                        TypeAnnotation.createReference('HttpCookie', {
-                            typeNamespace: 'nasl.http',
-                        }),
-                    ],
-                }),
-            }),
-        ],
+      name: 'HttpResponse',
+      typeParams: [
+        new TypeParam({
+          name: 'T',
+        }),
+      ],
+      properties: [
+        new StructureProperty({
+          name: 'status',
+          typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
+        }),
+        new StructureProperty({
+          name: 'body',
+          typeAnnotation: TypeAnnotation.createTypeParam('T'),
+        }),
+        new StructureProperty({
+          name: 'headers',
+          typeAnnotation: TypeAnnotation.createGeneric('Map', {
+            typeArguments: [
+              TypeAnnotation.createPrimitive('String'),
+              TypeAnnotation.createPrimitive('String'),
+              // TypeAnnotation.createTypeParam('K'),
+              // TypeAnnotation.createTypeParam('V'),
+            ],
+          }),
+        }), new StructureProperty({
+          name: 'cookies',
+          typeAnnotation: TypeAnnotation.createGeneric('Map', {
+            typeArguments: [
+              TypeAnnotation.createPrimitive('String'),
+              // TypeAnnotation.createTypeParam('K'),
+              TypeAnnotation.createReference('HttpCookie', {
+                typeNamespace: 'nasl.http',
+              }),
+            ],
+          }),
+        }),
+      ],
     }),
     new Structure({
-        name: 'HttpRequest',
-        typeParams: [
-            new TypeParam({
-                name: 'T',
-            }),
-        ],
-        properties: [
-            new StructureProperty({
-                name: 'requestURL',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'remoteIp',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'requestMethod',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-            new StructureProperty({
-                name: 'body',
-                typeAnnotation: TypeAnnotation.createTypeParam('T'),
-            }),
-            new StructureProperty({
-                name: 'headers',
-                typeAnnotation: TypeAnnotation.createGeneric('Map', {
-                    typeArguments: [
-                        TypeAnnotation.createPrimitive('String'),
-                        TypeAnnotation.createPrimitive('String'),
-                        // TypeAnnotation.createTypeParam('K'),
-                        // TypeAnnotation.createTypeParam('V'),
-                    ],
-                }),
-            }),
-            new StructureProperty({
-                name: 'pathParams',
-                typeAnnotation: TypeAnnotation.createGeneric('Map', {
-                    typeArguments: [
-                        TypeAnnotation.createPrimitive('String'),
-                        TypeAnnotation.createPrimitive('String'),
-                        // TypeAnnotation.createTypeParam('K'),
-                        // TypeAnnotation.createTypeParam('V'),
-                    ],
-                }),
-            }),
-            new StructureProperty({
-                name: 'queryParams',
-                typeAnnotation: TypeAnnotation.createGeneric('Map', {
-                    typeArguments: [
-                        TypeAnnotation.createPrimitive('String'),
-                        TypeAnnotation.createPrimitive('String'),
-                        // TypeAnnotation.createTypeParam('K'),
-                        // TypeAnnotation.createTypeParam('V'),
-                    ],
-                }),
-            }),
-            new StructureProperty({
-                name: 'cookies',
-                typeAnnotation: TypeAnnotation.createGeneric('Map', {
-                    typeArguments: [
-                        TypeAnnotation.createPrimitive('String'),
-                        // TypeAnnotation.createTypeParam('K'),
-                        TypeAnnotation.createReference('HttpCookie', {
-                            typeNamespace: 'nasl.http',
-                        }),
-                    ],
-                }),
-            }),
-        ],
+      name: 'HttpRequest',
+      typeParams: [
+        new TypeParam({
+          name: 'T',
+        }),
+      ],
+      properties: [
+        new StructureProperty({
+          name: 'requestURL',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'remoteIp',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'requestMethod',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'body',
+          typeAnnotation: TypeAnnotation.createTypeParam('T'),
+        }),
+        new StructureProperty({
+          name: 'headers',
+          typeAnnotation: TypeAnnotation.createGeneric('Map', {
+            typeArguments: [
+              TypeAnnotation.createPrimitive('String'),
+              TypeAnnotation.createPrimitive('String'),
+              // TypeAnnotation.createTypeParam('K'),
+              // TypeAnnotation.createTypeParam('V'),
+            ],
+          }),
+        }),
+        new StructureProperty({
+          name: 'pathParams',
+          typeAnnotation: TypeAnnotation.createGeneric('Map', {
+            typeArguments: [
+              TypeAnnotation.createPrimitive('String'),
+              TypeAnnotation.createPrimitive('String'),
+              // TypeAnnotation.createTypeParam('K'),
+              // TypeAnnotation.createTypeParam('V'),
+            ],
+          }),
+        }),
+        new StructureProperty({
+          name: 'queryParams',
+          typeAnnotation: TypeAnnotation.createGeneric('Map', {
+            typeArguments: [
+              TypeAnnotation.createPrimitive('String'),
+              TypeAnnotation.createPrimitive('String'),
+              // TypeAnnotation.createTypeParam('K'),
+              // TypeAnnotation.createTypeParam('V'),
+            ],
+          }),
+        }),
+        new StructureProperty({
+          name: 'cookies',
+          typeAnnotation: TypeAnnotation.createGeneric('Map', {
+            typeArguments: [
+              TypeAnnotation.createPrimitive('String'),
+              // TypeAnnotation.createTypeParam('K'),
+              TypeAnnotation.createReference('HttpCookie', {
+                typeNamespace: 'nasl.http',
+              }),
+            ],
+          }),
+        }),
+      ],
     }),
-];
-
-export const httpTypeList: Array<TypeAnnotation> = reference2TypeAnnotationList(httpStructures, 'nasl.http');
+  );
 
-export default new Namespace({
-    name: 'http',
-    structures: httpStructures,
-    logics: [],
-});
+  httpTypeList.push(
+    ...reference2TypeAnnotationList(httpStructures, 'nasl.http'),
+  );
+}

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

@@ -1,43 +1,54 @@
 import Namespace from '../../Namespace__';
-import Param from '../../Param__';
-import Return from '../../Return__';
-import Logic from '../../Logic__';
-import Module from '../../Module__';
-import Structure from '../../Structure__';
-import StructureProperty from '../../StructureProperty__';
-import TypeAnnotation from '../../TypeAnnotation__';
-import { primitiveTypeList } from '../types/coreTypeList';
+import type Structure from '../../Structure__';
+import type TypeAnnotation from '../../TypeAnnotation__';
 import { reference2TypeAnnotationList } from './reference2TypeAnnotationList';
-import TypeParam from '../../TypeParam__';
+import { getConceptConstructor } from '../../../decorators';
 
-export const interfaceStructures = [
+export const interfaceStructures: Structure[] = [];
+export const interfaceTypeList: Array<TypeAnnotation> = [];
+
+const interfaceNamespace = new Namespace({
+  name: 'interface',
+  structures: interfaceStructures,
+  logics: [],
+});
+
+export default interfaceNamespace;
+
+/** @internal */
+export function initialize() {
+  const Structure = getConceptConstructor('Structure');
+  const StructureProperty = getConceptConstructor('StructureProperty');
+  const TypeAnnotation = getConceptConstructor('TypeAnnotation');
+  const TypeParam = getConceptConstructor('TypeParam');
+
+  interfaceStructures.push(
     new Structure({
-        name: 'ApiReturnOf',
-        typeParams: [
-            new TypeParam({
-                name: 'T',
-            }),
-        ],
-        properties: [
-            new StructureProperty({
-                name: 'Data',
-                typeAnnotation: TypeAnnotation.createTypeParam('T'),
-            }),
-            new StructureProperty({
-                name: 'Code',
-                typeAnnotation: TypeAnnotation.createPrimitive('Long'),
-            }),
-            new StructureProperty({
-                name: 'Message',
-                typeAnnotation: TypeAnnotation.createPrimitive('String'),
-            }),
-        ],
+      name: 'ApiReturnOf',
+      typeParams: [
+        new TypeParam({
+          name: 'T',
+        }),
+      ],
+      properties: [
+        new StructureProperty({
+          name: 'Data',
+          typeAnnotation: TypeAnnotation.createTypeParam('T'),
+        }),
+        new StructureProperty({
+          name: 'Code',
+          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+        }),
+        new StructureProperty({
+          name: 'Message',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
     }),
-];
-export const interfaceTypeList: Array<TypeAnnotation> = reference2TypeAnnotationList(interfaceStructures, 'nasl.interface');
+  );
+
+  interfaceTypeList.push(
+    ...reference2TypeAnnotationList(interfaceStructures, 'nasl.interface'),
+  );
+}
 
-export default new Namespace({
-    name: 'interface',
-    structures: interfaceStructures,
-    logics: [],
-});

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

@@ -1,48 +1,58 @@
 import Namespace from '../../Namespace__';
-import Param from '../../Param__';
-import Return from '../../Return__';
-import Logic from '../../Logic__';
-import TypeAnnotation from '../../TypeAnnotation__';
-import StringLiteral from '../../StringLiteral__';
+import { getConceptConstructor } from '../../../decorators';
 
-export default new Namespace({
-    name: 'io',
-    logics: [
-        new Logic({
-            name: 'downloadFile',
-            params: [
-                new Param({
-                    name: 'url',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    required: true,
-                }),
-                new Param({
-                    name: 'fileName',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    defaultExpression: new StringLiteral({ value: '' }),
-                    required: false,
-                }),
-            ],
-            body: [],
+const ioNamespace = new Namespace({
+  name: 'io',
+  logics: [],
+});
+
+export default ioNamespace;
+
+/** @internal */
+export function initialize() {
+  const Param = getConceptConstructor('Param');
+  const StringLiteral = getConceptConstructor('StringLiteral');
+  const Logic = getConceptConstructor('Logic');
+  const TypeAnnotation = getConceptConstructor('TypeAnnotation');
+
+  const logics = [
+    new Logic({
+      name: 'downloadFile',
+      params: [
+        new Param({
+          name: 'url',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          required: true,
         }),
-        new Logic({
-            name: 'downloadFiles',
-            params: [
-                new Param({
-                    name: 'urlList',
-                    typeAnnotation: TypeAnnotation.createGeneric('List', {
-                        typeArguments: [TypeAnnotation.createTypeParam('T')],
-                    }),
-                    required: true,
-                }),
-                new Param({
-                    name: 'fileName',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    defaultExpression: new StringLiteral({ value: '' }),
-                    required: false,
-                }),
-            ],
-            body: [],
+        new Param({
+          name: 'fileName',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          defaultExpression: new StringLiteral({ value: '' }),
+          required: false,
         }),
-    ],
-});
+      ],
+      body: [],
+    }),
+    new Logic({
+      name: 'downloadFiles',
+      params: [
+        new Param({
+          name: 'urlList',
+          typeAnnotation: TypeAnnotation.createGeneric('List', {
+            typeArguments: [TypeAnnotation.createTypeParam('T')],
+          }),
+          required: true,
+        }),
+        new Param({
+          name: 'fileName',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          defaultExpression: new StringLiteral({ value: '' }),
+          required: false,
+        }),
+      ],
+      body: [],
+    }),
+  ];
+
+  logics.forEach((logic) => ioNamespace.addLogic(logic));
+}

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

@@ -1,61 +1,62 @@
 import Namespace from '../../Namespace__';
-import Param from '../../Param__';
-import Return from '../../Return__';
-import Logic from '../../Logic__';
-import Module from '../../Module__';
-import Structure from '../../Structure__';
-import Function from '../../Function__';
-import TypeAnnotation from '../../TypeAnnotation__';
-import { primitiveTypeList } from '../types/coreTypeList';
-import TypeParam from '../../TypeParam__';
-import NumericLiteral from '../../NumericLiteral__';
-import Identifier from '../../Identifier__';
-import BooleanLiteral from '../../BooleanLiteral__';
-import StringLiteral from '../../StringLiteral__';
-import StringInterpolation from '../../StringInterpolation__';
+import { getConceptConstructor } from '../../../decorators';
 
-export default new Namespace({
-    name: 'logging',
-    logics: [
-        new Logic({
-            name: 'INFO',
-            params: [
-                new Param({
-                    name: '模板',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    defaultExpression: new StringInterpolation(),
-                }),
-            ],
+const loggingNamespace = new Namespace({
+  name: 'logging',
+  logics: [],
+});
+
+export default loggingNamespace;
+
+/** @internal */
+export function initialize() {
+  const Param = getConceptConstructor('Param');
+  const StringInterpolation = getConceptConstructor('StringInterpolation');
+  const Logic = getConceptConstructor('Logic');
+  const TypeAnnotation = getConceptConstructor('TypeAnnotation');
+
+  const logics = [
+    new Logic({
+      name: 'INFO',
+      params: [
+        new Param({
+          name: '模板',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          defaultExpression: new StringInterpolation(),
         }),
-        new Logic({
-            name: 'DEBUG',
-            params: [
-                new Param({
-                    name: '模板',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    defaultExpression: new StringInterpolation(),
-                }),
-            ],
+      ],
+    }),
+    new Logic({
+      name: 'DEBUG',
+      params: [
+        new Param({
+          name: '模板',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          defaultExpression: new StringInterpolation(),
         }),
-        new Logic({
-            name: 'WARN',
-            params: [
-                new Param({
-                    name: '模板',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    defaultExpression: new StringInterpolation(),
-                }),
-            ],
+      ],
+    }),
+    new Logic({
+      name: 'WARN',
+      params: [
+        new Param({
+          name: '模板',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          defaultExpression: new StringInterpolation(),
         }),
-        new Logic({
-            name: 'ERROR',
-            params: [
-                new Param({
-                    name: '模板',
-                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    defaultExpression: new StringInterpolation(),
-                }),
-            ],
+      ],
+    }),
+    new Logic({
+      name: 'ERROR',
+      params: [
+        new Param({
+          name: '模板',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          defaultExpression: new StringInterpolation(),
         }),
-    ],
-});
+      ],
+    }),
+  ];
+
+  logics.forEach((logic) => loggingNamespace.addLogic(logic));
+}