@lcap/nasl 3.2.0-beta.3 → 3.3.0-alpha

package/src/server/createUiTs.ts

@@ -1,95 +1,89 @@
 import { Logic, TypeAnnotation, Param, LogicItem, NumericLiteral, BooleanLiteral, StringLiteral, Identifier, MemberExpression } from '..';
 import { trigger } from './event';
 
-export let elementsEventsMap: { [componentTagEventName: string]: any} = {};
+export let elementsEventsMap: { [componentTagEventName: string]: any } = {};
 
 export function getAllComponentEventMap(allComponent: any) {
-    const eventsMap: { [componentTagEventName: string]: any} = {};
-    for (const i in allComponent) {
-        const item = allComponent[i];
-        if (item.events && Array.isArray(item.events)) {
-            item.events.forEach((eventItem: any) => {
-                const name = `${item.name}-${eventItem.name}`;
-                eventsMap[name] = eventItem;
-            });
-        }
+  const eventsMap: { [componentTagEventName: string]: any } = {};
+  for (const i in allComponent) {
+    const item = allComponent[i];
+    if (item.events && Array.isArray(item.events)) {
+      item.events.forEach((eventItem: any) => {
+        const name = `${item.name}-${eventItem.name}`;
+        eventsMap[name] = eventItem;
+      });
     }
-    trigger.forEach((item: any) => {
-        eventsMap[item.name] = item;
-    });
+  }
+  trigger.forEach((item: any) => {
+    eventsMap[item.name] = item;
+  });
 
-    elementsEventsMap = eventsMap;
-    return eventsMap;
+  elementsEventsMap = eventsMap;
+  return eventsMap;
 }
 
 export default function formatUiTs(allComponent: any) {
-    const indent = (tabSize: number) => ' '.repeat(tabSize * 2);
+  const indent = (tabSize: number) => ' '.repeat(tabSize * 2);
 
-    const toHump = (name: string) => (name ? name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase()) : '');
+  const toHump = (name: string) => (name ? name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase()) : '');
 
-    const toNaslType = (type: string) => {
-        if (type === 'number')
-            return 'nasl.core.Long';
-        if (type === 'string')
-            return 'nasl.core.String';
-        if (type === 'boolean')
-            return 'nasl.core.Boolean';
-        if (type === 'Array<string>')
-            return 'nasl.collection.List<nasl.core.String>';
-        else
-            return type;
-    };
-    const createDefault = (param: any): LogicItem => {
-        const defaultValue = param.default;
-        if (defaultValue) {
-            if (typeof defaultValue === 'number') {
-                return new NumericLiteral({ value: `${defaultValue}` });
-            } else if (typeof defaultValue === 'boolean') {
-                return new BooleanLiteral({ value: `${defaultValue}` });
-            } else if (typeof defaultValue === 'string' && !defaultValue.includes('.')) {
-                return new StringLiteral({ value: defaultValue });
-            }
-            return null;
+  const toNaslType = (type: string) => {
+    if (type === 'number') return 'nasl.core.Long';
+    if (type === 'string') return 'nasl.core.String';
+    if (type === 'boolean') return 'nasl.core.Boolean';
+    if (type === 'Array<string>') return 'nasl.collection.List<nasl.core.String>';
+    return type;
+  };
+  const createDefault = (param: any): LogicItem => {
+    const defaultValue = param.default;
+    if (defaultValue) {
+      if (typeof defaultValue === 'number') {
+        return new NumericLiteral({ value: `${defaultValue}` });
+      }
+      if (typeof defaultValue === 'boolean') {
+        return new BooleanLiteral({ value: `${defaultValue}` });
+      }
+      if (typeof defaultValue === 'string' && !defaultValue.includes('.')) {
+        return new StringLiteral({ value: defaultValue });
+      }
+      return null;
+    }
+    return null;
+  };
+  const creatMethodLogic = (method: { name: string; params: any[] }) => {
+    const { name, params } = method;
+    const logic = new Logic({
+      name,
+      params: params.map((param) => {
+        let required = true;
+        if (param.required === false) {
+          required = false;
+        }
+        let typeAnnotation = null;
+        const { name, type } = param;
+        if (type === 'number') typeAnnotation = TypeAnnotation.createPrimitive('Long');
+        else if (type === 'string') typeAnnotation = TypeAnnotation.createPrimitive('String');
+        else if (type === 'boolean') typeAnnotation = TypeAnnotation.createPrimitive('Boolean');
+        else if (type === 'Array<string>')
+          typeAnnotation = TypeAnnotation.createGeneric('List', {
+            typeArguments: [TypeAnnotation.createPrimitive('String')],
+          });
+        else {
+          typeAnnotation = TypeAnnotation.createPrimitive('any');
         }
-        return null;
-    };
-    const creatMethodLogic = (method: { name: string; params: any[] }) => {
-        const { name, params } = method;
-        const logic = new Logic({
-            name,
-            params: params.map((param) => {
-                let required = true;
-                if (param.required === false) {
-                    required = false;
-                }
-                let typeAnnotation = null;
-                const { name, type } = param;
-                if (type === 'number')
-                    typeAnnotation = TypeAnnotation.createPrimitive('Long');
-                else if (type === 'string')
-                    typeAnnotation = TypeAnnotation.createPrimitive('String');
-                else if (type === 'boolean')
-                    typeAnnotation = TypeAnnotation.createPrimitive('Boolean');
-                else if (type === 'Array<string>')
-                    typeAnnotation = TypeAnnotation.createGeneric('List', {
-                        typeArguments: [TypeAnnotation.createPrimitive('String')],
-                    });
-                else {
-                    typeAnnotation = TypeAnnotation.createPrimitive('any');
-                }
-                return new Param({
-                    name,
-                    typeAnnotation,
-                    defaultExpression: createDefault(param),
-                    required,
-                });
-            }),
+        return new Param({
+          name,
+          typeAnnotation,
+          defaultExpression: createDefault(param),
+          required,
         });
-        return logic;
-    };
-    const elementsLogic: { [componentName: string]: Array<Logic> } = {};
+      }),
+    });
+    return logic;
+  };
+  const elementsLogic: { [componentName: string]: Array<Logic> } = {};
 
-    let value = `namespace nasl.ui {
+  let value = `namespace nasl.ui {
     export class VueComponent {
     }
     export class lRoot<T> extends VueComponent{
@@ -100,15 +94,28 @@ export default function formatUiTs(allComponent: any) {
               slotDefault?: ()=> Array<any>,
         }){super()}
     }
-    export class div<T> extends VueComponent {
+
+    class BaseDomEl<T> extends VueComponent {
         constructor(
-            options?: {
-              [propname: string]: any,
-              bindAttr?: () => Array<any>,
-              slotDefault?: ()=> Array<any>,
-              click?: (event: any) => Array<any>,
-        }){super()}
+        options?: {
+            [propname: string]: any,
+            bindAttr?: () => Array<any>,
+            slotDefault?: () => Array<any>,
+            click?: (event: any) => Array<any>,
+        }) { super() }
     }
+
+    export class div<T> extends BaseDomEl<T> {}
+    export class span<T> extends BaseDomEl<T> {}
+    export class h1<T> extends BaseDomEl<T> {}
+    export class h2<T> extends BaseDomEl<T> {}
+    export class h3<T> extends BaseDomEl<T> {}
+    export class h4<T> extends BaseDomEl<T> {}
+    export class h5<T> extends BaseDomEl<T> {}
+    export class img<T> extends BaseDomEl<T> {}
+    export class br<T> extends BaseDomEl<T> {}
+    export class a<T> extends BaseDomEl<T> {}
+
     export class template<T> extends VueComponent {
         constructor(
             options?: {
@@ -119,122 +126,121 @@ export default function formatUiTs(allComponent: any) {
     }
     export type GetItemTypeFromDataSource<T> = T extends { list: nasl.collection.List<infer U> } | nasl.collection.List<infer U> | ((...args: any) => { list: nasl.collection.List<infer U> } | nasl.collection.List<infer U>) ? U : never;
     \n`;
-    for (const i in allComponent) {
-        const item = allComponent[i];
-        const componentName = toHump(item.name);
-        if (!componentName)
-            continue;
-        // console.log(item);
-        if (componentName === 'uTableViewColumnDynamic') {
-            value += `export class ${componentName}<T, T1> extends VueComponent{\n
+  for (const i in allComponent) {
+    const item = allComponent[i];
+    const componentName = toHump(item.name);
+    if (!componentName) continue;
+    // console.log(item);
+    if (componentName === 'uTableViewColumnDynamic') {
+      value += `export class ${componentName}<T, T1> extends VueComponent{\n
                 constructor(\n
                 options?: {\n
                 [propname: string]: any,
                 bindAttr?: () => Array<any>,\n`;
-        } else {
-            value += `export class ${componentName}<T> extends VueComponent{\n
+    } else {
+      value += `export class ${componentName}<T> extends VueComponent{\n
                 constructor(\n
                 options?: {\n
                 [propname: string]: any,
                 bindAttr?: () => Array<any>,\n`;
-        }
+    }
 
-        // 生成slot
-        // tableview先写死其余slot没有声明类型的 都先放默认的
-        if (Object.prototype.toString.call(item.slots) === '[object Array]') {
-            item.slots.forEach((slot: any) => {
-                const slotName = toHump('slot-' + slot.name);
-                // 如果已经有带参数的slotDefault
-                if (slotName === 'slotDefault') {
-                    if (slot.supportGenericComponents && slot.supportGenericComponents.length) {
-                        let str = '';
-                        slot.supportGenericComponents.forEach((componentName: any) => {
-                            const name = toHump(componentName);
-                            str += `Array<${name}<T>> | `;
-                        });
-                        // 没有插槽的
-                        value += `slotDefault?: () => ${str} Array<any>,\n`;
-                    } else if (slot.slotProps) {
-                        const typeAnnotation = new TypeAnnotation(slot.slotProps.typeAnnotation);
-                        value += `slotDefault?: (current: ${typeAnnotation.typeKey}) => Array<any>,\n`;
-                    } else if (item.attrs && item.attrs.find((item: any) => item.name === 'data-source')) {
-                        // 没有插槽的
-                        value += `slotDefault?: (current: nasl.ui.Current<T>)=> Array<any>,\n`;
-                    } else {
-                        // 没有插槽的
-                        value += `slotDefault?: ()=> Array<any>,\n`;
-                    }
-                } else if (!slot.advanced) {
-                    if (slot.slotProps) {
-                        if (item.name === 'u-table-view-column-dynamic' && slotName === 'slotTitle') {
-                            value += `${slotName}?: (current: {columnIndex: number, columnItem: T1}) => Array<any>,\n`;
-                        } else {
-                            const typeAnnotation = new TypeAnnotation(slot.slotProps.typeAnnotation);
-                            value += `${slotName}?: (current: ${typeAnnotation.typeKey}) => Array<any>,\n`;
-                        }
-                    } else {
-                        value += `${slotName}?: ()=> Array<any>,\n`;
-                    }
-                    // if (Array.isArray(slot.props) && slot.props.length === 5) {
-                    //     value += indent(3);
-                    //     value += slotName + `?: (current: nasl.ui.Current<T>) => Array<any>,\n`;
-                    // } else if (Array.isArray(slot.props)) {
-                    //     value += indent(3);
-                    //     value += slotName + `?: (current: {`;
-                    //     slot.props.forEach((prop: any) => {
-                    //         const type = prop.type || '';
-                    //         value += `${prop.name}: ${type}, `;
-                    //     });
-                    //     value += `}) => Array<any>,\n`;
-                    // } else {
-                    //     value += indent(3);
-                    //     // 这里应该是有类型区分的，但是目前 current 只有一个 类型就先都是这个
-                    //     value += slotName + `?: (current: nasl.ui.Current<T>) => Array<any>,\n`;
-                    // }
-                }
+    // 生成slot
+    // tableview先写死其余slot没有声明类型的 都先放默认的
+    if (Object.prototype.toString.call(item.slots) === '[object Array]') {
+      item.slots.forEach((slot: any) => {
+        const slotName = toHump(`slot-${slot.name}`);
+        // 如果已经有带参数的slotDefault
+        if (slotName === 'slotDefault') {
+          if (slot.supportGenericComponents && slot.supportGenericComponents.length) {
+            let str = '';
+            slot.supportGenericComponents.forEach((componentName: any) => {
+              const name = toHump(componentName);
+              str += `Array<${name}<T>> | `;
             });
-        } else {
+            // 没有插槽的
+            value += `slotDefault?: () => ${str} Array<any>,\n`;
+          } else if (slot.slotProps) {
+            const typeAnnotation = new TypeAnnotation(slot.slotProps.typeAnnotation);
+            value += `slotDefault?: (current: ${typeAnnotation.typeKey}) => Array<any>,\n`;
+          } else if (item.attrs && item.attrs.find((item: any) => item.name === 'data-source')) {
+            // 没有插槽的
+            value += `slotDefault?: (current: nasl.ui.Current<T>)=> Array<any>,\n`;
+          } else {
             // 没有插槽的
             value += `slotDefault?: ()=> Array<any>,\n`;
+          }
+        } else if (!slot.advanced) {
+          if (slot.slotProps) {
+            if (item.name === 'u-table-view-column-dynamic' && slotName === 'slotTitle') {
+              value += `${slotName}?: (current: {columnIndex: number, columnItem: T1}) => Array<any>,\n`;
+            } else {
+              const typeAnnotation = new TypeAnnotation(slot.slotProps.typeAnnotation);
+              value += `${slotName}?: (current: ${typeAnnotation.typeKey}) => Array<any>,\n`;
+            }
+          } else {
+            value += `${slotName}?: ()=> Array<any>,\n`;
+          }
+          // if (Array.isArray(slot.props) && slot.props.length === 5) {
+          //     value += indent(3);
+          //     value += slotName + `?: (current: nasl.ui.Current<T>) => Array<any>,\n`;
+          // } else if (Array.isArray(slot.props)) {
+          //     value += indent(3);
+          //     value += slotName + `?: (current: {`;
+          //     slot.props.forEach((prop: any) => {
+          //         const type = prop.type || '';
+          //         value += `${prop.name}: ${type}, `;
+          //     });
+          //     value += `}) => Array<any>,\n`;
+          // } else {
+          //     value += indent(3);
+          //     // 这里应该是有类型区分的，但是目前 current 只有一个 类型就先都是这个
+          //     value += slotName + `?: (current: nasl.ui.Current<T>) => Array<any>,\n`;
+          // }
         }
+      });
+    } else {
+      // 没有插槽的
+      value += `slotDefault?: ()=> Array<any>,\n`;
+    }
 
-        value += indent(1) + '\n}){super()}\n';
-        // 生成methods
-        if (Object.prototype.toString.call(item.methods) === '[object Array]') {
-            //   beforeNavigate?:($event: {to: string | Location, replace: boolean, append: boolean, preventDefault: Function}) => void
-            const logics: Array<Logic> = [];
-            item.methods.forEach((method: any) => {
-                if (!method.advanced) {
-                    const methodName = toHump(method.name);
-                    if (Array.isArray(method.params) && method.params.length) {
-                        let methodParamStr = '';
-                        method.params.forEach((param: any) => {
-                            methodParamStr += param.name.includes('?') ? param.name + ': ' : param.name + '?: ';
-                            const type = toNaslType(param.type);
-                            methodParamStr += type;
-                            methodParamStr += ',';
-                        });
-                        value += indent(1);
-                        value += methodName + `: (${methodParamStr}) => any;\n`;
-                        logics.push(creatMethodLogic(method));
-                    } else {
-                        value += indent(1);
-                        value += methodName + `: () => any;\n`;
-                        logics.push(creatMethodLogic({ name: methodName, params: [] }));
-                    }
-                }
+    value += `${indent(1)}\n}){super()}\n`;
+    // 生成methods
+    if (Object.prototype.toString.call(item.methods) === '[object Array]') {
+      //   beforeNavigate?:($event: {to: string | Location, replace: boolean, append: boolean, preventDefault: Function}) => void
+      const logics: Array<Logic> = [];
+      item.methods.forEach((method: any) => {
+        if (!method.advanced) {
+          const methodName = toHump(method.name);
+          if (Array.isArray(method.params) && method.params.length) {
+            let methodParamStr = '';
+            method.params.forEach((param: any) => {
+              methodParamStr += param.name.includes('?') ? `${param.name}: ` : `${param.name}?: `;
+              const type = toNaslType(param.type);
+              methodParamStr += type;
+              methodParamStr += ',';
             });
-            elementsLogic[componentName] = logics;
+            value += indent(1);
+            value += `${methodName}: (${methodParamStr}) => any;\n`;
+            logics.push(creatMethodLogic(method));
+          } else {
+            value += indent(1);
+            value += `${methodName}: () => any;\n`;
+            logics.push(creatMethodLogic({ name: methodName, params: [] }));
+          }
         }
-        value += '}\n';
+      });
+      elementsLogic[componentName] = logics;
     }
     value += '}\n';
-    // console.log(value);
-    // console.log(elementsLogic);
-    // const elementsEventsMap = getAllComponentEventMap(allComponent);
-    return {
-        code: value,
-        elementsLogic,
-        elementsEventsMap,
-    };
+  }
+  value += '}\n';
+  // console.log(value);
+  // console.log(elementsLogic);
+  // const elementsEventsMap = getAllComponentEventMap(allComponent);
+  return {
+    code: value,
+    elementsLogic,
+    elementsEventsMap,
+  };
 }