@lcap/nasl 2.14.0 → 2.15.1

package/src/generator/genBundleFiles.ts

@@ -21,6 +21,7 @@ export async function genBundleFiles(app: App,
         lowcodeDomain: string;
         envLcpDomain: any,
         envNuimsDomain: any,
+        tenantType: any,
         appid: string;
     }) {
     const fnNuimsDomain = config?.envNuimsDomain?.[config?.env] || config?.nuimsDomain;
@@ -309,6 +310,7 @@ export async function genBundleFiles(app: App,
             domainName: app.name,
             nuimsDomain: fnNuimsDomain,
             envNuimsDomain: config.envNuimsDomain,
+            tenantType: config.tenantType,
             extendedConfig: config.extendedConfig,
             envConfig: {
                 lowcodeDomain: fnLowcodeDomain,
@@ -320,6 +322,7 @@ export async function genBundleFiles(app: App,
         tenant: config.tenant,
         env: config.env,
         hasUserCenter: app.hasUserCenter,
+        hasAuth: app.hasAuth,
         authResourcePaths,
         baseResourcePaths,
     }, null, 4);

package/src/server/extendBaseNode.ts

@@ -37,11 +37,19 @@ BaseNode.prototype.findReadOnlyLogicUsage = function () {
         const sourceMap = this.parentNode.sourceMap;
         for (const item of sourceMap) {
             const logic = item[0] as Logic;
-            if (logic.getNamespace && logic.getNamespace() === (this as Logic).getNamespace()) {
+            if (logic.calleewholeKey && logic.calleewholeKey === (this as Logic).calleewholeKey) {
                 targetNode = logic;
                 break;
             }
         }
+        if (!targetNode)
+            for (const item of sourceMap) {
+                const logic = item[0] as Logic;
+                if (logic.getNamespace && logic.getNamespace() === (this as Logic).getNamespace()) {
+                    targetNode = logic;
+                    break;
+                }
+            }
     }
 
     try {
@@ -198,11 +206,21 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                 const find = refsList.find((record) => !record.file.includes(viewPath));
                 // 如果没有别的文件的依赖，就直接delete
                 if (!find) {
-                    this.delete();
+                    if (node instanceof Process) {
+                        const App = this.rootNode;
+                        App.emit('collect:start', {
+                            actionMsg: `删除流程${node.name}`,
+                        });
+                        await Promise.all(node.elements.map((ele) => ele.isUserTask && ele.cancelBindDelete(true)));
+                        this.delete();
+                        App.emit('collect:end');
+                    } else {
+                        this.delete();
+                    }
                     return;
                 }
             }
-            callback = () => {
+            callback = async () => {
                 // removeParam
                 // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
                 if (node instanceof Param) {
@@ -284,9 +302,18 @@ BaseNode.prototype.prepareDelete = async function prepareDelete() {
                 }
 
                 // 删除页面或者流程,如果上一步没有return 就说明他是有别的引用的，会有引用弹框
-                if (node instanceof View || node instanceof Process) {
+                if (node instanceof View) {
                     this.delete();
                 }
+                if (node instanceof Process) {
+                    const App = this.rootNode;
+                    App.emit('collect:start', {
+                        actionMsg: `删除流程${node.name}`,
+                    });
+                    await Promise.all(node.elements.map((ele) => ele.isUserTask && ele.cancelBindDelete(true)));
+                    this.delete();
+                    App.emit('collect:end');
+                }
                 // 其余的都直接调用删除
                 // Structure 和 Interface是内部有delete方法
                 if (node instanceof Structure || node instanceof Interface) {

package/src/server/getLogics.ts

@@ -111,6 +111,40 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
             result.push(tree);
         }
 
+        const processLogics = stdlibNamespace.findChild('process').logics;
+        const processLogicsTree = new Namespace({
+            name: 'category',
+            path: `process`,
+            title: '流程逻辑',
+            children: [
+                new Namespace({
+                    name: 'category',
+                    title: '流程实例',
+                    logics: processLogics.filter((logic) => logic.name.includes('ProcessInstance')),
+                    expanded: false,
+                }),
+                new Namespace({
+                    name: 'category',
+                    title: '流程定义',
+                    logics: processLogics.filter((logic) => logic.name.includes('ProcessDefinition')),
+                    expanded: false,
+                }),
+                new Namespace({
+                    name: 'category',
+                    title: '任务实例',
+                    logics: processLogics.filter((logic) => logic.name.includes('TaskInstance') || logic.name.includes('TaskDestination')),
+                    expanded: false,
+                }),
+                new Namespace({
+                    name: 'category',
+                    title: '任务定义',
+                    logics: processLogics.filter((logic) => logic.name.includes('TaskDefinition')),
+                    expanded: false,
+                }),
+            ],
+            expanded: false,
+        });
+
         if (node.view && node.view.logics) {
             // 获取组件逻辑, 获取传入字段的子集
             const elements: Array<ViewElement> = [];
@@ -148,13 +182,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 path: `nasl`,
                 title: '系统逻辑',
                 children: [
-                    new Namespace({
-                        name: 'category',
-                        path: `process`,
-                        title: '流程逻辑',
-                        logics: stdlibNamespace.findChild('process').logics,
-                        expanded: false,
-                    }),
+                    processLogicsTree,
                     new Namespace({
                         name: 'category',
                         path: `browser`,
@@ -176,6 +204,13 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                         logics: stdlibNamespace.findChild('configuration').logics,
                         expanded: false,
                     }),
+                    new Namespace({
+                        name: 'category',
+                        path: `io`,
+                        title: '文件处理',
+                        logics: stdlibNamespace.findChild('io').logics,
+                        expanded: false,
+                    }),
                 ],
                 expanded: false,
             });
@@ -192,13 +227,7 @@ export async function getLogics(node: CallLogic | BindEvent, needAllLogic: boole
                 path: `nasl`,
                 title: '系统逻辑',
                 children: [
-                    new Namespace({
-                        name: 'category',
-                        path: `process`,
-                        title: '流程逻辑',
-                        logics: stdlibNamespace.findChild('process').logics,
-                        expanded: false,
-                    }),
+                    processLogicsTree,
                     new Namespace({
                         name: 'category',
                         path: `configuration`,

package/src/server/getProcesses.ts

@@ -60,25 +60,48 @@ export function constantToParam(v: Constant) {
 export function genUserTaskLogic(userTask: ProcessElement) {
     const taskId = userTask.constants.find((p) => p.name === 'taskId');
     const process = userTask.process;
-    const l = new Logic({
-        name: `complete`,
-        fake: true,
-        params: [constantToParam(taskId), ...userTask.returns.map(returnToParam)],
-        body: [],
-        returns: [],
-    });
+    const l = [
+        new Logic({
+            name: `complete`,
+            fake: true,
+            params: [constantToParam(taskId), ...userTask.returns.map(returnToParam)],
+            body: [],
+            returns: [],
+        }),
+        new Logic({
+            name: `reject`,
+            fake: true,
+            params: [
+                new Param({
+                    name: 'taskId',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                new Param({
+                    name: 'targetTaskDefinitionId',
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+                ...userTask.returns.map(returnToParam),
+            ],
+            body: [],
+            returns: [],
+        }),
+    ];
+    if (userTask.type === 'InitiateTask')
+        l.pop();
     const path = `app.processes.${process.name}.elements.${userTask.name}.logics`;
-    l.getNamespace = function () {
-        return path;
-    };
-    l.fake = true;
+    l.forEach((item) => {
+        item.getNamespace = function () {
+            return path;
+        };
+        item.fake = true;
+    });
     return l;
 }
 
 export function userTask2LogicNamespace(userTask: ProcessElement) {
     const ns = new Namespace({
         name: userTask.name,
-        logics: [genUserTaskLogic(userTask)],
+        logics: [...genUserTaskLogic(userTask)],
     });
 
     return ns;
@@ -152,7 +175,7 @@ export function travelDown(node: any, callback: (node: any) => void) {
 export function syncMemberExpression(elem: ProcessElement | Process, callback: (node: MemberExpression) => void) {
     const process = elem instanceof Process ? elem : elem.process;
     process.elements.forEach((el) => {
-        if (el.type === 'UserTask') {
+        if (el.isUserTask) {
             el.bindAttrs.forEach((attr) => {
                 if (attr.name === 'destination') {
                     attr.destination.arguments.forEach((arg) => {
@@ -197,17 +220,18 @@ export function genMemberExpression(path: string) {
             m = new MemberExpression({
                 object: cv,
             });
+            cv.parentKey = 'object';
             cv.parentNode = m;
         } else {
             m.property = cv;
+            cv.parentKey = 'property';
+            cv.parentNode = m;
             if (arr.length) {
                 const tm = new MemberExpression({
                     object: m,
                 });
                 m.parentKey = 'object';
                 m.parentNode = tm;
-                cv.parentKey = 'property';
-                cv.parentNode = tm;
                 m = tm;
             }
         }
@@ -279,7 +303,7 @@ export function getPreviousTask(node: ProcessElement, nodePorcess?: Process) {
         if (visitedMap.has(processElem)) {
             return;
         }
-        if (processElem !== node && (processElem.type === 'UserTask' || processElem.type === 'AutoTask')) {
+        if (processElem !== node && (processElem.isUserTask || processElem.type === 'AutoTask')) {
             elements.push(processElem);
         }
         visitedMap.set(processElem, true);
@@ -349,7 +373,7 @@ export function getProcessVariableSuggestions(node: LogicItem, abandonConstant:
         processVariables.children.push(scopeVariable);
     }
 
-    if (processElem.type === 'UserTask') {
+    if (processElem.isUserTask) {
         // 任务完成时可以拿到该任务的输出参数
         let returns: CompletionProperty[] = [];
         if (node.logic && node.logic.parentNode.name === 'OnClose') {
@@ -456,14 +480,15 @@ function deduceTypeAnnotation(app: App,
     }
 }
 
-export function getProcessVariableSuggestionsAll(node: ProcessElement, exitConstant?: Boolean) {
+export function getProcessVariableSuggestionsAll(node: ProcessElement, exitConstantId?: Boolean) {
     const processElem = node;
     const process = node.process;
     const app = node.app;
     const elements: ProcessElement[] = getPreviousTask(processElem);
     const prevtasks = elements.map((us) => {
         const returns = us.returns.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], []));
-        const constants = exitConstant ? [] : us.constants.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], []));
+        let constants = us.constants.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name, us.name], []));
+        exitConstantId && (constants = constants.filter((constant) => constant.name !== 'taskId'));
         const cp = new CompletionProperty({
             name: us.name,
             value: us.name,
@@ -478,7 +503,8 @@ export function getProcessVariableSuggestionsAll(node: ProcessElement, exitConst
         return cp;
     });
 
-    const processContants = exitConstant ? [] : process.constants.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], []));
+    let processContants = process.constants.map((node) => deduceTypeAnnotation(app, node, node.typeAnnotation, [process.name], []));
+    exitConstantId && (processContants = processContants.filter((constant) => constant.name !== 'processId'));
     const processVariables = new CompletionProperty({
         name: process.name,
         value: process.name,
@@ -504,7 +530,7 @@ export function getProcessVariableSuggestionsAll(node: ProcessElement, exitConst
         processVariables.children.push(scopeVariable);
     }
 
-    if (processElem.type === 'UserTask' && !exitConstant) {
+    if ((processElem.isUserTask) && !exitConstantId) {
         const scopeVariable = new CompletionProperty({
             name: processElem.name,
             value: processElem.name,

package/src/server/naslServer.ts

@@ -652,6 +652,20 @@ const naslServer = {
                 }
             }
         }
+        if (fileNode instanceof Logic) {
+            fileNode?.sourceMap.forEach((value, node) => {
+                // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
+                if (node instanceof SqlQueryComponent && node.getTypeBanError()) {
+                    const diagnostic = {
+                        node,
+                        severity: 'error',
+                        message: 'SQL查询：返回类型内部,不支持复杂类型。',
+                    };
+                    node.tsErrorDetail = diagnostic;
+                    diagnostics.push(diagnostic);
+                }
+            });
+        }
 
         return diagnostics;
     },
@@ -1287,11 +1301,6 @@ const naslServer = {
                     if (minRange.node instanceof BindEvent && node instanceof Param) {
                         return null;
                     }
-                    // 如果是子页面修改
-                    // 父页面引起子页面改名，就可以不改了，自动同步
-                    if (minRange.node instanceof View && node instanceof View && minRange.node !== node) {
-                        return null;
-                    }
                     /**
                      * 理论上 logic setName只能自己触发，别的地方查到引用都不用重命名
                      * 流程改名不触发Logic改名
@@ -1305,23 +1314,37 @@ const naslServer = {
                     if (node instanceof Param && minRange.node instanceof Interface) {
                         return null;
                     }
-
-                    /**
-                     * 无论是逻辑还是实体中的key，修改都不应该触发
-                     * 理论上除了组件自己改名可以触发
-                     * 下面这里 不属于Role是因为上面代码里有， 不符合 规范 的role改名存在所以先保留
-                     */
-                    if (!(node instanceof Role) && minRange.node instanceof ViewElement) {
-                        return null;
+                    // 如果是被影响的是页面
+                    if (minRange.node instanceof View) {
+                        if (node instanceof View) {
+                            // 如果是子页面修改
+                            // 父页面引起子页面改名，就可以不改了，自动同步
+                            if (minRange.node !== node) {
+                                return null;
+                            }
+                        } else if (!(node instanceof Role)) {
+                            /**
+                             * 无论是逻辑还是实体中的key，修改都不应该触发
+                             * 理论上除了组件自己改名可以触发
+                             * 下面这里 不属于Role是因为上面代码里有， 不符合 规范 的role改名存在所以先保留
+                             */
+                            return null;
+                        }
                     }
-
-                    /**
-                     * 无论是逻辑还是实体中的key，修改都不应该触发
-                     * 理论上除了组件自己改名可以触发
-                     * 下面这里 不属于Role是因为上面代码里有， 不符合 规范 的role改名存在所以先保留
-                     */
-                    if (!(node instanceof Role) && minRange.node instanceof View) {
-                        return null;
+                    // 如果是被影响的是页面元素
+                    if (minRange.node instanceof ViewElement) {
+                        if (node instanceof ViewElement) {
+                            if (minRange.node !== node) {
+                                return null;
+                            }
+                        } else if (!(node instanceof Role)) {
+                            /**
+                             * 无论是逻辑还是实体中的key，修改都不应该触发
+                             * 理论上除了组件自己改名可以触发
+                             * 下面这里 不属于Role是因为上面代码里有， 不符合 规范 的role改名存在所以先保留
+                             */
+                            return null;
+                        }
                     }
                 } else {
                     console.log('没找到节点需要排查');

package/src/server/naslStdlibMap.ts

@@ -12,6 +12,7 @@ const naslStdlibMap: any = {
     'nasl.validation.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.validation.ts').default,
     'nasl.process.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.process.ts').default,
     'nasl.logging.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.logging.ts').default,
+    'nasl.io.ts': require('!!raw-loader!../../../file-storage/data/stdlib/nasl.io.ts').default,
 };
 
 export default naslStdlibMap;

package/src/server/process2LogicNamespace.ts

@@ -9,22 +9,25 @@ import { genLaunchProcess, genUserTaskLogic } from './getProcesses';
 export function process2LogicNamespace(process: Process) {
     const children: Array<Namespace> = [];
     process.elements.forEach((e) => {
-        if (e.type === 'UserTask') {
+        if (e.isUserTask) {
             const l = genUserTaskLogic(e);
             const ns = new Namespace({
                 name: e.name,
-                logics: [l],
-                originConcept: 'UserTask',
+                logics: [...l],
+                originConcept: e.type,
             });
             // 与process 中 toEmbededTS 所设置的 namespace 相关
             const path = `app.processes.${process.name}.elements.${e.name}.logics`;
-            l.getNamespace = function () {
-                return path;
-            };
-            const api = `/api/${process.name}/${e.name}/${l.name}`;
-            l.getPath = function () {
-                return api;
-            };
+            l.forEach((k) => {
+                k.getNamespace = function () {
+                    return path;
+                };
+                const api = `/api/${process.name}/${e.name}/${k.name}`;
+                k.getPath = function () {
+                    return api;
+                };
+            });
+
             children.push(ns);
             ns.path = `app.processes.${process.name}.elements.${e.name}`;
             ns.expanded = true;
@@ -73,23 +76,26 @@ export function processToTreeFragment(process: Process) {
         elements: [],
     };
     process.elements.forEach((e) => {
-        if (e.type === 'UserTask') {
+        if (e.isUserTask) {
             const l = genUserTaskLogic(e);
-            l.parentKey = 'readonly';
-            l.params.forEach((p) => {
-                p.readonly = true;
+            l.forEach((k) => {
+                k.parentKey = 'readonly';
+                k.params.forEach((p) => {
+                    p.readonly = true;
+                });
+                k.parentNode = process;
+                // 与process 中 toEmbededTS 所设置的 namespace 相关
+                const path = `app.processes.${process.name}.elements.${e.name}.logics`;
+                k.getNamespace = function () {
+                    return path;
+                };
             });
-            l.parentNode = process;
-            // 与process 中 toEmbededTS 所设置的 namespace 相关
-            const path = `app.processes.${process.name}.elements.${e.name}.logics`;
-            l.getNamespace = function () {
-                return path;
-            };
+
             fragment.elements.push({
                 level: 'processTreeElementFragment',
                 id: e.id,
                 name: e.name,
-                logics: [l],
+                logics: [...l],
             });
         }
     });

package/src/server/translator.ts

@@ -86,7 +86,7 @@ function transformType(tsType: string): string {
         return '拓展模块';
     else if (tsType === 'Promise<void>')
         return '未知类型';
-    else if (tsType.startsWith('{') && tsType.endsWith('}'))
+    else if (tsType.startsWith('{') && tsType.endsWith('}') || tsType.startsWith('{') && tsType.endsWith('...'))
         return '当前节点';
     else if (tsType.endsWith('[]')) {
         return `List<${transformType(tsType.slice(0, -2))}>`;
@@ -226,9 +226,13 @@ const TS_RULES: Array<{
         re: /Cannot find name '__(?:EMPTY_AGGREGATE_ALIAS)__'/,
         result: '数据查询：聚合函数别名不能为空。',
     },
+    {
+        re: /Cannot find name '__(?:SQL_GRAMMAR_ERROR)__'/,
+        result: 'SQL查询：语句可能有异常。',
+    },
     {
         re: /Cannot find name '__UsersEmpty__'./,
-        result: '用户任务完成人为空',
+        result: '任务完成人为空',
     },
     {
         re: /No value exists in scope for the shorthand property '__(?:IDENTIFIER|LEFT|RIGHT)__'. Either declare one or provide an initializer./,
@@ -307,7 +311,7 @@ const TS_RULES: Array<{
     },
     {
         re: /'__destinationEmpty__' is declared but its value is never read./,
-        result: '用户任务未关联页面',
+        result: '任务未关联页面',
     },
 ];
 
@@ -385,11 +389,24 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             return null;
         }
 
-        if (node instanceof ProcessElement && (node.type === 'UserTask' || node.type === 'AutoTask' || node.type === 'StartNoneEvent')) {
+        if (node instanceof ProcessElement && (node.isUserTask || node.type === 'AutoTask' || node.type === 'StartNoneEvent')) {
             const reg = /Expected (.+?) arguments, but got (.+?)./.exec(text);
-            let u = '用户任务';
-            if (node.type === 'AutoTask') {
-                u = '自动任务';
+            let u;
+            switch (node.type) {
+                case 'UserTask':
+                    u = '用户任务';
+                    break;
+                case 'AutoTask':
+                    u = '自动任务';
+                    break;
+                case 'ApprovalTask':
+                    u = '审批任务';
+                    break;
+                case 'InitiateTask':
+                    u = '发起任务';
+                    break;
+                default:
+                    u = '任务';
             }
             if (reg[2] === '0') {
                 tsErrorDetail.message = `${u}出口顺序流个数不能是0`;
@@ -480,9 +497,19 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             tsErrorDetail.message = '调用逻辑：参数不能为空！';
         } else if (node instanceof ProcessOutcome || node instanceof Function) {
             tsErrorDetail.message = (node as any).constructor.nodeTitle + '：不能为空！';
-        } else if (node instanceof Argument || node instanceof TypeAnnotation) {
+        } else if (node instanceof Argument) {
+            let str = tsErrorDetail.message;
+            str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
+            tsErrorDetail.message = str;
+        } else if (node instanceof TypeAnnotation) {
+            // 如果是TypeAnnotation 嵌套TypeAnnotation，就往上冒，多是那种T嵌套的
             let str = tsErrorDetail.message;
+            // TypeAnnotation要冒泡到最上面
+            while (node.parentNode && node.parentNode instanceof TypeAnnotation) {
+                node = node.parentNode;
+            }
             str = (node.parentNode as any).constructor.nodeTitle + '：' + str;
+
             tsErrorDetail.message = str;
         } else if (node instanceof Identifier) {
             // 根据父级内容推断当前缺少啥

package/src/service/storage/init.ts

@@ -80,12 +80,30 @@ async function doAction(app: any, actionItem: any) {
     let hasBackEnd = false;
     const actionList: any[] = [];
     const { list, actionMsg, action } = actionItem || {};
+    const itemloop = (_i: LogicItem, app: any, diffArr: string[]) => {
+        const _l = getStatement(_i, app, diffArr);
+        if (_l.length) {
+            _l.map((_ii: LogicItem) => itemloop(_ii, app, diffArr));
+        }
+    };
     const loopEle = (view: View | ViewElement, checkAuth: boolean) => {
         if (view instanceof View) {
             view?.elements?.forEach((item) => loopEle(item, checkAuth));
         }
         view?.children?.forEach((item) => loopEle(item, checkAuth));
         if (view instanceof ViewElement) {
+            if (view.bindEvents.length) {
+                const diffArr: string[] = [];
+                view.bindEvents.forEach((bindEvent) => {
+                    bindEvent.logics.forEach((logic) => {
+                        logic.body.forEach((logicItem) => itemloop(logicItem, app, diffArr));
+                    });
+                });
+                const result = diffArr.filter((item) => item.startsWith('app') || item.startsWith('extensions'));
+                if (result.length) {
+                    hasBackEnd = true;
+                }
+            }
             if (view.tag === 'u-uploader' || view.tag === 'van-uploader') {
                 const bute = view?.bindAttrs.find((item) => item.name === 'url');
                 if (checkAuth) {
@@ -112,12 +130,6 @@ async function doAction(app: any, actionItem: any) {
                 ) {
                     hasBackEnd = true;
                 }
-                const itemloop = (_i: LogicItem, app: any, diffArr: string[]) => {
-                    const _l = getStatement(_i, app, diffArr);
-                    if (_l.length) {
-                        _l.map((_ii: LogicItem) => itemloop(_ii, app, diffArr));
-                    }
-                };
                 if (emitTarget.concept === 'Logic') {
                     const diffArr: string[] = [];
                     if (emitTarget.body.length > 2) {

package/src/templator/genCreateBlock.ts

@@ -34,7 +34,7 @@ export function genCreateFormTemplate(entity: Entity, nameGroup: NameGroup, sele
                 rules.push('required');
             const rulesStr = rules.join(' | ');
 
-            let formItem = `            <u-form-item label="${label}"${required ? ' required' : ''}${rulesStr.length ? ` rules="${rulesStr}"` : ''}>\n`;
+            let formItem = `            <u-form-item ${required ? ' required' : ''}${rulesStr.length ? ` rules="${rulesStr}"` : ''}><template #label><u-text text="${label}"></u-text></template>\n`;
 
             const { typeAnnotation } = property || {};
             const { typeName: propertyTypeName, typeNamespace: propertyTypeNamespace } = typeAnnotation || {};