@lcap/nasl 1.0.0-alpha.2 → 1.0.0-alpha.5

package/src/server/createUiTs.ts

@@ -0,0 +1,153 @@
+import { Logic, TypeAnnotation, Param } from '..';
+
+export default function formatUiTs(allComponent: any) {
+    const indent = (tabSize: number) => ' '.repeat(tabSize * 2);
+
+    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 creatMethodLogic = (method: {name: string, params: any[]}) => {
+        const { name, params } = method;
+        const logic = new Logic({
+            name,
+            params: params.map((param) => {
+                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,
+                });
+            }),
+        });
+        return logic;
+    };
+    const elementsLogic: { [componentName: string]: Array<Logic> } = {};
+    let value = `namespace nasl.ui {
+    export class VueComponent {
+    }
+    export class lRoot<T> extends VueComponent{
+        constructor(
+            options?: {
+              slotDefault?: ()=> Array<any>,
+        }){super()}
+    }
+    export class div<T> extends VueComponent {
+        constructor(
+            options?: {
+              slotDefault?: ()=> Array<any>,
+        }){super()}
+    }
+    export class template<T> extends VueComponent {
+        constructor(
+            options?: {
+              slotDefault?: ()=> Array<any>,
+        }){super()}
+    }
+    export type GetItemTypeFromDataSource<T> = T extends nasl.collection.PageOf<infer U> | Array<infer U> | ((...args: any) => nasl.collection.PageOf<infer U> | Array<infer U>) ? U : never;
+    \n`;
+    for (const i in allComponent) {
+        const item = allComponent[i];
+        const componentName = toHump(item.name);
+        if (!componentName)
+            break;
+        // console.log(item);
+        value += `export class ${componentName}<T> extends VueComponent{\n
+                constructor(\n
+                options?: {\n
+                [propname: string]: any,\n`;
+        // 生成slot
+        if (Object.prototype.toString.call(item.slots) === '[object Array]') {
+            let hasDefault = false;
+            if (item.attrs && item.attrs.find((item: any) => item.name === 'data-source')) {
+                // 没有插槽的
+                value += `slotDefault?: (scope: nasl.ui.ScopeOf<T>)=> Array<any>,\n`;
+                hasDefault = true;
+            }
+            item.slots.forEach((slot: any) => {
+                if (!slot.advanced) {
+                    const slotName = toHump('slot-' + slot.name);
+                    // 如果已经有带参数的slotDefault
+                    if (slotName === 'slotDefault' && hasDefault)
+                        return;
+                    if (Array.isArray(slot.props) && slot.props.length === 5) {
+                        value += indent(3);
+                        value += slotName + `?: (scope: nasl.ui.ScopeOf<T>) => Array<any>,\n`;
+                    } else if (Array.isArray(slot.props)) {
+                        value += indent(3);
+                        value += slotName + `?: (scope: {`;
+                        slot.props.forEach((prop: any) => {
+                            const type = prop.type || '';
+                            value += `${prop.name}: ${type}, `;
+                        });
+                        value += `}) => Array<any>,\n`;
+                    } else {
+                        value += indent(3);
+                        value += slotName + `?: ()=> 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 + ': ';
+                            const type = toNaslType(param.type);
+                            methodParamStr += type;
+                            methodParamStr += ',';
+                        });
+                        value += indent(1);
+                        value += methodName + `: (fn: (${methodParamStr}) => any) => void\n`;
+                        logics.push(creatMethodLogic(method));
+                    } else {
+                        value += indent(1);
+                        value += methodName + `: () => void;\n`;
+                        logics.push(creatMethodLogic({ name: methodName, params: [] }));
+                    }
+                }
+            });
+            elementsLogic[componentName] = logics;
+        }
+        value += '}\n';
+    }
+    value += '}\n';
+    return {
+        code: value,
+        elementsLogic,
+    };
+}

package/src/server/entity2LogicNamespace.ts

@@ -1,4 +1,4 @@
-import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process } from '..';
+import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return } from '..';
 export function entity2LogicNamespace(entity: Entity) {
     const ns = new Namespace({
         name: entity.name,
@@ -186,3 +186,19 @@ export function entity2LogicNamespace(entity: Entity) {
 
     return ns;
 }
+
+interface entityTreeFragment {
+    logics: Array<Logic>;
+    name: string;
+    id: string;
+    concept: string;
+}
+export function entityToTreeFragment(entity: Entity) {
+    const fragment: entityTreeFragment = {
+        name: entity.name,
+        id: entity.id,
+        concept: entity.concept,
+        logics: entity.ns.logics,
+    };
+    return fragment;
+}

package/src/server/getExtensionModules.ts

@@ -0,0 +1,13 @@
+import { App, Module, Namespace } from '..';
+export function getExtensionModules(app: App) {
+    return app.dependencies;
+}
+
+export function moduleToLogicNamesapce(m: Module) {
+    const ns = new Namespace({
+        name: m.name,
+        logics: m.logics,
+    });
+    ns.path = `app.${m.name}.logics`;
+    return ns;
+}

package/src/server/getLogics.ts

@@ -1,5 +1,6 @@
-import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process } from '..';
+import { CallLogic, BindEvent, App, Namespace, Entity, BaseNode, Logic, Param, TypeAnnotation, Return, Process, ViewElement } from '..';
 import { process2LogicNamespace } from './process2LogicNamespace';
+import { moduleToLogicNamesapce } from './getExtensionModules';
 import naslServer from './naslServer';
 
 type FakeNode = Partial<Namespace> & {
@@ -51,6 +52,9 @@ function iterator(tree: FakeNode | FakeProcessNode, searchContent: string, fakeN
     }
 }
 
+function toHump(name: string): string {
+    return name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase());
+}
 export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boolean = true) {
     const app = node.rootNode as App;
     if (node.concept === 'CallLogic' || node.concept === 'BindEvent') {
@@ -63,41 +67,38 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 return item;
             });
             const ps = app.processes.map((p) => process2LogicNamespace(p));
+            const extensions = app.dependencies.map(moduleToLogicNamesapce);
             const tree = new Namespace({
                 name: 'logics',
                 path: `${app.getNamespace()}.logics`,
                 title: '全局逻辑',
                 logics: app.logics,
-                children: [...nc, ...(app.dependencies.slice(1) as any as Namespace[]), ...ps],
+                children: [...nc, ...extensions, ...ps],
             });
             result.push(tree);
         }
 
         if (node.view && node.view.logics) {
             // 获取组件逻辑, 获取传入字段的子集
-            const elementsMethod = await naslServer.getElementsMethod(node, '@__elements') || [];
-            console.log(elementsMethod);
+            const elements: Array<ViewElement> = [];
+            node.view.elementsMethods(node.view.elements, elements);
             const viewElements: Array<Namespace> = [];
-            (elementsMethod as Array<any>).forEach((item) => {
-                const { text, children } = item;
-                if (children && children.length) {
-                    const logics = children.map((method: any) =>
-                        new Logic({
-                            name: method.text,
-                            params: [],
-                            returns: [],
-                            body: [],
-                        }));
+            elements.forEach((item) => {
+                const itemTag = toHump(item.tag);
+                const elementsLogic = naslServer.elementsLogic;
+                const elementsLogicName = itemTag;
+                const eleLogis = elementsLogic[elementsLogicName];
+                // 看是不是有已经有有参数的函数了
+                if (Array.isArray(eleLogis) && eleLogis.length) {
                     const viewElement = new Namespace({
-                        title: text,
+                        title: toHump(item.name),
                         name: 'methods',
-                        logics,
-                        path: `elements.${text}.logics`,
+                        logics: elementsLogic[elementsLogicName],
+                        path: `elements.${toHump(item.name)}.logics`,
                     });
                     viewElements.push(viewElement);
                 }
             });
-
             // 增加页面逻辑
             const tree = new Namespace({
                 name: 'logics',

package/src/server/getMemberIdentifier.ts

@@ -1,4 +1,4 @@
-import { BaseNode, CompletionProperty, App, Identifier, MemberExpression, Enum, NullLiteral, BooleanLiteral, Param } from '..';
+import { BaseNode, CompletionProperty, App, Identifier, MemberExpression, Enum, NullLiteral, BooleanLiteral, Param, BindAttribute } from '..';
 import naslServer from './naslServer';
 
 interface variableItem {
@@ -23,7 +23,6 @@ function formatVariableData(data: unknown | variableItem[], node: BaseNode, pare
             } else {
                 item.expression = new MemberExpression({
                     object: parent.expression,
-                    objectqwer: parent.expression,
                     property: new Identifier({ name: item.name }),
                 });
             }
@@ -76,7 +75,6 @@ function formatEnums(enums: Array<Enum>) {
             newEnumItem.name = newEnumItem.value;
             newEnumItem.expression = new MemberExpression({
                 object: item.expression,
-                objectqwer: item.expression,
                 property: new Identifier({ name: newEnumItem.value }),
             });
             const completionProperty = new CompletionProperty(newEnumItem);
@@ -90,10 +88,10 @@ function formatEnums(enums: Array<Enum>) {
     return result;
 }
 type LiteralDefination = {
-    name: string
-    value: string
-    expression?: Identifier,
-}
+    name: string;
+    value: string;
+    expression?: Identifier;
+};
 // 先简单处理一下
 function formatLiterals() {
     const list: Array<LiteralDefination> = [
@@ -110,19 +108,54 @@ function formatLiterals() {
     return newList;
 }
 
-export async function getMemberIdentifier(node: BaseNode, filterText?: string) {
+// 获取当前可选的逻辑
+function getCurrentLogic(node: BaseNode,
+    result: {
+        name: string;
+        children: CompletionProperty[];
+        level: string;
+    }[]) {
+    // 只有data-source可以
+    if (node instanceof Identifier && node.parentNode instanceof BindAttribute && node.parentNode.name === 'data-source') {
+        const view = node.view;
+        const viewLogics = view.logics;
+        const logicVariable = viewLogics.map((item) => {
+            const newLogic: LiteralDefination = {
+                name: item.name,
+                value: item.name,
+            };
+            newLogic.expression = new Identifier({ name: item.name });
+            const completionProperty = new CompletionProperty(newLogic);
+            completionProperty.level = 'logic';
+            return completionProperty;
+        });
+        result.push({ name: '逻辑', children: logicVariable, level: 'category' });
+    }
+}
+
+export async function getMemberIdentifier(node: BaseNode) {
     if (node) {
-        // 先去获取
-        const completion = await naslServer.getSelectCompletion(node) as variableItem[];
-        const completionData = formatVariableData(completion, node);
         // 获取枚举
         const app = node.rootNode as App;
         const literals = formatLiterals();
         const enums = app?.enums;
-        const newEnums = formatEnums(enums);
+        const newEnums = enums ? formatEnums(enums) : [];
+
         //      extensionModules(state) {
         // return state.app?.dependencies?.filter((module) => module.type === 'extension') || {};
         // },
+
+        // 如果之前有选好的值就需要的把之前那一列的内容渲染出来
+        // 先去获取
+
+        let completionData: CompletionProperty[] = [new CompletionProperty({})];
+        if (node instanceof Identifier || node instanceof MemberExpression) {
+            const value = (node as Identifier | MemberExpression).getValue();
+            if (value) {
+                const completion = (await naslServer.getValueSelectCompletion(node, value)) as variableItem[];
+                completionData = formatVariableData(completion, node);
+            }
+        }
         // 这个可能需要自己算一下
         const result = [
             { name: '字面量', children: literals, level: 'category' },
@@ -130,14 +163,22 @@ export async function getMemberIdentifier(node: BaseNode, filterText?: string) {
             { name: '变量', children: completionData, level: 'category' },
             // { name: '流程变量', children: [] },
         ];
+        getCurrentLogic(node, result);
         return result;
     }
 }
 
-// export async function getSelectNextCompletionData(node: BaseNode) {
-//     if (node) {
-//         // 先去获取
-//         const nextCompletion = await naslServer.getSelectNextCompletion(node);
-//         console.log(nextCompletion)
-//     }
-// }
+export async function getSelectNextCompletionData(node: Identifier, completionProperty?: CompletionProperty) {
+    if (node) {
+        let fieldKey: string = null;
+        if (completionProperty) {
+            const exp = BaseNode.from(completionProperty.expression);
+            const value = (exp as Identifier).getValue();
+            fieldKey = value;
+        }
+
+        const nextCompletion = await naslServer.getFieldKeySelectCompletion(node, fieldKey);
+        const completionData = formatVariableData(nextCompletion, node, completionProperty);
+        return completionData;
+    }
+}

package/src/server/getProcesses.ts

@@ -10,7 +10,7 @@ function alphaUpper(name: string) {
 
 export function genLaunchProcess(process: Process) {
     const l = new Logic({
-        name: 'launch' + alphaUpper(process.name),
+        name: 'launch',
         params: process.params,
         body: [],
         returns: [
@@ -33,24 +33,31 @@ export function process2LogicNamespace(process: Process) {
     return ns;
 }
 
-function returnToParam(r: Return) {
-    return Param.from(r);
+export function returnToParam(r: Return) {
+    const obj = r.toJSON() as { concept: string };
+    delete obj.concept;
+    return Param.from(obj);
 }
 
 function variableToParam(v: Variable) {
-    return Param.from(v);
+    const obj = v.toJSON() as { concept: string };
+    delete obj.concept;
+    return Param.from(obj);
 }
 
-function constantToParam(v: Constant) {
-    return Param.from(v);
+export function constantToParam(v: Constant) {
+    const obj = v.toJSON() as { concept: string };
+    delete obj.concept;
+    // console.log(Param.from(obj));
+    return Param.from(obj);
 }
 
 export function genUserTaskLogic(userTask: ProcessElement) {
     const taskId = userTask.constants.find((p) => p.name === 'taskId');
     const l = new Logic({
-        name: `complete${alphaUpper(userTask.process.name)}${alphaUpper(userTask.name)}`,
+        name: `complete`,
         fake: true,
-        params: [...userTask.returns.map(returnToParam), constantToParam(taskId)],
+        params: [constantToParam(taskId), ...userTask.returns.map(returnToParam)],
         body: [],
         returns: [],
     });

package/src/server/getValidates.ts

@@ -1,7 +1,7 @@
 import { CallFunction, stdlibNamespace } from '..';
 
 export function getValidates(node?: CallFunction) {
-    return stdlibNamespace.findChild('validate');
+    return stdlibNamespace.findChild('validation');
 }
 
 export function getValidateFunction(name: string) {

package/src/server/index.ts

@@ -3,7 +3,7 @@ import { getInterfaces } from './getInterfaces';
 import { getFunctions, getBuildInFunction } from './getFunctions';
 import { getValidates, getValidateFunction } from './getValidates';
 import { getProcessComponents, getProcessComponent } from './getProcessComponents';
-import { getMemberIdentifier } from './getMemberIdentifier';
+import { getMemberIdentifier, getSelectNextCompletionData } from './getMemberIdentifier';
 import naslServer from './naslServer';
 
 const server: any = {
@@ -18,5 +18,6 @@ const server: any = {
     getMemberIdentifier,
     getValidates,
     getValidateFunction,
+    getSelectNextCompletionData,
 };
 export default server;