@lcap/nasl 0.3.15-beta → 1.0.0-alpha

package/DEVELOPMENT.md

@@ -1,58 +1,42 @@
 # Development
 
-开发时，这块尽量能够单独发包。
-
-## 规范
-
-- 为了兼容 Vue，属性至少全部声明 undefined
-- 都声明 constructor
-- 按 JSON 创建节点时，优先使用 from
-- 添加和删除操作，先请求再变更；设置属性的话，简单一些先修改数据再请求
-- 发送请求处理数据，返回时按最小情况 pick
-### 增删改查定义方式
-
-#### 增1
-```
-const entity = new Entity({
-    serviceId: '292c8df3-a74b-4434-83ec-14eb7798bc5e',
-    ...
-});
-await entity.create();
-```
-
-#### 增2
-```
-await service.addEntity(entityOptions);
-```
-
-#### 删1
-```
-await entity.delete();
-```
-
-#### 删1
-```
-await service.removeEntity(entity);
-```
-
-#### 改1
-```
-entity.assign({ name: 'bbb' });
-entity.update();
-```
-
-#### 改2
-```
-entity.setName('bbb');
-```
-
-#### 查
-```
-const entity = new Entity({ id: 'e457acee-d69b-4f5b-bbe5-64ac8fdbf7ce' });
-entity.load(); => handle
-```
-
-#### [v] 查列表
+## 目录结构
+
+```
+- src/                          # 源文件
+    - common/                   # 通用类
+    - concepts/                 # 所有概念类
+    - decorators/               # 装饰器
+    - generator/                # 生成器
+    - manager/                  # 管理器（类型检查）
+    - server/                   # LanguageServer
+    - service/                  # 后端请求 Service
+    - templator/                # 生成实体拖拽的模板器
+    - terms/                    # 术语
+    - test/                     # 测试脚本，由于 ts 是统一编译，一般就放在 src 下面了
+    - translator/               # 翻译器（编译器的部分）
+    - utils/                    # 工具库
+```
+
+## 依赖层级
+
+大家不要反向引用。
+
+```mermaid
+graph BT;
+    service --> config
+    common --> service
+    common --> decorators
+    common --> translator
+    common --> utils
+    concepts --> common
+    server --> concepts
+    manager --> concepts
+    templator --> concepts
+    generator --> concepts
+    designer --> concepts
+    designer --> server
+    designer --> manager
+    designer --> templator
+    designer --> generator
 ```
-service.loadEntities(); => handle
-```

package/README.md

@@ -2,10 +2,83 @@
 
 Software Development Kit of NetEase Application Specific Language.
 
-网易轻舟低代码平台 NASL 语言软件开发工具包，支持在 Browser 和 Node.js 上使用。
+NASL SDK 是针对 NASL 投射编辑的无可视化的软件工具包，与用户在编辑器中的实际操作一致。轻舟低代码平台的 IDE 和前端生成服务便是主要以它为核心开发的。
 
-## 目录
+可运行在 现代浏览器 和 [Node.js](https://nodejs.org) (>=14) 环境上。
 
-- [NASL 规范描述文档]()
-- [前端 @lcap/asl 包的 TypeScript 文档]()
-- [前端 NASL 开发文档](./DEVELOPMENT.md)
+🧐 NASL SDK 主要包含以下功能：
+
+- NASL Object Model，即 NASL 语法树节点结合增删改查等行为的实例化对象，类似 HTML 之于 [DOM](https://developer.mozilla.org/zh-CN/docs/Web/API/Document_Object_Model/Introduction)、CSS 之于 [CSSOM](https://developer.mozilla.org/zh-CN/docs/Glossary/CSSOM)
+- 用于生成中间代码或 Vue 等最终代码的编译方法
+- 实体拖拽的方法
+- 请求、遍历树、去重名等工具库
+- ...
+
+NASL SDK 不包含以下功能：
+
+- 应用本身的创建和删除
+- 应用的发布
+
+## 快速开始 ⏱️
+
+我们以一个在 Node.js 环境运行的脚本为例，您可以在上面进行快速开发。这里推荐使用 [TypeScript](https://www.typescriptlang.org)，它可以给您提供很方便的关于 NASL Object Model 的类型提示。
+
+### 1. 准备
+
+安装 [Node.js](https://nodejs.org) (>=14)
+
+### 2. 安装
+
+```shell
+npm i --save nasl
+```
+
+### 3. 三种方式
+
+#### Browser 方式
+
+```ts
+import * as nasl from 'nasl';
+
+async function start() {
+    await nasl.connect('http', '/some/path');
+    const app = await nasl.loadApp('aw9fajff90j323');
+    // Do your things
+}
+
+start();
+```
+
+#### Node.js 请求方式
+
+```ts
+import * as nasl from 'nasl';
+
+async function start() {
+    await nasl.connect('http', 'http://dogfood.lcap.163yun.com', 'username', 'password');
+    const app = await nasl.loadApp('aw9fajff90j323');
+    // Do your things
+}
+
+start();
+```
+
+#### Node.js 本地文件方式
+
+```ts
+import * as nasl from 'nasl';
+
+async function start() {
+    await nasl.connect('file', './demo-app.json');
+    const app = await nasl.loadApp();
+}
+
+start();
+```
+
+## Test
+
+### 测试一个文件
+```bash
+npm run test:one -- src/test/integration/connect-file.ts
+```

package/bak/basicTypes.ts

@@ -0,0 +1,76 @@
+import { BasicSchema } from '..';
+
+export enum BASIC_TYPE {
+    Boolean = 'Boolean',
+    Integer = 'Integer',
+    Long = 'Long',
+    Decimal = 'Decimal',
+    String = 'String',
+    Text = 'Text',
+    Binary = 'Binary',
+    Date = 'Date',
+    Time = 'Time',
+    DateTime = 'DateTime',
+    Email = 'Email'
+}
+
+export const basicTypeList = [
+    { kind: 'basicType', text: 'Boolean 布尔值', value: '#/basicTypes/Boolean' },
+    { kind: 'basicType', text: 'Integer 整数', value: '#/basicTypes/Integer' },
+    { kind: 'basicType', text: 'Long 长整数', value: '#/basicTypes/Long' },
+    { kind: 'basicType', text: 'Double 小数', value: '#/basicTypes/Decimal' },
+    { kind: 'basicType', text: 'String 字符串', value: '#/basicTypes/String' },
+    { kind: 'basicType', text: 'Text 长文本', value: '#/basicTypes/Text' },
+    { kind: 'basicType', text: 'Binary 二进制流', value: '#/basicTypes/Binary' },
+    { kind: 'basicType', text: 'Date 日期', value: '#/basicTypes/Date' },
+    { kind: 'basicType', text: 'Time 时间', value: '#/basicTypes/Time' },
+    { kind: 'basicType', text: 'DateTime 日期时间', value: '#/basicTypes/DateTime' },
+    { kind: 'basicType', text: 'Email 电子邮箱', value: '#/basicTypes/Email' },
+];
+
+export const basicTypeMap: { [name: string]: BasicSchema } = {
+    '#/basicTypes/Boolean': { type: 'boolean', format: '' },
+    '#/basicTypes/Integer': { type: 'integer', format: 'int' },
+    '#/basicTypes/Long': { type: 'integer', format: 'long' },
+    '#/basicTypes/Decimal': { type: 'number', format: 'double' },
+    '#/basicTypes/String': { type: 'string', format: '' },
+    '#/basicTypes/Text': { type: 'string', format: 'text' },
+    '#/basicTypes/Binary': { type: 'string', format: 'binary' },
+    '#/basicTypes/Date': { type: 'string', format: 'date' },
+    '#/basicTypes/Time': { type: 'string', format: 'time' },
+    '#/basicTypes/DateTime': { type: 'string', format: 'date-time' },
+    '#/basicTypes/Email': { type: 'string', format: 'email' },
+};
+
+export function getBasicTypeName(type: string, format: string) {
+    if (type === 'boolean')
+        return BASIC_TYPE.Boolean;
+    else if (type === 'integer' && format === 'long')
+        return BASIC_TYPE.Long;
+    else if (type === 'integer')
+        return BASIC_TYPE.Integer;
+    else if (type === 'number')
+        return BASIC_TYPE.Decimal;
+    else if (type === 'string' && format === 'text')
+        return BASIC_TYPE.Text;
+    else if (type === 'string' && format === 'binary')
+        return BASIC_TYPE.Binary;
+    else if (type === 'string' && format === 'date')
+        return BASIC_TYPE.Date;
+    else if (type === 'string' && format === 'time')
+        return BASIC_TYPE.Time;
+    else if (type === 'string' && format === 'date-time')
+        return BASIC_TYPE.DateTime;
+    else if (type === 'string' && format === 'email')
+        return BASIC_TYPE.Email;
+    else if (type === 'string')
+        return BASIC_TYPE.String;
+}
+
+export function getBasicTypeRef(type: string, format: string) {
+    return `#/basicTypes/${getBasicTypeName(type, format)}`;
+}
+
+export function getBasicTypeDefaultValue(value?: any): void {
+    return undefined;
+}

package/bak/dataTypeUtils.ts

@@ -0,0 +1,429 @@
+import { Schema } from '..';
+import { basicTypeMap, getBasicTypeRef } from './basicTypes';
+import { dataTypesMap } from './dataTypes';
+import { getGenericTypeRef } from './genericTypes';
+import { cloneDeep } from 'lodash';
+
+/**
+ * 会改变原来的结构，最好自己做深拷贝
+ * @param schema
+ * @param root
+ * @example RefType - 用于前端界面的类型描述
+ * {
+ *     asset: {
+ *         type: 'object',
+ *         properties: [
+ *             { name: 'id', $ref: '#/basicType/Long' },
+ *             { name: 'name', $ref: '#/basicType/String' },
+ *         ],
+ *     },
+ *     assetType: {
+ *         type: 'enum',
+ *         enumItems: [
+ *             { value: 'COMPUTER', label: '台式机' },
+ *             { value: 'TABLET', label: '平板电脑' },
+ *             { value: 'MOBILE', label: '移动电话' },
+ *         },
+ *     }，
+ *     assets: {
+ *         isArray: true,
+ *         $ref: '#/xxxx/entity/asset'
+ *     },
+ *     test: { $ref: '#/basicType/Date' }
+ * }
+ */
+export function convert2RefType(schema: Schema): Schema {
+    if (!schema)
+        return schema;
+    if (schema.type === 'object') {
+        if (schema.properties) {
+            schema.properties = Object.keys(schema.properties).map((name) => {
+                const property = schema.properties[name];
+                property.name = name;
+                return property;
+            });
+            delete schema.properties;
+        }
+        schema.properties = !schema.properties ? [] : schema.properties.map((property) => convert2RefType(property));
+    } else if (schema.type === 'enum') {
+        if (schema.enumItems) {
+            schema.enumItems = Object.keys(schema.enumItems).map((value) => ({
+                level: 'enumItem',
+                label: schema.enumItems[value],
+                value,
+            }));
+        }
+        delete schema.enumItems;
+    } else if (schema.type === 'array') {
+        schema.isArray = true;
+        // 转成泛型
+        const listSchema = dataTypesMap['#/genericTypes/List'];
+        if (listSchema) {
+            const genericSchema = {
+                type: 'genericType',
+                typeKey: '#/genericTypes/List',
+                typeInstantiation: {
+                    typeName: 'List',
+                    typeParams: (listSchema.typeParams || []).map((param: any) => {
+                        const tempParam = Object.assign({}, param);
+                        tempParam.typeParamValue = convert2RefType(schema.items);
+                        tempParam.type = 'typeParam';
+                        return tempParam;
+                    }),
+                },
+            };
+            delete schema.items;
+            Object.assign(schema, genericSchema);
+        }
+    } else if (schema.type === 'genericType') {
+        if (schema.typeInstantiation) {
+            schema.typeKey = getGenericTypeRef(schema.typeInstantiation.typeName);
+            schema.typeInstantiation.typeParams.forEach((typeParam) => {
+                typeParam.type = 'typeParam';
+                convert2RefType(typeParam.typeParamValue);
+            });
+        }
+    } else if (schema.type) {
+        schema.typeKey = getBasicTypeRef(schema.type, schema.format);
+    } else if (schema.$ref) {
+        if (schema.$ref.startsWith('#/basicTypes')) {
+            //兼容错误缓存情况
+            schema.typeKey = schema.$ref;
+            Object.assign(schema, dataTypesMap[schema.$ref]);
+            delete schema.$ref;
+        } else {
+            schema.typeKey = schema.$ref;
+            delete schema.type;
+            delete schema.format;
+        }
+    }
+    return schema;
+}
+
+/**
+ * 会改变原来的结构，最好自己做深拷贝
+ * @param schema
+ * @param root
+ * @example SchemaType - 非标准的 JSON Schema 结构
+ * {
+ *     asset: {
+ *         type: 'object',
+ *         properties: [
+ *             { type: 'int', format: 'long' },
+ *             { type: 'string' },
+ *         ],
+ *     },
+ *     assetType: {
+ *         type: 'enum',
+ *         enumItems: [
+ *             { value: 'COMPUTER', label: '台式机' },
+ *             { value: 'TABLET', label: '平板电脑' },
+ *             { value: 'MOBILE', label: '移动电话' },
+ *         },
+ *     }，
+ *     assets: {
+ *         isArray: true,
+ *         items: {
+ *             $ref: '#/xxxx/entity/asset'
+ *         }
+ *     },
+ *     test: { type: 'string', format: 'date' }
+ * }
+ */
+export function convert2SchemaType(schema: Schema, options: { enum?: string } = {}) {
+    if (!schema)
+        return schema;
+
+    if (schema.type === 'object') {
+        schema.properties && schema.properties.forEach((property) => convert2SchemaType(property));
+    } else if (schema.type === 'enum') {
+        //
+    } else if (schema.isArray) {
+        // 去除
+        //
+    } else if (schema.$ref) {
+        // 兼容老版本传$ref
+        if (!schema.$ref.startsWith('#/basicTypes/')) {
+            // 防止切换 type 时的污染
+            delete schema.type;
+            delete schema.format;
+            Object.assign(schema, { typeKey: schema.$ref });
+        } else {
+            Object.assign(schema, { typeKey: schema.$ref });
+            Object.assign(schema, basicTypeMap[schema.$ref]);
+            delete schema.$ref;
+        }
+    } else if (schema.typeKey) {
+        // 从s-datatype-select中选择类型后只传typeKey
+        if (schema.typeKey.startsWith('#/genericTypes')) {
+            if (!schema.typeInstantiation)
+                return schema;
+            schema = {
+                type: 'genericType',
+                typeKey: `#/genericTypes/${schema.typeInstantiation.typeName}`,
+                typeInstantiation: {
+                    typeName: schema.typeInstantiation.typeName,
+                    typeParams: schema.typeInstantiation.typeParams.map((typeParam: any) => {
+                        delete typeParam.tempColor;
+                        delete typeParam.tempText;
+                        typeParam.typeParamValue = convert2SchemaType(typeParam.typeParamValue);
+                        typeParam.type = 'typeParam';
+                        return typeParam;
+                    }),
+                },
+            };
+        } else if (!schema.typeKey.startsWith('#/basicTypes/')) {
+            // { $ref: '', typeKey: ''}
+            // 防止切换 type 时的污染
+            schema = { $ref: schema.typeKey, typeKey: schema.typeKey };
+        } else {
+            schema = Object.assign({ typeKey: schema.typeKey }, basicTypeMap[schema.typeKey]);
+        }
+    }
+    return schema;
+}
+
+/**
+ * 根据 Ref Schema 生成子节点
+ * @param schema
+ * @param code
+ * @param dataTypesMap
+ */
+export function genSchemaChildren(schema: Schema, code: string = '', usedSchemaRefs: { [name: string]: boolean } = {}): Array<any> {
+    const typeKey = schema.typeKey;
+    if (typeKey && usedSchemaRefs[typeKey])
+        return;
+    // 理论上可以继续往下选，但这里先断掉！
+
+    const next = dataTypesMap[typeKey];
+    usedSchemaRefs = Object.assign({}, usedSchemaRefs);
+    if (typeKey && !(typeKey.startsWith('#/basicTypes/') || typeKey.startsWith('#/genericTypes/')))
+        usedSchemaRefs[typeKey] = true;
+
+    if (schema.type === 'genericType') {
+        const children: Array<any> = [];
+        const genericClass = dataTypesMap[schema.typeKey];
+        if (genericClass) {
+            const properties = genericClass.properties;
+            properties.forEach((property: any) => {
+                let propertySchema = cloneDeep(property);
+                if (property.type === 'genericParam' && schema.typeInstantiation) {
+                    const param = schema.typeInstantiation.typeParams.find((typeParam: any) => typeParam.typeParamName === property.typeParamName);
+                    if (param) {
+                        propertySchema = Object.assign({ name: property.name }, param.typeParamValue);
+                    }
+                } else if (propertySchema.type === 'genericType' && schema.typeInstantiation) {
+                    if (propertySchema.typeInstantiation) {
+                        propertySchema.typeInstantiation.typeParams.forEach((typeParam: any) => {
+                            const param = schema.typeInstantiation.typeParams.find((typeParamTemp: any) => typeParamTemp.typeParamName === typeParam.typeParamName);
+                            if (param) {
+                                typeParam.typeParamValue = Object.assign({}, param.typeParamValue);
+                            }
+                        });
+                    }
+                }
+                const item: any = {
+                    level: 'property',
+                    name: propertySchema.name,
+                    schema: propertySchema,
+                    code: property.id ? `${code}.ID_${property.id}` : `${code}.${property.name}`,
+                };
+                if (schema.typeName === '#/genericTypes/List') {
+                    item.arrayLength = true;
+                }
+                item.children = genRefSchemaChildren(item.schema, item.code, usedSchemaRefs);
+                item.isLeaf = !item.children;
+                children.push(item);
+            });
+        }
+        return children;
+    } else if (schema.type === 'object') {
+        const children: Array<any> = [];
+        schema.properties
+            && schema.properties.forEach((property: Schema) => {
+                const item: any = {
+                    level: 'property',
+                    name: property.name,
+                    schema: property,
+                    code: code + '.' + (property.id ? 'ID_' + property.id : property.name),
+                };
+
+                item.children = genSchemaChildren(item.schema, item.code, usedSchemaRefs);
+                item.isLeaf = !item.children;
+                children.push(item);
+            });
+        return children;
+    } else if (schema.isArray) {
+        //
+    } else if (typeKey && typeKey.startsWith('#/basicTypes')) {
+        return undefined;
+    } else if (next) {
+        return genSchemaChildren(next, code, usedSchemaRefs);
+    }
+}
+
+/**
+ * 根据 Ref Schema 生成子节点
+ * @param schema
+ * @param code
+ */
+export function genRefSchemaChildren(schema: Schema, code: string, usedSchemaRefs: { [name: string]: boolean } = {}): Array<any> {
+    if (!schema)
+        return;
+    const typeKey = schema.typeKey;
+    if (typeKey && usedSchemaRefs[typeKey])
+        return;
+    // 理论上可以继续往下选，但这里先断掉！
+
+    const next = dataTypesMap[typeKey];
+    usedSchemaRefs = Object.assign({}, usedSchemaRefs);
+    if (typeKey && !(typeKey.startsWith('#/basicTypes/') || typeKey.startsWith('#/genericTypes/')))
+        usedSchemaRefs[typeKey] = true;
+
+    if (schema.type === 'genericType') {
+        const children: Array<any> = [];
+        const genericClass = dataTypesMap[schema.typeKey];
+        if (genericClass) {
+            const properties = genericClass.properties;
+            properties.forEach((property: any) => {
+                let propertySchema = cloneDeep(property);
+                if (property.type === 'genericParam' && schema.typeInstantiation) {
+                    const param = schema.typeInstantiation.typeParams.find((typeParam: any) => typeParam.typeParamName === property.typeParamName);
+                    if (param) {
+                        propertySchema = Object.assign({ name: property.name }, param.typeParamValue);
+                    }
+                } else if (propertySchema.type === 'genericType' && schema.typeInstantiation) {
+                    if (propertySchema.typeInstantiation) {
+                        propertySchema.typeInstantiation.typeParams.forEach((typeParam: any) => {
+                            const param = schema.typeInstantiation.typeParams.find((typeParamTemp: any) => typeParamTemp.typeParamName === typeParam.typeParamName);
+                            if (param) {
+                                typeParam.typeParamValue = Object.assign({}, param.typeParamValue);
+                            }
+                        });
+                    }
+                }
+                const item: any = {
+                    level: 'refProperty',
+                    schema: propertySchema,
+                    code: property.id ? `${code}.ID_${property.id}` : `${code}.${property.name}`,
+                };
+                if (schema.typeKey === '#/genericTypes/List') {
+                    item.arrayLength = true;
+                }
+                item.children = genRefSchemaChildren(item.schema, item.code, usedSchemaRefs);
+                item.isLeaf = !item.children;
+                children.push(item);
+            });
+        }
+        return children;
+    } else if (schema.type === 'object') {
+        const children: Array<any> = [];
+        schema.properties
+            && schema.properties.forEach((property: Schema) => {
+                const item: any = {
+                    level: 'refProperty',
+                    schema: property,
+                    code: property.id ? `${code}.ID_${property.id}` : `${code}.${property.name}`,
+                };
+
+                item.children = genRefSchemaChildren(item.schema, item.code, usedSchemaRefs);
+                item.isLeaf = !item.children;
+                children.push(item);
+            });
+        return children;
+    } else if (schema.isArray) {
+        //
+    } else if (typeKey && typeKey.startsWith('#/basicTypes')) {
+        return undefined;
+    } else if (next) {
+        return genRefSchemaChildren(next, code, usedSchemaRefs);
+    }
+}
+
+/**
+ * 根据 Ref Schema 生成子节点
+ * @param schema
+ * @param code
+ */
+export function genFullRefSchemaChildren(schema: Schema, code: string, usedSchemaRefs: { [name: string]: boolean } = {}): Array<any> {
+    if (!schema)
+        return;
+
+    const typeKey = schema.typeKey;
+    if (typeKey && usedSchemaRefs[typeKey])
+        return;
+    // 理论上可以继续往下选，但这里先断掉！
+
+    const next = dataTypesMap[typeKey];
+    usedSchemaRefs = Object.assign({}, usedSchemaRefs);
+    if (typeKey && !(typeKey.startsWith('#/basicTypes/') || typeKey.startsWith('#/genericTypes/')))
+        usedSchemaRefs[typeKey] = true;
+
+    if (schema.type === 'genericType') {
+        let children: Array<any> = [];
+        if (schema.typeKey === '#/genericTypes/List') {
+            children = genRefSchemaChildren(schema.typeInstantiation.typeParams[0].typeParamValue, code, usedSchemaRefs);
+        } else {
+            const genericClass = dataTypesMap[schema.typeKey];
+            if (genericClass) {
+                const properties = genericClass.properties;
+                properties.forEach((property: any) => {
+                    let propertySchema = cloneDeep(property);
+                    if (property.type === 'genericParam' && schema.typeInstantiation) {
+                        const param = schema.typeInstantiation.typeParams.find((typeParam: any) => typeParam.typeParamName === property.typeParamName);
+                        if (param) {
+                            propertySchema = Object.assign({ name: property.name }, param.typeParamValue);
+                        }
+                    } else if (propertySchema.type === 'genericType' && schema.typeInstantiation) {
+                        if (propertySchema.typeInstantiation) {
+                            propertySchema.typeInstantiation.typeParams.forEach((typeParam: any) => {
+                                const param = schema.typeInstantiation.typeParams.find((typeParamTemp: any) => typeParamTemp.typeParamName === typeParam.typeParamName);
+                                if (param) {
+                                    typeParam.typeParamValue = Object.assign({}, param.typeParamValue);
+                                }
+                            });
+                        }
+                    }
+                    const item: any = {
+                        level: 'refProperty',
+                        schema: propertySchema,
+                        code: property.id ? `${code}.ID_${property.id}` : `${code}.${property.name}`,
+                    };
+                    item.children = genRefSchemaChildren(item.schema, item.code, usedSchemaRefs);
+                    item.isLeaf = !item.children;
+                    children.push(item);
+                });
+            }
+        }
+
+        return children;
+    } else if (schema.type === 'object') {
+        const children: Array<any> = [];
+        schema.properties
+            && schema.properties.forEach((property: Schema) => {
+                const item: any = {
+                    level: 'refProperty',
+                    schema: property,
+                    code: `${code}.ID_${property.id}`,
+                };
+
+                item.children = genFullRefSchemaChildren(item.schema, item.code, usedSchemaRefs);
+                item.isLeaf = !item.children;
+                children.push(item);
+            });
+        return children;
+    } else if (schema.isArray) {
+        //
+    } else if (typeKey && typeKey.startsWith('#/basicTypes')) {
+        return undefined;
+    } else if (next) {
+        return genFullRefSchemaChildren(next, code, usedSchemaRefs);
+    }
+}
+
+/**
+ * 统一在 lcap-pc-template 中处理
+ */
+export function genInitData(schema: Schema, relationship = 'None', usedSchemaRefs: { [name: string]: boolean } = {}): any {
+    throw new Error('统一在 lcap-pc-template 中处理！');
+}