@lcap/nasl 3.8.0-beta.8 → 3.8.2-alpha.1

package/src/concepts/NewComposite__.ts

@@ -993,6 +993,30 @@ export class NewComposite extends LogicItem {
     return this.rights[firstIndex].members[secondIndex];
   }
 
+  toBrief(): string {
+    let code = '新建：{ ';
+    if (this.typeAnnotation) {
+      const leftAssignmentMap = new Map();
+      this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+        const rightItem = this.findMember(rightIndex);
+        const leftItem = this.findMember(leftIndex, 'left');
+        if (!leftAssignmentMap.has(leftItem)) {
+          leftAssignmentMap.set(leftItem, rightItem);
+        }
+      });
+      this.properties.forEach((leftItem, index) => {
+        if (index) {
+          code += ', ';
+        }
+        const rightItem = leftAssignmentMap.get(leftItem);
+        const value = rightItem ? rightItem.toBrief() : 'null';
+        code += `${leftItem.name}: ${value}`;
+      });
+    }
+    code += ` }`;
+    return code;
+  }
+
   toUI(state?: TranslatorState, hideDetails?: boolean): string {
     let code = '新建：{ ';
     if (this.typeAnnotation) {

package/src/concepts/OverriddenLogic__.ts

@@ -1770,8 +1770,20 @@ export class OverriddenLogic extends BaseNode {
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
             code += `const __${key}_${node?.name} = `;
-            const itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+            let itemCode = '';
+            if (
+              asserts.isNewComposite(itemNode)
+              || asserts.isNewList(itemNode)
+              || asserts.isNewMap(itemNode)
+            ) {
+              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+                inline: true
+              })) ??
               returnOrigin('');
+            } else {
+              itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('');
+            }
             code += yield* self.getRightCode(itemCode, assignment, itemNode);
             code += ';\n';
           }

package/src/concepts/Param__.ts

@@ -429,7 +429,7 @@ export class Param extends BaseNode {
 
   public static getDefaultOptions(): any {
     return {
-      required: true,
+      // required: true,
       typeAnnotation: {
         concept: 'TypeAnnotation',
         typeKind: 'primitive',

package/src/concepts/Structure__.ts

@@ -580,9 +580,7 @@ export class Structure extends BaseNode {
 
     // code += `${indent(state.tabSize + 1)}__name: '${this.getNamespace()}.${this.name}';\n`;
     this.properties.forEach((property) => {
-      code += indent(state.tabSize + 1);
-      code += property.toNaturalTS(shiftState(state, code, { tabSize: 0 }));
-      code += ';\n';
+      code += `${property.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }))};\n`;
     });
     code += `${indent(state.tabSize)}}\n`;
     return code;

package/src/concepts/SubLogic__.ts

@@ -1391,8 +1391,20 @@ export class SubLogic extends LogicItem {
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
             code += `const __${key}_${node?.name} = `;
-            const itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+            let itemCode = '';
+            if (
+              asserts.isNewComposite(itemNode)
+              || asserts.isNewList(itemNode)
+              || asserts.isNewMap(itemNode)
+            ) {
+              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+                inline: true
+              })) ??
               returnOrigin('');
+            } else {
+              itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('');
+            }
             code += yield* self.getRightCode(itemCode, assignment, itemNode);
             code += ';\n';
           }

package/src/concepts/TypeAnnotation__.ts

@@ -978,9 +978,11 @@ export class TypeAnnotation extends BaseNode {
       code += ')';
       code += '=>';
       const returnTypes = self?.returnType || [];
-      yield* wrapForEach(returnTypes, function* warpForEachGenerator(type) {
-        code += yield* type.toEmbeddedTS(shiftState(state, code));
-      });
+      if (returnTypes.length) {
+        code += yield* returnTypes[0].toEmbeddedTS(shiftState(state, code));
+      } else {
+        code += 'void';
+      }
       return code;
     } else {
       if (self.tsCalleeNamespace && self.typeName) {

package/src/concepts/ViewComponentDeclaration__.ts

@@ -1667,19 +1667,19 @@ export class ViewComponentDeclaration extends BaseNode {
     code += `${indent(state.tabSize + 1)}}\n`;
     code += `${indent(state.tabSize + 1)}class ${componentName}Options extends ViewComponentOptions {\n`;
     // props
-    this.props?.forEach((prop: PropDeclaration) => {
+    (this.props || [])?.forEach((prop: PropDeclaration) => {
       const desc = utils.getDescription(prop.title, prop.description);
       code += desc ? `${indent(state.tabSize + 2)}${desc}\n` : '';
       code += `${indent(state.tabSize + 2)}${prop.toNaturalTS(state)}`;
     });
     // events
-    this.events?.forEach((event: EventDeclaration) => {
+    (this.events || [])?.forEach((event: EventDeclaration) => {
       const desc = utils.getDescription(event.title, event.description);
       code += desc ? `${indent(state.tabSize + 2)}${desc}\n` : '';
       code += `${indent(state.tabSize + 2)}${event.toNaturalTS()}`;
     });
     // slots
-    this.slots?.forEach((slot: SlotDeclaration) => {
+    (this.slots || [])?.forEach((slot: SlotDeclaration) => {
       const desc = utils.getDescription(slot.title, slot.description);
       code += desc ? `${indent(state.tabSize + 2)}${desc}\n` : '';
       code += `${indent(state.tabSize + 2)}${slot.toNaturalTS()}`;

package/src/concepts/ViewElement__.ts

@@ -1493,6 +1493,10 @@ export class ViewElement extends Annotatable {
     return this.bindStyles.find((bindStyle) => bindStyle.name === name);
   }
 
+  getBindEvent(name: string) {
+    return this.bindEvents.find((bindEvent) => bindEvent.name === name);
+  }
+
   toHump(name: string): string {
     return name.replace(/-(\w)/g, (all, letter) => letter.toUpperCase());
   }
@@ -1915,7 +1919,6 @@ export class ViewElement extends Annotatable {
               noNeedParams: true,
               callLogicNoIife: true,
             };
-            debugger;
             const value = yield* attr.expression.toEmbeddedTS(
               shiftState(state, code, attr.expression.concept === 'CallLogic' ? extraParams : {}),
             );
@@ -2263,6 +2266,15 @@ export class ViewElement extends Annotatable {
 
     code += `$refs.${this.name} = new ${kebab2Camel(this.tag)}({\n`;
 
+    this?.bindDirectives?.forEach((directive) => {
+      code += directive.toNaturalTS(
+        shiftState(state, code, {
+          tabSize: state.tabSize + 1,
+        }),
+      );
+      code += ',\n';
+    });
+
     this.bindAttrs.forEach((attr) => {
       code += attr.toNaturalTS(
         shiftState(state, code, {
@@ -2272,6 +2284,15 @@ export class ViewElement extends Annotatable {
       code += ',\n';
     });
 
+    this.bindStyles.forEach((style) => {
+      code += style.toNaturalTS(
+        shiftState(state, code, {
+          tabSize: state.tabSize + 1,
+        }),
+      );
+      code += ',\n';
+    });
+
     this.bindEvents.forEach((event) => {
       code += event.toNaturalTS(
         shiftState(state, code, {
@@ -3186,6 +3207,7 @@ export class ViewElement extends Annotatable {
 
         result && parts.push(result);
       });
+    let preAnnoParts:any = []
     const genDirectiveByAnno = (viewElement: ViewElement) => {
       if (viewElement?.applyAnnotations?.length > 0) {
         // todo: 根据注解生成自定义指令 v-annoName="context"
@@ -3203,22 +3225,12 @@ export class ViewElement extends Annotatable {
           };
           let argsList = aa.arguments.map((arg: any) => getExpressionValue(arg.expression));
           let annoArgs = {
+            annotationName:aa.annotationName,
             argsList,
             dataRefList,
           };
-          // 所有参数序列化之后当字符串传进指令参数 （目前不支持<div v-demo="{ color: 'white', text: 'hello!' }"></div>
-          let expression = StringLiteral.from({
-            concept: 'StringLiteral',
-            kind: 'Expression',
-            name: '',
-            value: JSON.stringify(annoArgs),
-          });
-          let annoDirective = BindDirective.from({
-            name: aa.annotationName,
-            // arg:'arg',
-            expression,
-          });
-          return annoDirective;
+          return annoArgs
+
         });
       }
     };
@@ -3258,9 +3270,8 @@ export class ViewElement extends Annotatable {
                       propName: attr?.expression.toUI()?.replace('current.item.', ''),
                     };
                     dataRefList.push(ref);
-                    // 要考虑 多个元素 每个元素有多个注解的情况
-                    let result = (genDirectiveByAnno(viewElement) as any)?.map((d: any) => d?.toVue());
-                    result && result?.length > 0 && parts.push(...result);
+                    let result = (genDirectiveByAnno(viewElement) as any)
+                    result && result?.length > 0 && preAnnoParts.push(...result);
                   }
                 }
               }
@@ -3309,8 +3320,9 @@ export class ViewElement extends Annotatable {
                 propName: entityPropName,
               };
               dataRefList.push(ref);
-              let result = (genDirectiveByAnno(viewElement) as any)?.map((d: any) => d?.toVue());
-              result && result?.length > 0 && parts.push(...result);
+
+              let result = (genDirectiveByAnno(viewElement) as any)
+              result && result?.length > 0 && preAnnoParts.push(...result);
             }
             // typeName "Entity1"
             // typeNamespace "app.dataSources.defaultDS.entities"
@@ -3337,7 +3349,38 @@ export class ViewElement extends Annotatable {
       // 2 向上是线性布局 卡片 template gridView
     };
     getEntityDataRef(this);
+    let annoMap:any = {}
 
+    preAnnoParts?.map((annoArgs:any)=>{
+      let annotationName =annoArgs.annotationName
+      if(!annoMap[annotationName] ){
+        annoMap[annotationName]  =[]
+      }
+      annoMap[annotationName] = annoArgs
+    })
+    Object.keys(annoMap)?.map(key=>{
+    let annoArgs =annoMap[key]
+      let {
+        annotationName,
+        argsList,
+        dataRefList,
+      }= annoArgs;
+      // 一个元素可以有多个指令； 其中一个指令可以从多处获取参数 这里就不能直接生成指令了 不然多个参数就变成了多个指令 实现同一个指令多个参数
+          // 所有参数序列化之后当字符串传进指令参数 （目前不支持<div v-demo="{ color: 'white', text: 'hello!' }"></div>
+          let expression = StringLiteral.from({
+            concept: 'StringLiteral',
+            kind: 'Expression',
+            name: '',
+            value: JSON.stringify(annoArgs),
+          });
+          let annoDirective = BindDirective.from({
+            name: annotationName,
+            // arg:'arg',
+            expression,
+          });
+      let directString = annoDirective?.toVue()
+      directString && parts.push(directString)
+    })
     if (vIfs.length === 2) parts.push(`v-if="(${vIfs[0]}) && (${vIfs[1]})"`);
     else if (vIfs.length === 1) parts.push(`v-if="${vIfs[0]}"`);
 
@@ -3705,6 +3748,22 @@ export class ViewElement extends Annotatable {
       this.getBindAttribute('processPrefix')
     );
   }
+
+  getBindViewDestination() {
+    let bindView
+    utils.traverse(
+      ({ node }) => {
+        if (this.composedBy?.[0] === (node as any).composedBy?.[0]) {
+          bindView = node
+        }
+      },
+      {
+        node: { children: this.frontend?.views },
+      }
+    );
+    return bindView;
+  }
+
   getAncestorByTag<Node extends types.SyntaxNode = types.SyntaxNode>(
     concept: types.SyntaxNode['concept'],
     tag: string,

package/src/concepts/View__.ts

@@ -1583,8 +1583,8 @@ export class View extends Annotatable {
     const BindEvent = getConceptConstructor('BindEvent');
     const definitionStr = utils.sliceTagContent(code, 'definition') || '{}';
     const definition: any = JSON.parse(definitionStr);
-     // 服务端逻辑
-     if (Array.isArray(definition.logics)) {
+    // 服务端逻辑
+    if (Array.isArray(definition.logics)) {
       definition.logics.forEach((logicOption: any) => {
         const logic = Logic.from(
           {
@@ -1671,8 +1671,8 @@ export class View extends Annotatable {
     const BindEvent = getConceptConstructor('BindEvent');
     const definitionStr = utils.sliceTagContent(code, 'definition') || '{}';
     const definition: any = JSON.parse(definitionStr);
-     // 服务端逻辑
-     if (Array.isArray(definition.logics)) {
+    // 服务端逻辑
+    if (Array.isArray(definition.logics)) {
       definition.logics.forEach((logicOption: any) => {
         const logic = Logic.from(
           {
@@ -1834,7 +1834,7 @@ export class View extends Annotatable {
    */
   genScript() {
     const componentList: Array<ViewElement> = [];
-    const allComponentList: Array<ViewElement & { currentIndex: number }> = [];
+    const allComponentList: Array<ViewElement & { currentIndex: number; }> = [];
     this.elementsAttrs(this.elements, componentList, allComponentList, -1);
 
     const routeMeta = this.getRouteMeta();
@@ -1864,15 +1864,15 @@ export class View extends Annotatable {
             methods: {
                 async onKeyDown(e) {
                     ${this.bindEvents
-                      .filter((event) => ['keydown'].includes(event.name))
-                      .map((event) => `await this.${event.view.name}_${event.name}(e);`)
-                      .join('\n')}
+        .filter((event) => ['keydown'].includes(event.name))
+        .map((event) => `await this.${event.view.name}_${event.name}(e);`)
+        .join('\n')}
                 },
                 async onKeyUp(e) {
                     ${this.bindEvents
-                      .filter((event) => ['keyup'].includes(event.name))
-                      .map((event) => `await this.${event.view.name}_${event.name}(e);`)
-                      .join('\n')}
+        .filter((event) => ['keyup'].includes(event.name))
+        .map((event) => `await this.${event.view.name}_${event.name}(e);`)
+        .join('\n')}
                 }
             }
         };\n`;
@@ -2066,9 +2066,8 @@ export class View extends Annotatable {
         parent = parent.parentNode;
       }
     }
-    return `/embedded/${this.getAncestor('App')?.name}/frontendTypes/${
-      this.getAncestor('FrontendType')?.name
-    }/frontends/${this.getAncestor('Frontend')?.name}/views/${pathName}.ts`;
+    return `/embedded/${this.getAncestor('App')?.name}/frontendTypes/${this.getAncestor('FrontendType')?.name
+      }/frontends/${this.getAncestor('Frontend')?.name}/views/${pathName}.ts`;
   }
 
   getNamespace(): string {
@@ -2117,11 +2116,11 @@ export class View extends Annotatable {
   elementsAttrs(
     elements: Array<ViewElement>,
     componentList: Array<ViewElement>,
-    allComponentList: Array<ViewElement & { currentIndex: number }>,
+    allComponentList: Array<ViewElement & { currentIndex: number; }>,
     currentIndex: number,
   ) {
     if (elements) {
-      elements.forEach((item: ViewElement & { currentIndex: number }) => {
+      elements.forEach((item: ViewElement & { currentIndex: number; }) => {
         let index = currentIndex ?? -1;
         if (item.tag === 'template' && item.haveScope()) {
           index += 1;
@@ -2246,9 +2245,9 @@ export class View extends Annotatable {
             const leftCode =
               leftIndex.length === 1
                 ? yield* el.left?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('')
+                returnOrigin('')
                 : yield* el.left?.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
+                returnOrigin('');
             const advanceVar = self.variables?.find(
               (variable) => !variable.typeAnnotation && leftCode === variable.name,
             );
@@ -2303,7 +2302,7 @@ export class View extends Annotatable {
             leftIndex.length === 1
               ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
               : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                  returnOrigin('');
+              returnOrigin('');
           if (leftCode === variable.name) {
             const rightNode =
               rightIndex.length === 1
@@ -2361,8 +2360,20 @@ export class View extends Annotatable {
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
             code += `const __${key}_${node?.name} = `;
-            const itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-              returnOrigin('');
+            let itemCode = '';
+            if (
+              asserts.isNewComposite(itemNode)
+              || asserts.isNewList(itemNode)
+              || asserts.isNewMap(itemNode)
+            ) {
+              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+                inline: true
+              })) ??
+                returnOrigin('');
+            } else {
+              itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('');
+            }
             code += yield* self.getRightCode(itemCode, assignment, itemNode);
             code += ';\n';
           }
@@ -2562,6 +2573,19 @@ export class View extends Annotatable {
       });
       if (this.variables.length) code += '\n';
 
+      this.logics.forEach((logic) => {
+        const logicCode = logic.toNaturalTS(
+          shiftState(state, code, {
+            tabSize: state.tabSize + 1,
+            declaration: true,
+            autoPrefixName: true,
+          })
+        );
+        code += logicCode.replace('declare function', 'function');
+        code += '\n';
+      });
+      if (this.logics.length) code += '\n';
+
       if (callback) {
         code += callback.call(this, state);
       } else {
@@ -3685,9 +3709,9 @@ export const ComponentCompletionPropertyMap: Record<string, any> = {
       prop: 'sorting',
       label: '排序方式',
     },
-    filter:{
-      prop:'filter',
-      label:'筛选条件'
+    filter: {
+      prop: 'filter',
+      label: '筛选条件'
     },
   },
   List: {

package/src/generator/genBundleFiles.ts

@@ -271,7 +271,7 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
       return 'bundle';
     }
   };
-  let baseUrl = `${config.STATIC_URL}/${config.tenant}/${app.id}/${config.env}`;
+  let baseUrl = `${config.USER_STATIC_URL}/${config.tenant}/${app.id}/${config.env}`;
   let { basePath } = frontend;
 
   if (config.isExport as any) {