@mybricks/to-code-taro 1.0.0

package/dist/cjs/handleCom.js

@@ -0,0 +1,260 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/handleCom.ts
+var handleCom_exports = {};
+__export(handleCom_exports, {
+  default: () => handleCom_default
+});
+module.exports = __toCommonJS(handleCom_exports);
+var import_utils = require("./utils");
+var import_code = require("./utils/code");
+var import_handleSlot = __toESM(require("./handleSlot"));
+var import_component = require("./utils/code/component");
+var import_renderManager = require("./utils/code/renderManager");
+var import_handleProcess = require("./utils/handleProcess");
+var handleCom = (com, config) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const { meta, props, slots, events } = com;
+  const isModule = meta.def.namespace.startsWith("mybricks.taro.module");
+  const { importInfo, callName } = config.getComponentMeta(meta);
+  const isJsCalculationComponent = meta.def.namespace === "mybricks.taro._muilt-inputJs" || meta.def.namespace === "mybricks.core-comlib.js-ai";
+  if (isJsCalculationComponent) {
+    const transformCode = ((_b = (_a = props.data) == null ? void 0 : _a.fns) == null ? void 0 : _b.code) || ((_d = (_c = props.data) == null ? void 0 : _c.fns) == null ? void 0 : _d.transformCode) || ((_e = props.data) == null ? void 0 : _e.fns);
+    if (transformCode && config.addJSModule) {
+      config.addJSModule({
+        id: meta.id,
+        title: meta.title || "JS计算",
+        transformCode: typeof transformCode === "string" ? transformCode : "",
+        inputs: ((_f = meta.model) == null ? void 0 : _f.inputs) || [],
+        outputs: ((_g = meta.model) == null ? void 0 : _g.outputs) || [],
+        data: props.data || {}
+      });
+    }
+    return {
+      slots: [],
+      scopeSlots: [],
+      ui: "",
+      js: "",
+      cssContent: "",
+      outputsConfig: void 0
+    };
+  }
+  const componentName = (0, import_utils.firstCharToUpperCase)(callName || importInfo.name);
+  const importName = (0, import_utils.firstCharToUpperCase)(importInfo.name);
+  config.addParentDependencyImport({
+    packageName: importInfo.from,
+    dependencyNames: [importName],
+    importType: importInfo.type
+  });
+  const currentProvider = config.getCurrentProvider();
+  const providerName = currentProvider.name;
+  const componentController = ((_h = config.getComponentController) == null ? void 0 : _h.call(config, {
+    com: meta,
+    scene: config.getCurrentScene()
+  })) || `controller_${meta.id}`;
+  const providerPath = `controllers.current.${providerName}`;
+  const controllerPath = `${providerPath}.${componentController}`;
+  const indentJs = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 1));
+  let eventCode = "";
+  const scene = config.getCurrentScene();
+  const sceneCom = (_i = scene.coms) == null ? void 0 : _i[meta.id];
+  const componentInputs = (sceneCom == null ? void 0 : sceneCom.inputs) || [];
+  const componentOutputs = (sceneCom == null ? void 0 : sceneCom.outputs) || meta.outputs || [];
+  let comEventCode = "";
+  const outputsConfig = {};
+  const eventConfig = {};
+  const resultStyle = (0, import_utils.convertComponentStyle)(props.style);
+  const cssContent = (0, import_utils.convertStyleAryToCss)((_j = props.style) == null ? void 0 : _j.styleAry, meta.id);
+  const outputEvents = events || {};
+  Object.entries(outputEvents).forEach(
+    ([eventId, eventInfo]) => {
+      const { type, isAbstract, diagramId, schema, active } = eventInfo;
+      if (active === false)
+        return;
+      if (isAbstract) {
+        config.setAbstractEventTypeDefMap({
+          comId: com.meta.id,
+          eventId,
+          typeDef: config.getTypeDef(),
+          schema
+        });
+        return;
+      }
+      if (type === "fx") {
+        const fxsMap = config.getFxsMap();
+        const currentProvider2 = config.getCurrentProvider();
+        const scene2 = config.getCurrentScene();
+        const pinProxy = scene2.pinProxies[`${props.id}-${eventId}`];
+        const fxProvider = fxsMap[pinProxy.frameId];
+        const isGlobal = fxProvider.name === "global";
+        if (fxProvider.name !== currentProvider2.name) {
+          if (isGlobal) {
+            config.addParentDependencyImport({
+              packageName: config.getComponentPackageName(),
+              dependencyNames: ["globalFxs"],
+              importType: "named"
+            });
+          } else {
+            config.addConsumer(fxProvider);
+          }
+        }
+        const indent3 = (0, import_utils.indentation)(
+          config.codeStyle.indent * (config.depth + 2)
+        );
+        comEventCode += `${indent3}${eventId}: ${isGlobal ? `globalFxs` : `comRefs.current.${fxProvider.name}_Fxs`}.${pinProxy.frameId},
+`;
+        eventConfig[eventId] = { connected: true };
+        return;
+      }
+      if (type !== "defined") {
+        return;
+      }
+      if (!diagramId) {
+        return;
+      }
+      const event = config.getEventByDiagramId(diagramId);
+      if (!event) {
+        return;
+      }
+      const paramName = "value";
+      let process = (0, import_handleProcess.handleProcess)(event, {
+        ...config,
+        target: "comRefs.current",
+        depth: config.depth + 3,
+        addParentDependencyImport: config.addParentDependencyImport,
+        getParams: () => {
+          return {
+            [eventId]: paramName
+          };
+        }
+      }).replace(/this\./g, "comRefs.current.").replace(/comRefs\.current\.([a-zA-Z0-9_]+)\.controller_/g, "comRefs.current.$1.").replace(/comRefs\.current\.slot_Index\./g, "comRefs.current.");
+      if (process.includes("pageParams")) {
+        config.addParentDependencyImport({
+          packageName: config.getComponentPackageName(),
+          dependencyNames: ["page"],
+          importType: "named"
+        });
+        process = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 3)) + `const pageParams: any = page.getParams("${config.getCurrentScene().id}");
+` + process;
+      }
+      const handlerCode = `(${paramName}: any) => {
+${process}
+${(0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 2))}}`;
+      if (!outputsConfig[meta.id]) {
+        outputsConfig[meta.id] = {};
+      }
+      const onEventName = eventId.startsWith("on") ? eventId : `on${eventId.charAt(0).toUpperCase()}${eventId.slice(1)}`;
+      outputsConfig[meta.id][onEventName] = handlerCode;
+      eventConfig[eventId] = { connected: true };
+    }
+  );
+  currentProvider.coms.add(meta.id);
+  currentProvider.controllers.add(meta.id);
+  const indent = (0, import_utils.indentation)(config.codeStyle.indent * config.depth);
+  const indent2 = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 1));
+  let slotsCode = "";
+  let accumulatedCssContent = cssContent;
+  let renderCode = "";
+  const renderManager = config.renderManager || new import_renderManager.RenderManager();
+  if (slots) {
+    let slotsObjectCode = "";
+    const slotEntries = Object.entries(slots);
+    slotEntries.forEach(([slotId, slot], index) => {
+      var _a2, _b2;
+      const rawSlotInfo = (_b2 = (_a2 = props.style) == null ? void 0 : _a2.slots) == null ? void 0 : _b2[slotId];
+      if (rawSlotInfo == null ? void 0 : rawSlotInfo.layout) {
+        slot.layout = rawSlotInfo.layout;
+      }
+      const { js, ui: ui2, cssContent: slotCssContent } = (0, import_handleSlot.default)(slot, {
+        ...config,
+        checkIsRoot: () => false,
+        depth: 1,
+        // 参照鸿蒙：非作用域插槽 depth 从 1 开始
+        renderManager
+        // 传递 renderManager
+      });
+      eventCode += js;
+      if (slotCssContent) {
+        accumulatedCssContent += (accumulatedCssContent ? "\n" : "") + slotCssContent;
+      }
+      const renderId = `${meta.id}_${slotId}`;
+      const baseIndentSize = config.codeStyle.indent;
+      const rootIndent = config.codeStyle.indent;
+      const renderBodyIndent = (0, import_utils.indentation)(rootIndent + config.codeStyle.indent);
+      const formattedContent = (0, import_component.formatSlotContent)({
+        uiContent: ui2,
+        baseIndentSize,
+        renderBodyIndent
+      });
+      renderManager.register(renderId, formattedContent);
+      const slotIndent = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 2));
+      slotsObjectCode += (0, import_component.genSlotRenderRef)({
+        slotId,
+        renderId,
+        indent: slotIndent,
+        isLast: index === slotEntries.length - 1
+      });
+    });
+    slotsCode = slotsObjectCode;
+  }
+  const componentResultStyle = { ...resultStyle };
+  const rootStyle = componentResultStyle.root || {};
+  delete componentResultStyle.root;
+  const eventHandlers = outputsConfig[meta.id] || {};
+  const uiComponentCode = (0, import_code.getUiComponentCode)(
+    {
+      componentName,
+      meta,
+      props,
+      resultStyle: { root: rootStyle },
+      // 传递 root style
+      componentInputs: componentInputs.length > 0 ? componentInputs : void 0,
+      componentOutputs: componentOutputs.length > 0 ? componentOutputs : void 0,
+      comEventCode,
+      slotsCode,
+      eventHandlers
+      // 传递事件处理函数
+    },
+    {
+      codeStyle: config.codeStyle,
+      depth: config.depth + 1,
+      verbose: config.verbose
+    }
+  );
+  const ui = uiComponentCode;
+  return {
+    slots: [],
+    scopeSlots: [],
+    ui,
+    js: eventCode,
+    cssContent: accumulatedCssContent,
+    outputsConfig: Object.keys(outputsConfig).length > 0 ? outputsConfig : void 0
+  };
+};
+var handleCom_default = handleCom;

package/dist/cjs/handleDom.d.ts

@@ -0,0 +1,19 @@
+import type { UI, BaseConfig } from "./toCodeTaro";
+import { ImportManager } from "./utils";
+type Dom = Extract<UI["children"][0], {
+    type: "dom";
+}>;
+interface HandleDomConfig extends BaseConfig {
+    addParentDependencyImport: (typeof ImportManager)["prototype"]["addImport"];
+    addConsumer: (provider: ReturnType<BaseConfig["getCurrentProvider"]>) => void;
+    addComId: (comId: string) => void;
+}
+type HandleDomResult = {
+    ui: string;
+    js: string;
+    slots: string[];
+    scopeSlots: string[];
+    cssContent: string;
+};
+declare const handleDom: (dom: Dom, config: HandleDomConfig) => HandleDomResult;
+export default handleDom;

package/dist/cjs/handleDom.js

@@ -0,0 +1,86 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/handleDom.ts
+var handleDom_exports = {};
+__export(handleDom_exports, {
+  default: () => handleDom_default
+});
+module.exports = __toCommonJS(handleDom_exports);
+var import_utils = require("./utils");
+var import_handleCom = __toESM(require("./handleCom"));
+var handleDom = (dom, config) => {
+  var _a;
+  const { props, children } = dom;
+  const domProps = props;
+  let uiCode = "";
+  let jsCode = "";
+  let cssContent = (0, import_utils.convertStyleAryToCss)((_a = domProps.style) == null ? void 0 : _a.styleAry, domProps.id);
+  const level0Slots = [];
+  const level1Slots = [];
+  const nextConfig = {
+    ...config,
+    depth: config.depth + 1
+  };
+  children.forEach((child) => {
+    if (child.type === "com") {
+      const { ui: ui2, js, slots, scopeSlots, cssContent: childCssContent } = (0, import_handleCom.default)(child, nextConfig);
+      uiCode += uiCode ? "\n" + ui2 : ui2;
+      jsCode += js;
+      if (childCssContent) {
+        cssContent += (cssContent ? "\n" : "") + childCssContent;
+      }
+      level0Slots.push(...slots);
+      level1Slots.push(...scopeSlots);
+    } else if (child.type === "module") {
+      uiCode += uiCode ? "\n模块" : "模块";
+    } else {
+      const { ui: ui2, js, slots, scopeSlots, cssContent: childCssContent } = handleDom(child, nextConfig);
+      uiCode += uiCode ? "\n" + ui2 : ui2;
+      jsCode += js;
+      if (childCssContent) {
+        cssContent += (cssContent ? "\n" : "") + childCssContent;
+      }
+      level0Slots.push(...slots);
+      level1Slots.push(...scopeSlots);
+    }
+  });
+  const indent = (0, import_utils.indentation)(config.codeStyle.indent * config.depth);
+  const styleCode = JSON.stringify((0, import_utils.convertRootStyle)(domProps.style));
+  const ui = `${indent}<View${domProps.id ? ` id="${domProps.id}" className="${domProps.id}"` : ""} style={${styleCode}}>
+${uiCode}
+${indent}</View>`;
+  return {
+    ui,
+    js: jsCode,
+    slots: level0Slots,
+    scopeSlots: level1Slots,
+    cssContent
+  };
+};
+var handleDom_default = handleDom;

package/dist/cjs/handleExtension.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 处理Extension事件卡片
+ */
+import type { ToTaroCodeConfig, Result } from "./toCodeTaro";
+interface HandleExtensionParams {
+    tojson: any;
+    extensionEvents: any[];
+}
+declare const handleExtension: (params: HandleExtensionParams, config: ToTaroCodeConfig) => Result;
+export default handleExtension;

package/dist/cjs/handleExtension.js

@@ -0,0 +1,300 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/handleExtension.ts
+var handleExtension_exports = {};
+__export(handleExtension_exports, {
+  default: () => handleExtension_default
+});
+module.exports = __toCommonJS(handleExtension_exports);
+var import_utils = require("./utils");
+var import_handleProcess = require("./utils/handleProcess");
+var handleExtension = (params, config) => {
+  const { tojson, extensionEvents } = params;
+  const result = [];
+  const importManager = new import_utils.ImportManager(config);
+  const addDependencyImport = importManager.addImport.bind(importManager);
+  const eventCode = genEvent(
+    {
+      tojson,
+      extensionEvents: extensionEvents.filter((extensionEvent) => {
+        return extensionEvent.meta.type === "extension-event";
+      })
+    },
+    { ...config, addParentDependencyImport: addDependencyImport }
+  );
+  const apiCode = genApi(
+    {
+      tojson,
+      extensionEvents: extensionEvents.filter((extensionEvent) => {
+        return extensionEvent.meta.type === "extension-api";
+      })
+    },
+    { ...config, addParentDependencyImport: addDependencyImport }
+  );
+  const configCode = genConfig(
+    {
+      tojson,
+      extensionEvents: extensionEvents.filter((extensionEvent) => {
+        return extensionEvent.meta.type === "extension-config";
+      })
+    },
+    { ...config, addParentDependencyImport: addDependencyImport }
+  );
+  result.push({
+    type: "api",
+    content: (apiCode ? `${apiCode}
+
+` : "") + (configCode ? `${configCode}
+
+` : "") + eventCode,
+    importManager,
+    name: "abstractEventTypeDef"
+  });
+  const extensionBusImportManager = new import_utils.ImportManager(config);
+  const addDependencyExtensionBusImport = extensionBusImportManager.addImport.bind(extensionBusImportManager);
+  const busCode = genBus(
+    {
+      tojson,
+      extensionEvents: extensionEvents.filter((extensionEvent) => {
+        return extensionEvent.meta.type === "extension-bus";
+      })
+    },
+    { ...config, addParentDependencyImport: addDependencyExtensionBusImport }
+  );
+  if (busCode) {
+    result.push({
+      content: busCode,
+      importManager: extensionBusImportManager,
+      type: "extension-bus",
+      name: "系统总线"
+    });
+  }
+  return result;
+};
+var handleExtension_default = handleExtension;
+var genConfig = (params, config) => {
+  var _a;
+  const { extensionEvents } = params;
+  const { addParentDependencyImport } = config;
+  if (!extensionEvents.length) {
+    return "";
+  }
+  const extensionEvent = extensionEvents[0];
+  const event = extensionEvent.events[0];
+  const eventParams = {};
+  (event.paramPins || []).forEach((cur) => {
+    eventParams[cur.id] = `value.${cur.id}`;
+  });
+  const code = (0, import_handleProcess.handleProcess)(event, {
+    ...config,
+    depth: 2,
+    getParams: () => {
+      return eventParams;
+    },
+    getComponentPackageName: () => {
+      return config.getComponentPackageName({ type: "extensionEvent" });
+    },
+    addParentDependencyImport,
+    getComponentMeta: (com, configMeta) => {
+      return config.getComponentMeta(com, {
+        ...configMeta,
+        json: extensionEvent.meta
+      });
+    }
+  });
+  addParentDependencyImport({
+    packageName: config.getUtilsPackageName(),
+    dependencyNames: ["MyBricks"],
+    importType: "named"
+  });
+  return `export const config = (${((_a = event.paramPins) == null ? void 0 : _a.length) ? "value: any" : ""}) => {` + (code ? `
+${code}` : "") + `
+}`;
+};
+var genApi = (params, config) => {
+  const { extensionEvents } = params;
+  const { addParentDependencyImport } = config;
+  if (!extensionEvents.length) {
+    return "";
+  }
+  let apiCode = "";
+  extensionEvents.forEach((extension) => {
+    const { meta, events } = extension;
+    const event = events[0];
+    const params2 = {
+      open: "value",
+      call: "value"
+    };
+    const code = (0, import_handleProcess.handleProcess)(event, {
+      ...config,
+      depth: 2,
+      getParams: () => {
+        return params2;
+      },
+      getComponentPackageName: () => {
+        return config.getComponentPackageName({ type: "extensionEvent" });
+      },
+      addParentDependencyImport,
+      getComponentMeta: (com, configMeta) => {
+        return config.getComponentMeta(com, {
+          ...configMeta,
+          json: meta
+        });
+      }
+    });
+    const indent = (0, import_utils.indentation)(config.codeStyle.indent);
+    const indent2 = (0, import_utils.indentation)(config.codeStyle.indent * 2);
+    apiCode += `${indent}/** ${event.title} */
+${indent}${event.title}: any = transformApi((value: any) => {
+${code}
+${indent}})
+`;
+    addParentDependencyImport({
+      packageName: config.getUtilsPackageName(),
+      dependencyNames: ["MyBricks", "transformApi"],
+      importType: "named"
+    });
+  });
+  return `class Api {
+${apiCode}}
+
+export const api = new Api()`;
+};
+var genBus = (params, config) => {
+  const { extensionEvents } = params;
+  const { addParentDependencyImport } = config;
+  if (!extensionEvents.length) {
+    return "";
+  }
+  let busCode = "";
+  extensionEvents.forEach((extension) => {
+    const { meta, events } = extension;
+    const event = events[0];
+    const params2 = {
+      open: "value",
+      call: "value"
+    };
+    const code = (0, import_handleProcess.handleProcess)(event, {
+      ...config,
+      depth: 2,
+      getParams: () => {
+        return params2;
+      },
+      getComponentPackageName: () => {
+        return config.getComponentPackageName({ type: "extensionEvent" });
+      },
+      addParentDependencyImport,
+      getComponentMeta: (com, configMeta) => {
+        return config.getComponentMeta(com, {
+          ...configMeta,
+          json: meta
+        });
+      }
+    });
+    const indent = (0, import_utils.indentation)(config.codeStyle.indent);
+    busCode += `${indent}/** ${event.title} */
+${indent}${event.title}: any = createFx((value: any) => {
+${code}
+${indent}})
+`;
+    addParentDependencyImport({
+      packageName: config.getUtilsPackageName(),
+      dependencyNames: ["MyBricks", "createFx"],
+      importType: "named"
+    });
+  });
+  return `/** 系统总线 */
+class Bus {
+${busCode}}
+
+export const bus = new Bus()`;
+};
+var genEvent = (params, config) => {
+  const { tojson, extensionEvents } = params;
+  const { addParentDependencyImport } = config;
+  if (!extensionEvents.length) {
+    return "";
+  }
+  addParentDependencyImport({
+    packageName: config.getUtilsPackageName(),
+    dependencyNames: ["MyBricks", "createEvent", "transformEvents"],
+    importType: "named"
+  });
+  let typeCode = "";
+  let eventCode = "";
+  let eventCreateCode = "";
+  const indent = (0, import_utils.indentation)(config.codeStyle.indent);
+  extensionEvents.forEach((event) => {
+    const extensionEvent = tojson.frames.find(
+      (frame) => frame.id === event.meta.id
+    );
+    const typeParams = `T${extensionEvent.title}Params`;
+    const interfaceCallBack = `I${extensionEvent.title}CallBack`;
+    typeCode += `type ${typeParams} = any;
+`;
+    let interfaceCallBackCode = "";
+    extensionEvent.outputs.forEach((output) => {
+      const title = output.title;
+      interfaceCallBackCode += (title ? `
+${indent}/** ${title} */` : "") + `
+${indent}${output.id}: (value: any) => void;`;
+    });
+    if (interfaceCallBackCode) {
+      typeCode += `interface ${interfaceCallBack} {${interfaceCallBackCode}
+}
+`;
+    }
+    eventCode += `${indent}${extensionEvent.title}?: ${interfaceCallBackCode ? "EventWithCallBack" : "Event"}<${typeParams}${interfaceCallBackCode ? `, ${interfaceCallBack}` : ""}>;
+`;
+    const params2 = {
+      open: "value",
+      call: "value"
+    };
+    const code = (0, import_handleProcess.handleProcess)(event.events[0], {
+      ...config,
+      depth: 2,
+      getParams: () => {
+        return params2;
+      },
+      getComponentPackageName: () => {
+        return config.getComponentPackageName({ type: "extensionEvent" });
+      },
+      getComponentMeta: (com, configMeta) => {
+        return config.getComponentMeta(com, {
+          ...configMeta,
+          json: event.meta
+        });
+      }
+    });
+    eventCreateCode += `${indent}${extensionEvent.title}: any = createEvent((value: ${typeParams}${interfaceCallBackCode ? `, callBack: ${interfaceCallBack}` : ""}) => {` + code + `
+${indent}})
+`;
+  });
+  return `type Event<ParamsType> = (params: ParamsType) => void;
+type EventWithCallBack<ParamsType, CallbackType> = (value: ParamsType, callBack: CallbackType) => void;
+${typeCode}class Events {
+${eventCreateCode}}
+
+export const events = new Events();
+
+interface OnEventParams {
+${eventCode}}
+
+export const onEvent: (events: OnEventParams) => void = transformEvents(events);`;
+};

package/dist/cjs/handleGlobal.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 处理全局变量和全局Fx
+ */
+import { ImportManager } from "./utils";
+import type { ToTaroCodeConfig } from "./toCodeTaro";
+interface HandleGlobalParams {
+    tojson: any;
+    globalFxs: any[];
+    globalVars: any[];
+}
+declare const handleGlobal: (params: HandleGlobalParams, config: ToTaroCodeConfig) => {
+    content: string;
+    cssContent?: string;
+    pageConfigContent?: string;
+    importManager: ImportManager;
+    type: "module" | "normal" | "popup" | "global" | "extension-config" | "extension-api" | "extension-bus" | "abstractEventTypeDef" | "fx" | "api" | "extension-event" | "jsModules" | "commonIndex" | "tabBarConfig";
+    meta?: import("@mybricks/render-web/packages/code-next/dist/esm/toCode/types").Scene;
+    name: string;
+    tabBarConfig?: string;
+};
+export default handleGlobal;