@cloudbase/cals 1.1.14 → 1.2.1

package/lib/esm/utils/dts/index.js

@@ -0,0 +1,1071 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import cloneDeep from 'lodash/cloneDeep';
+import pick from 'lodash/pick';
+import set from 'lodash/set';
+import JSONEasyFilter from 'json-easy-filter';
+import { wedaDTS } from './auto-generated';
+export var IInputDataType;
+(function (IInputDataType) {
+    IInputDataType["globalState"] = "globalState";
+    IInputDataType["globalQuery"] = "globalQuery";
+    IInputDataType["pageState"] = "pageState";
+    IInputDataType["pageQuery"] = "pageQuery";
+    IInputDataType["compState"] = "compState";
+    IInputDataType["pageParams"] = "pageParams";
+    IInputDataType["pageEventFlow"] = "pageEventFlow";
+    IInputDataType["forState"] = "forState";
+    IInputDataType["globalCommonCodes"] = "globalCommonCodes";
+    IInputDataType["pageHandlerCodes"] = "pageHandlerCodes";
+    IInputDataType["compHandlerCodes"] = "compHandlerCodes";
+    IInputDataType["compPropData"] = "compPropData";
+    IInputDataType["compPropEvents"] = "compPropEvents";
+    IInputDataType["usedComponents"] = "usedComponents";
+    IInputDataType["usedWidgets"] = "usedWidgets";
+    IInputDataType["repeaterScope"] = "repeaterScope";
+    IInputDataType["redefineAnyType"] = "redefineAnyType";
+    IInputDataType["serverSideSate"] = "serverSideSate";
+    IInputDataType["dtsString"] = "dtsString";
+})(IInputDataType || (IInputDataType = {}));
+const DtsPlaceholder = {
+    [IInputDataType.globalState]: "// Global State 全局变量 - Don't touch me",
+    [IInputDataType.globalQuery]: "// Global Query 全局查询 - Don't touch me",
+    [IInputDataType.pageState]: "// Page State 页面变量 - Don't touch me",
+    [IInputDataType.pageQuery]: "// Page Query 页面查询 - Don't touch me",
+    [IInputDataType.pageEventFlow]: "// EventFlow 事件流 - Don't touch me",
+    [IInputDataType.compState]: "// Comp State 组件变量 - Don't touch me",
+    [IInputDataType.pageParams]: "// Page Param 页面参数 - Don't touch me",
+    [IInputDataType.forState]: "// For 循环变量 - Don't touch me",
+    [IInputDataType.globalCommonCodes]: "// Global Common 全局方法 - Don't touch me",
+    [IInputDataType.pageHandlerCodes]: "// Page Handler 页面方法 - Don't touch me",
+    [IInputDataType.compHandlerCodes]: "// Comp Handler 组件方法 - Don't touch me",
+    [IInputDataType.compPropData]: "// Comp Prop Data 组件属性 - Don't touch me",
+    [IInputDataType.compPropEvents]: "// Comp Prop Events 组件事件 - Don't touch me",
+    [IInputDataType.usedComponents]: "// Used Components - Don't touch me",
+    [IInputDataType.usedWidgets]: "// used widgets - Don't touch me",
+    [IInputDataType.repeaterScope]: "// repeater scope - Don't touch me",
+    [IInputDataType.redefineAnyType]: "// Redefine Any Type - Don't touch me",
+    [IInputDataType.serverSideSate]: "// Server side state - Don't touch me",
+    [IInputDataType.dtsString]: "// DTS String - Don't touch me",
+};
+const DtsInnerSign = {
+    [IInputDataType.globalState]: 'Global State Inner',
+    [IInputDataType.globalQuery]: 'Global Query Inner',
+    [IInputDataType.pageState]: 'Page State Inner',
+    [IInputDataType.pageQuery]: 'Page Query Inner',
+    [IInputDataType.pageEventFlow]: 'Page EventFlow Inner',
+    [IInputDataType.compState]: 'Comp State Inner',
+    [IInputDataType.pageParams]: 'Page Param Inner',
+    [IInputDataType.forState]: 'Global For Inner',
+    [IInputDataType.globalCommonCodes]: 'Global Common Inner',
+    [IInputDataType.pageHandlerCodes]: 'Page Handler Inner',
+    [IInputDataType.compHandlerCodes]: 'Comp Handler Inner',
+    [IInputDataType.compPropData]: 'Comp Prop Data Inner',
+    [IInputDataType.compPropEvents]: 'Comp Prop Events Inner',
+    [IInputDataType.usedComponents]: 'Used Components Inner',
+    [IInputDataType.usedWidgets]: 'used widgets Inner',
+    [IInputDataType.repeaterScope]: 'repeater scope Inner',
+    [IInputDataType.redefineAnyType]: 'Redefine Any Type Inner',
+    [IInputDataType.serverSideSate]: 'Server side state Inner',
+    [IInputDataType.dtsString]: 'DTS String Inner',
+};
+var GroupEnum;
+(function (GroupEnum) {
+    GroupEnum["GLOBAL_VAR"] = "globalVar";
+    GroupEnum["PAGE_VAR"] = "pageVar";
+    GroupEnum["GLOBAL_QUERY"] = "globalQuery";
+    GroupEnum["PAGE_QUERY"] = "pageQuery";
+    GroupEnum["PAGE_EVENTFLOW"] = "pageEventFlow";
+    GroupEnum["PAGE_PARAM"] = "pageParam";
+    GroupEnum["COMPONENT"] = "component";
+    GroupEnum["REPEATER"] = "repeater";
+    GroupEnum["DATA_FIELD"] = "dataField";
+})(GroupEnum || (GroupEnum = {}));
+/**
+ * 通过该类可以共享同个dts。
+ * 场景：在 weda 中，低代码的变更会通知更改 dts，而低码编辑器和表达式编辑器对 dts 的需求是不一样的，这样不同的 dts 共享的是同一份全的 dts。如果直接调用 generateWeDaAppDTS 会导致 dts 重复地解析
+ */
+export class WeDaDTS {
+    /**
+     * 全部更新
+     */
+    static updateDTS(inputData = {}, options = { isCompMode: false }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            WeDaDTS._dts = yield generateWeDaAppDTS(inputData, Object.assign(Object.assign({}, options), { needGlobalFormula: true, needGlobalFor: true }));
+        });
+    }
+    /**
+     * 部分更新 - 只更新一种类型
+     */
+    static updateDTSPartial(inputData, itemType, options = { setEmptyIfError: false }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const [dts, replaceRules] = yield _generateOneItemDTS(inputData, itemType);
+                replaceRules.forEach((rule) => {
+                    WeDaDTS._dts = WeDaDTS._dts.replace(rule.from, rule.to);
+                });
+                WeDaDTS._dts = WeDaDTS._dts.replace(new RegExp(`^(\\s*\\/\\/ ${DtsInnerSign[itemType]} Begin)[\\s\\S]*(^\\s*\\/\\/ ${DtsInnerSign[itemType]} End)`, 'm'), `$1\n${dts}\n$2`);
+            }
+            catch (e) {
+                if (options.setEmptyIfError) {
+                    WeDaDTS._dts = WeDaDTS._dts.replace(new RegExp(`^(\\s*\\/\\/ ${DtsInnerSign[itemType]} Begin)[\\s\\S]*(^\\s*\\/\\/ ${DtsInnerSign[itemType]} End)`, 'm'), `$1\n${''}\n$2`);
+                }
+            }
+        });
+    }
+    static getDTS(options = {
+        needGlobalFormula: false,
+        needGlobalFor: false,
+        scope: 'component',
+    }) {
+        let resultDts = WeDaDTS._dts;
+        let regexArray = [];
+        const { scope = 'component' } = options;
+        if (!options.needGlobalFormula) {
+            resultDts = resultDts.replace(/^\/\/ Global Formula Begin[\s\S]*^\/\/ Global Formula End$/m, '');
+        }
+        if (!options.needGlobalFor) {
+            resultDts = resultDts.replace(/^\/\/ Global For Begin[\s\S]*^\/\/ Global For End$/m, '');
+        }
+        switch (scope) {
+            case 'component':
+                break;
+            case 'page':
+                regexArray = [
+                    // 屏蔽组件级别 - 循环作用域
+                    /\/\/ repeater scope Inner Begin[\s\S]*\/\/ repeater scope Inner End$/m,
+                ];
+                break;
+            case 'global':
+                regexArray = [
+                    // 屏蔽 $page
+                    /\/\/ \$page Begin[\s\S]*\/\/ \$page End$/m,
+                    // 屏蔽 $w.page
+                    /\/\/ Widget Page Begin[\s\S]*\/\/ Widget Page End$/m,
+                    // 屏蔽页面 page query
+                    /\/\/ Page Query Inner Begin[\s\S]*\/\/ Page Query Inner End$/m,
+                    // 屏蔽页面事件流
+                    /\/\/ Page EventFlow Inner Begin[\s\S]*\/\/ Page EventFlow Inner End$/m,
+                    // 屏蔽组件 api
+                    /\/\/ used widgets Inner Begin[\s\S]*\/\/ used widgets Inner End$/m,
+                    // 屏蔽页面参数
+                    /\/\/ Page Param Inner Begin[\s\S]*\/\/ Page Param Inner Begind$/m,
+                    // 屏蔽组件级别 - 循环作用域
+                    /\/\/ repeater scope Inner Begin[\s\S]*\/\/ repeater scope Inner End$/m,
+                ];
+                break;
+        }
+        resultDts = regexArray.reduce((acc, regex) => acc.replace(regex, ''), resultDts);
+        return resultDts;
+    }
+}
+WeDaDTS._dts = '';
+/**
+ * 生成 WeDa 应用的低码代码提示的 dts 类型声明内容
+ */
+export function generateWeDaAppDTS(inputData = {}, options = { isCompMode: false, needGlobalFormula: false, needGlobalFor: false }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let resultDts = wedaDTS;
+        yield Promise.all(Object.keys(inputData).map((key) => __awaiter(this, void 0, void 0, function* () {
+            const placeholder = DtsPlaceholder[key];
+            if (placeholder) {
+                // 防止某项错误导致全部都错误
+                try {
+                    const [dts, replaceRules] = yield _generateOneItemDTS(inputData[key], key);
+                    replaceRules.forEach((rule) => {
+                        resultDts = resultDts.replace(rule.from, rule.to);
+                    });
+                    resultDts = resultDts.replace(placeholder, `${dts}\n${placeholder}`);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        })));
+        // 根据是否组件模式删除一些类型定义
+        if (options === null || options === void 0 ? void 0 : options.isCompMode) {
+            resultDts = resultDts.replace(/^\/\/ \$page Begin[\s\S]*^\/\/ \$page End$/m, '');
+        }
+        else {
+            resultDts = resultDts.replace(/^\/\/ \$comp Begin[\s\S]*^\/\/ \$comp End$/m, '');
+        }
+        // 根据是否需要全局提示函数公式删除一些类型定义
+        if (!(options === null || options === void 0 ? void 0 : options.needGlobalFormula)) {
+            resultDts = resultDts.replace(/^\/\/ Global Formula Begin[\s\S]*^\/\/ Global Formula End$/m, '');
+        }
+        // 根据是否需要全局 $for 来删除一些类型定义
+        if (!(options === null || options === void 0 ? void 0 : options.needGlobalFor)) {
+            resultDts = resultDts.replace(/^\/\/ Global For Begin[\s\S]*^\/\/ Global For End$/m, '');
+        }
+        return resultDts;
+    });
+}
+/**
+ * 生成 weda 专有的注释信息
+ */
+function genWeDaCodeComment({ fieldName, title, description, type, dataFieldInfo, group, schema, subGroup, baseClass, datasource, }) {
+    const desc = title || fieldName ? `${title || fieldName}\n${description || ''}` : '';
+    return `${desc}\n@privateForWeDa\n${JSON.stringify({
+        group,
+        displayType: type,
+        displayName: title || '',
+        description: description || '',
+        schema,
+        subGroup,
+        baseClass,
+        datasource,
+        dataFieldInfo,
+    })}`;
+}
+/**
+ * 生成指定类型的 DTS
+ */
+function _generateOneItemDTS(inputData, itemType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const replaceRules = [];
+        /**
+         * 获取数据字段的类型
+         */
+        function getDataFieldDisplayType(format) {
+            const nameMap = {
+                email: 'email',
+                url: 'url',
+                tel: 'tel',
+                phone: 'phone',
+                'x-image': 'image',
+                'x-rtf': 'rtf',
+                datetime: 'datetime',
+                date: 'date',
+                time: 'time',
+                'x-enum': 'enum',
+                'x-location': 'location',
+                'x-file': 'file',
+                related: 'related',
+                'father-son': 'father-son',
+                'x-autonumber': 'autonumber',
+                'x-area-code': 'area-code',
+                function: 'function',
+                'one-one': 'one-one',
+                'one-many': 'one-many',
+                'many-one': 'many-one',
+                'many-many': 'many-many',
+            };
+            return nameMap[format];
+        }
+        /**
+         * 处理注释信息
+         */
+        function _handleComment(inputData, group, needKeepSchema) {
+            const _inputData = cloneDeep(inputData);
+            JSONEasyFilter.traverse(_inputData, (key, value, path) => {
+                var _a;
+                if ((value === null || value === void 0 ? void 0 : value.type) && !((_a = value === null || value === void 0 ? void 0 : value.type) === null || _a === void 0 ? void 0 : _a.type)) {
+                    // value?.type?.type 有值，则证明 type 是自定义的字段，而非 JSONSchema 中的 type
+                    let schema = null;
+                    if (needKeepSchema) {
+                        const isFirstLevel = path.length === 2 && (path === null || path === void 0 ? void 0 : path[0]) === 'properties';
+                        if (isFirstLevel) {
+                            // 只需要第一级属性需要保存，且只保存子信息（对象或数组的子项）
+                            schema = value.properties || value.items ? value : null;
+                        }
+                    }
+                    // 特殊处理数据字段的类型
+                    let { type } = value;
+                    if (group === GroupEnum.DATA_FIELD) {
+                        type = getDataFieldDisplayType(value.format) || type;
+                    }
+                    value.description = genWeDaCodeComment({
+                        fieldName: key,
+                        title: value.title,
+                        description: value.description,
+                        group,
+                        type,
+                        dataFieldInfo: pick(value, ['type', 'format', 'x-system']),
+                        schema,
+                    });
+                }
+            });
+            _inputData.description = ''; // 避免第一层出现注释
+            return _inputData;
+        }
+        /**
+         * 获取用于显示的数据类型（仅有 number, string , boolean, array, object 等内置基础类型）
+         */
+        function getDisplayReturnType(typeStr) {
+            var _a, _b;
+            let displayType = typeStr.trim();
+            if ((_a = displayType === null || displayType === void 0 ? void 0 : displayType.endsWith) === null || _a === void 0 ? void 0 : _a.call(displayType, '[]')) {
+                displayType = 'array';
+            }
+            else if ((_b = displayType === null || displayType === void 0 ? void 0 : displayType.endsWith) === null || _b === void 0 ? void 0 : _b.call(displayType, '}')) {
+                displayType = 'object';
+            }
+            return displayType;
+        }
+        /**
+         * 获取组件接口定义名称
+         */
+        function _genCompInterfaceName(module, component) {
+            return `${module.replace(/-/g, '_')}_${component}`;
+        }
+        function _compile(jsonschema, isObjNeedWrapper = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    let dts = yield compileJSONToDTS(jsonschema);
+                    if (dts.search(/^export interface IWeDa/) >= 0) {
+                        dts = dts.replace(/^export interface.*$/m, '');
+                        dts = dts.substring(0, dts.length - 2);
+                        if (isObjNeedWrapper) {
+                            dts = `{${dts}}`;
+                        }
+                    }
+                    else {
+                        dts = dts.replace(/^export type IWeDa =/m, '');
+                    }
+                    return dts;
+                }
+                catch (e) {
+                    console.error('_compile error:', e);
+                    return '';
+                }
+            });
+        }
+        function handleQuery(inputData, group) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const dts = yield Promise.all(Object.keys(inputData === null || inputData === void 0 ? void 0 : inputData.properties).map((queryName) => __awaiter(this, void 0, void 0, function* () {
+                    const description = inputData === null || inputData === void 0 ? void 0 : inputData.properties[queryName].description;
+                    inputData === null || inputData === void 0 ? true : delete inputData.properties[queryName].description;
+                    const handledInputData = _handleComment(inputData === null || inputData === void 0 ? void 0 : inputData.properties[queryName], group, false);
+                    const _dts = yield _compile(handledInputData, true);
+                    return `
+        /**
+         ${genWeDaCodeComment({
+                        fieldName: queryName,
+                        title: queryName,
+                        description,
+                        group,
+                        type: 'query',
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                isFetching: {
+                                    type: 'boolean',
+                                    title: '加载状态',
+                                },
+                                error: {
+                                    type: 'object',
+                                    title: '错误对象',
+                                    properties: {},
+                                },
+                                data: Object.assign(Object.assign({}, inputData === null || inputData === void 0 ? void 0 : inputData.properties[queryName]), { title: '查询结果数据' }),
+                            },
+                        },
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+         */
+        const ${queryName}: {
+          /**
+           ${genWeDaCodeComment({
+                        type: 'function',
+                        title: '触发查询',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          trigger: (data?: any) => {}
+          /**
+           ${genWeDaCodeComment({
+                        type: 'function',
+                        title: '清空查询数据',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          reset: () => {}
+          /**
+           ${genWeDaCodeComment({
+                        type: 'object',
+                        title: '错误对象',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          error: Error
+          /**
+           ${genWeDaCodeComment({
+                        type: 'object',
+                        title: '查询结果数据',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          data: ${_dts}
+          /**
+           ${genWeDaCodeComment({
+                        type: 'boolean',
+                        title: '加载状态',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          isFetching: boolean
+          /**
+           ${genWeDaCodeComment({
+                        type: 'string',
+                        title: 'ID',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          id: string
+          /**
+           ${genWeDaCodeComment({
+                        type: 'string',
+                        title: '名称',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          label: string
+          /**
+           ${genWeDaCodeComment({
+                        type: 'string',
+                        title: '详细描述',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          description: string
+        }
+        `;
+                })));
+                return dts.join('\n');
+            });
+        }
+        function handlerEventFlow(inputData, group) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const dts = yield Promise.all(Object.keys(inputData === null || inputData === void 0 ? void 0 : inputData.properties).map((id) => __awaiter(this, void 0, void 0, function* () {
+                    return `
+        /**
+         ${genWeDaCodeComment({
+                        fieldName: id,
+                        title: id,
+                        description: inputData === null || inputData === void 0 ? void 0 : inputData.properties[id].description,
+                        group,
+                        type: 'eventFlow',
+                        schema: {
+                            type: 'object',
+                            properties: {},
+                        },
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+         */
+        const ${id}: {
+          /**
+           ${genWeDaCodeComment({
+                        type: 'function',
+                        title: '触发事件流',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          trigger: (data?: any) => {}
+          /**
+           ${genWeDaCodeComment({
+                        type: 'string',
+                        title: 'ID',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          id: string
+          /**
+           ${genWeDaCodeComment({
+                        type: 'string',
+                        title: '详细描述',
+                    })
+                        .split('\n')
+                        .map((item) => `* ${item}`)
+                        .join('\n')}
+           */
+          description: string
+        }
+        `;
+                })));
+                return dts.join('\n');
+            });
+        }
+        const hanlderMap = {
+            [IInputDataType.globalState](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    // 完善注释信息
+                    const handledInputData = _handleComment(inputData, GroupEnum.GLOBAL_VAR, true);
+                    return yield _compile(handledInputData);
+                });
+            },
+            [IInputDataType.globalQuery](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return handleQuery(inputData, GroupEnum.GLOBAL_QUERY);
+                });
+            },
+            [IInputDataType.pageState](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    // 完善注释信息
+                    const handledInputData = _handleComment(inputData, GroupEnum.PAGE_VAR, true);
+                    return yield _compile(handledInputData);
+                });
+            },
+            [IInputDataType.pageQuery](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return handleQuery(inputData, GroupEnum.PAGE_QUERY);
+                });
+            },
+            [IInputDataType.pageEventFlow]: (inputData) => __awaiter(this, void 0, void 0, function* () {
+                return handlerEventFlow(inputData, GroupEnum.PAGE_EVENTFLOW);
+            }),
+            [IInputDataType.pageParams](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    // 完善注释信息
+                    const handledInputData = _handleComment(inputData, GroupEnum.PAGE_PARAM);
+                    return yield _compile(handledInputData);
+                });
+            },
+            [IInputDataType.globalCommonCodes](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const dts = yield Promise.all(inputData.map((item) => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        const code = item.code.replace(/^\s*export(?!\s+default\b)/gm, ''); // 将 export 去掉，因为 common 代码当前只认 export default
+                        let dts = yield transpileToDTS(code);
+                        let resultDts = '';
+                        if (dts.search(/^\s*export default function/m) >= 0) {
+                            // 类似 export default function (): number; 或 export default function fnName(): number;
+                            resultDts = dts.replace(/^\s*export default/m, '').replace(/(function )(.*?)(\()/, `$1${item.name}$3`);
+                        }
+                        else {
+                            // 类似
+                            // declare function fnName(): boolean;
+                            // export default fnName;
+                            const exportName = (_a = dts.match(/export default (.*?);/)) === null || _a === void 0 ? void 0 : _a[1];
+                            resultDts = dts
+                                .replace(exportName, item.name)
+                                .replace(/^\s*export default.*/m, '')
+                                .replace(/^\s*declare/m, '');
+                        }
+                        return resultDts;
+                    })));
+                    return dts.join('\n');
+                });
+            },
+            [IInputDataType.pageHandlerCodes](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const IParams = `{
+        data?: {
+            target?: {
+                [key: string]: any
+            }
+        },
+        event?: {
+          target?: EventTarget
+          currentTarget?: EventTarget
+          detail?: {
+            detail?: {
+              [key: string]: any
+            }
+          }
+        }
+        forItems?: {
+            [key: string]: any
+        }
+    }`;
+                    const dts = yield Promise.all(inputData.map((item) => __awaiter(this, void 0, void 0, function* () {
+                        const dts = yield transpileToDTS(item.code);
+                        // 将 export default function() 替换成类似 export function onClick
+                        return dts.replace(/default function\s*\([\s\S]*?\)/, `function ${item.name} (params: ${IParams})`);
+                    })));
+                    return dts.join('\n');
+                });
+            },
+            [IInputDataType.compHandlerCodes](inputData) {
+                return this.pageHandlerCodes(inputData);
+            },
+            [IInputDataType.compPropEvents](inputData) {
+                const IData = `any`;
+                return inputData
+                    .map((eventName) => {
+                    return `function ${eventName}(data?: ${IData}): void`;
+                })
+                    .join('\n');
+            },
+            [IInputDataType.usedComponents](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    // 组件系统属性（在 framework/weda-framework.d.ts 的 UserWidget 中筛选一部分）
+                    const commonProperties = {
+                        id: {
+                            type: 'string',
+                            title: '组件 ID',
+                            describe: '组件 ID，微搭中一般由编辑器生成',
+                        },
+                        module: {
+                            type: 'string',
+                            title: '组件库名',
+                        },
+                        component: {
+                            type: 'string',
+                            title: '组件名',
+                        },
+                    };
+                    const results = yield Promise.all(inputData.map((item) => __awaiter(this, void 0, void 0, function* () {
+                        // 属性
+                        let exportPropertiesDTS = '';
+                        if (item.exportProperties) {
+                            const handledProperties = _handleComment(item.exportProperties);
+                            exportPropertiesDTS = yield _compile(handledProperties);
+                        }
+                        // 方法
+                        let exportMethodsDTS = '';
+                        if (item.exportMethods) {
+                            const results = yield Promise.all(item.exportMethods.map((item) => __awaiter(this, void 0, void 0, function* () {
+                                let inputDTS = '';
+                                let inputDTSCompatible = '';
+                                if (item.input) {
+                                    inputDTS = yield _compile(item.input, true);
+                                    if (item.input.properties) {
+                                        inputDTSCompatible = yield _compile(item.input);
+                                    }
+                                }
+                                let outputDTS = 'void';
+                                if (item.output) {
+                                    outputDTS = yield _compile(item.output, true);
+                                }
+                                // 第一个版本是兼容版本，是将 input.properties 的字段展开当多个参数
+                                // 第二个版本是直接将 input 当参数，所以只能有一个入参
+                                return `
+                  /**
+                   *
+                   */
+                  ${item.name} (${inputDTS ? `param: ${inputDTS.trim()}` : ''}): ${outputDTS}
+                  ${inputDTSCompatible
+                                    ? `
+                    /**
+                     *
+                     */
+                    ${item.name} (${inputDTSCompatible.trim().replace(/\n/g, ',')}): ${outputDTS}
+                    `
+                                    : ''}
+                  `;
+                            })));
+                            exportMethodsDTS = results.join('\n');
+                        }
+                        // FIXME: 等确定要对外暴露 UserWidge 所有定义时
+                        // return `
+                        // declare class ${_genCompInterfaceName(item.module, item.component)} extends UserWidget {
+                        //   get custom(): {
+                        //     ${exportPropertiesDTS}
+                        //     ${exportMethodsDTS}
+                        //   };
+                        //   ${exportPropertiesDTS}
+                        //   ${exportMethodsDTS}
+                        // }
+                        // `
+                        const interfaceName = _genCompInterfaceName(item.module, item.component);
+                        if (!item.exportProperties) {
+                            item.exportProperties = {
+                                type: 'object',
+                                properties: {},
+                            };
+                        }
+                        item.exportProperties.properties = Object.assign({}, commonProperties, item.exportProperties.properties);
+                        return `
+        /**
+        ${genWeDaCodeComment({
+                            fieldName: interfaceName,
+                            schema: item.exportProperties,
+                        })
+                            .split('\n')
+                            .map((item) => `* ${item}`)
+                            .join('\n')}
+        */
+        declare class ${interfaceName} extends UserWidget {
+
+          ${exportPropertiesDTS}
+
+          ${exportMethodsDTS}
+        }
+        `;
+                    })));
+                    return results.join('\n');
+                });
+            },
+            [IInputDataType.usedWidgets](inputData) {
+                return inputData
+                    .map((item) => {
+                    if (item.idList && item.idList.length > 0) {
+                        const interfaceName = _genCompInterfaceName(item.module, item.component);
+                        return item.idList
+                            .map((id) => `
+          /**
+          ${genWeDaCodeComment({
+                            fieldName: id,
+                            title: '',
+                            description: '',
+                            group: GroupEnum.COMPONENT,
+                            type: 'component',
+                            baseClass: interfaceName,
+                            datasource: `$${id}_start$ $${id}_end$`,
+                        })
+                            .split('\n')
+                            .map((item) => `* ${item}`)
+                            .join('\n')}
+           */
+          const ${id}: ${interfaceName}`)
+                            .join('\n');
+                    }
+                    return '';
+                })
+                    .join('\n');
+            },
+            [IInputDataType.repeaterScope](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const results = yield Promise.all(inputData.map((item) => __awaiter(this, void 0, void 0, function* () {
+                        let itemDataDTS = '';
+                        if (item.itemData.title) {
+                            // 特殊场景：数据字段
+                            const handledInputData = _handleComment(item.itemData, GroupEnum.DATA_FIELD);
+                            itemDataDTS = yield _compile(handledInputData, true);
+                        }
+                        else {
+                            // 普通的循环项数据
+                            itemDataDTS = yield _compile(item.itemData, true);
+                        }
+                        return `
+        /**
+        ${genWeDaCodeComment({
+                            fieldName: item.currentItemAlias,
+                            title: '当前项值',
+                            description: '',
+                            group: GroupEnum.REPEATER,
+                            type: getDisplayReturnType(itemDataDTS),
+                            schema: item.itemData,
+                            subGroup: item.widgetId,
+                        })
+                            .split('\n')
+                            .map((item) => `* ${item}`)
+                            .join('\n')}
+        */
+        const ${item.currentItemAlias}: ${itemDataDTS}
+        /**
+        ${genWeDaCodeComment({
+                            fieldName: item.currentIndexAlias,
+                            title: '当前下标',
+                            description: '',
+                            group: GroupEnum.REPEATER,
+                            type: 'number',
+                            subGroup: item.widgetId,
+                        })
+                            .split('\n')
+                            .map((item) => `* ${item}`)
+                            .join('\n')}
+          */
+        const ${item.currentIndexAlias}: number
+        `;
+                    })));
+                    return results.join('\n');
+                });
+            },
+            [IInputDataType.redefineAnyType](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const results = yield Promise.all(inputData.map((item) => __awaiter(this, void 0, void 0, function* () {
+                        const compInterfaceName = _genCompInterfaceName(item.module, item.component);
+                        const widgetInterfaceName = `${item.widgetId}_${compInterfaceName}`;
+                        /**
+                         * 更新 widget 的类型名
+                         */
+                        replaceRules.push({
+                            from: new RegExp(`(const ${item.widgetId}): .*`),
+                            to: `$1: ${widgetInterfaceName}`,
+                        });
+                        /**
+                         * 增加类
+                         */
+                        const datasources = {};
+                        const propDefinitions = yield Promise.all(item.updateProps.map((prop) => __awaiter(this, void 0, void 0, function* () {
+                            const properties = _handleComment(prop.widgetPropTypeSchema, GroupEnum.DATA_FIELD);
+                            const widgetPropTypeDTS = yield _compile(Object.assign(Object.assign({}, prop.widgetPropTypeSchema), properties), true);
+                            // 同个数据源，有可能是数组类型，所以需要区分开
+                            const id = `${prop.datasource.name}_${prop.widgetPropTypeSchema.type}`;
+                            if (!datasources[id]) {
+                                datasources[id] = {
+                                    fields: [{ name: prop.widgetPropName, title: prop.widgetPropTitle }],
+                                    schema: prop.widgetPropTypeSchema,
+                                    name: prop.datasource.name,
+                                    title: prop.datasource.title,
+                                    id: prop.datasource.id,
+                                    type: prop.datasource.type,
+                                };
+                            }
+                            else {
+                                datasources[id].fields.push({ name: prop.widgetPropName, title: prop.widgetPropTitle });
+                            }
+                            // 是否是多层级字段，如 "a.b"
+                            // FIXME: 当前只支持 a.b 这种形式，不支持 a[].b
+                            const multiLevelField = prop.widgetPropName.includes('.');
+                            let multiLevelFields = [];
+                            let multiLevelFieldObj = {};
+                            let firstField = '';
+                            let othersFields = [];
+                            if (multiLevelField) {
+                                multiLevelFields = prop.widgetPropName.split('.');
+                                set(multiLevelFieldObj, prop.widgetPropName, '$$schema$$');
+                                const [_firstField, ..._othersFields] = multiLevelFields;
+                                firstField = _firstField;
+                                othersFields = _othersFields;
+                            }
+                            return `
+          /**
+           ${genWeDaCodeComment({
+                                fieldName: prop.widgetPropName,
+                                title: prop.widgetPropTypeSchema.title,
+                                description: prop.widgetPropTypeSchema.description,
+                                group: undefined,
+                                type: getDisplayReturnType(widgetPropTypeDTS),
+                            })
+                                .split('\n')
+                                .map((item) => `* ${item}`)
+                                .join('\n')}
+            */
+            ${multiLevelField
+                                ? `${firstField}: Omit<${compInterfaceName}['${firstField}'], '${othersFields.join('.')}'> & ${JSON.stringify(multiLevelFieldObj[firstField]).replace('"$$schema$$"', widgetPropTypeDTS)}`
+                                : `${prop.widgetPropName}: ${widgetPropTypeDTS}`}
+          `;
+                        })));
+                        /**
+                         *  更新数据源信息
+                         */
+                        const datasourceInfoList = Object.values(datasources);
+                        if (datasourceInfoList.length > 0) {
+                            replaceRules.push({
+                                from: new RegExp(`(\\$${item.widgetId}_start\\$).*(\\$${item.widgetId}_end\\$)`),
+                                // encodeURIComponent 是为了能正常 parse 成 JSON
+                                to: `$1${encodeURIComponent(JSON.stringify(datasourceInfoList))}$2`,
+                            });
+                        }
+                        return `
+        declare class ${widgetInterfaceName} extends ${compInterfaceName} {
+          ${propDefinitions.join('\n')}
+        }
+        `;
+                    })));
+                    return results.join('\n');
+                });
+            },
+            [IInputDataType.serverSideSate](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return inputData
+                        ? `/**
+         ${genWeDaCodeComment({
+                            type: 'string',
+                            title: '用户id',
+                        })
+                            .split('\n')
+                            .map((item) => `* ${item}`)
+                            .join('\n')}
+         */
+        const USERID: string`
+                        : '';
+                });
+            },
+            [IInputDataType.dtsString](inputData) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return inputData;
+                });
+            },
+        };
+        let dts = '';
+        if (!inputData)
+            return [dts, replaceRules];
+        const handler = hanlderMap[itemType];
+        // 优先判断是否有独立的处理逻辑
+        if (handler) {
+            dts = yield handler.call(hanlderMap, inputData);
+        }
+        dts = dts || (yield _compile(inputData));
+        return [dts, replaceRules];
+    });
+}
+// 仅仅为了与 unittest 共享，外部请不要使用
+export const workerCode = `
+importScripts('https://qbase.cdn-go.cn/lcap/lcap-resource-cdngo/-/release/_url/devtools/typescriptServices.min.js');
+importScripts('https://qbase.cdn-go.cn/lcap/lcap-resource-cdngo/-/release/_url/devtools/ts-lib.min.js');
+
+const files = {
+  "foo.ts": '',
+  "lib.d.ts": libFileMap['lib.es5.d.ts']
+};
+
+function createLanguageService() {
+  return ts.createLanguageService({
+      getCompilationSettings() {
+          return {};
+      },
+      getScriptFileNames() {
+          return ["foo.ts", "lib.d.ts"];
+      },
+      getScriptVersion(_fileName) {
+          // 这样可避免使用缓存
+          if (_fileName === 'foo.ts')
+              return 'v_' + Math.random();
+          return ''
+      },
+      getScriptSnapshot(fileName) {
+          if (fileName === ".ts") {
+              return ts.ScriptSnapshot.fromString("");
+          }
+          return ts.ScriptSnapshot.fromString(files[fileName] || "");
+      },
+      getCurrentDirectory: () => ".",
+      getDefaultLibFileName(options) {
+          return 'lib.d.ts'
+      },
+      fileExists: name => !!files[name],
+      readFile: name => {
+          return files[name]
+      }
+  });
+}
+const languageService = createLanguageService();
+
+function transpile(code) {
+  files["foo.ts"] = code
+  const result = languageService.getEmitOutput(
+      "foo.ts",
+      /*emitOnlyDtsFiles*/ true,
+      /*forceDtsEmit*/ true
+  )
+  return result.outputFiles[0].text.trim()
+}
+
+addEventListener('message', (message) => {
+    const {action, data: {id, code}} = message.data
+    switch(action) {
+        case 'dts':
+            const dts = transpile(code)
+            postMessage({action: 'dts_back', data: {id, dts}})
+            break
+        default:
+            break
+    }
+})
+`;
+function TypescriptWorker(workerId, workerCode) {
+    let typescriptWorkerMap = {};
+    return function getInstance() {
+        var _a;
+        let typescriptWorker = (_a = typescriptWorkerMap[workerId]) === null || _a === void 0 ? void 0 : _a.typescriptWorker;
+        if (!typescriptWorker) {
+            const sendMessageCallbackFn = {};
+            const workerURL = URL.createObjectURL(new Blob([workerCode]));
+            // 在 node 环境 unittest 时增加 name 参数用于辨别是哪个 worker
+            typescriptWorker = new Worker(workerURL + (workerURL.search('blob:http://localhost') === 0 ? `?name=${workerId}` : ''));
+            typescriptWorker.onmessage = function (event) {
+                var _a;
+                const { action } = event.data;
+                if (action === 'dts_back') {
+                    const { data: { id, dts }, } = event.data;
+                    (_a = sendMessageCallbackFn[id]) === null || _a === void 0 ? void 0 : _a.call(sendMessageCallbackFn, dts);
+                    delete sendMessageCallbackFn[id];
+                }
+            };
+            typescriptWorkerMap[workerId] = {
+                typescriptWorker,
+                sendMessageCallbackFn,
+            };
+        }
+        function sendMessage(msgData, callbackFn) {
+            const { typescriptWorker, sendMessageCallbackFn } = typescriptWorkerMap[workerId];
+            const id = Math.random().toString(36).substring(2, 5);
+            msgData.data.id = id;
+            sendMessageCallbackFn[id] = callbackFn;
+            typescriptWorker.postMessage(msgData);
+        }
+        return { sendMessage };
+    };
+}
+/**
+ * 使用：
+ * const typescriptWorker = getTypescriptWorker();
+ * typescriptWorker.sendMessage({ action: 'dts', data: { code } }, dts => {
+ *
+ * })
+ * // 以下暂未实现
+ * typescriptWorker.sendMessage({ action: 'ts', data: { code } }, ts => {
+ *
+ * })
+ */
+const getTypescriptWorker = TypescriptWorker('transpileToDTS', workerCode);
+/**
+ * 通过 js/ts 代码生成 dts
+ */
+export function transpileToDTS(code) {
+    return new Promise((resolve) => {
+        const typescriptWorker = getTypescriptWorker();
+        typescriptWorker.sendMessage({ action: 'dts', data: { code } }, (dts) => {
+            resolve(dts);
+        });
+    });
+}
+export const jsonToDTSWorkerCode = `
+importScripts('https://qbase.cdn-go.cn/lcap/lcap-resource-cdngo/-/release/_url/devtools/json-schema-to-typescript-for-browser.min-11.0.5.js');
+
+function transpile(jsonschema) {
+  return jstt.compile(jsonschema, 'IWeDa', { additionalProperties: true, bannerComment: '', format: false, unknownAny: false })
+}
+
+addEventListener('message', (message) => {
+    const {action, data: {id, jsonschema}} = message.data
+    switch(action) {
+        case 'dts':
+            transpile(jsonschema).then(dts => {
+              postMessage({action: 'dts_back', data: {id, dts}})
+            }).catch(err => postMessage({action: 'dts_back', data: {id, dts: 'Parse error:' + err.message}}))
+            break
+        default:
+            break
+    }
+})
+`;
+const getCompileJSONToDTSWorker = TypescriptWorker('compileJSONToDTS', jsonToDTSWorkerCode);
+/**
+ * Webworker 版本的 JSON to DTS
+ */
+export function compileJSONToDTS(jsonschema) {
+    return new Promise((resolve, reject) => {
+        const worker = getCompileJSONToDTSWorker();
+        worker.sendMessage({ action: 'dts', data: { jsonschema } }, (dts) => {
+            if (dts.search('Parse error:') === 0)
+                reject(dts);
+            else
+                resolve(dts);
+        });
+    });
+}