@mybricks/to-code-taro 1.0.2 → 1.0.4

package/dist/cjs/handleSlot.js

@@ -1,8 +1,6 @@
-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)
@@ -16,14 +14,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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/handleSlot.ts
@@ -33,160 +23,38 @@ __export(handleSlot_exports, {
 });
 module.exports = __toCommonJS(handleSlot_exports);
 var import_utils = require("./utils");
-var import_handleCom = __toESM(require("./handleCom"));
-var import_handleProcess = require("./utils/handleProcess");
-var import_scene = require("./utils/code/scene");
-var import_renderManager = require("./utils/code/renderManager");
-var import_handleDom = __toESM(require("./handleDom"));
-var import_handleModule = __toESM(require("./handleModule"));
+var import_scene = require("./utils/templates/scene");
+var import_renderManager = require("./utils/templates/renderManager");
+var import_processChildren = require("./utils/logic/processChildren");
+var import_processSceneLogic = require("./processors/processSceneLogic");
 var handleSlot = (ui, config) => {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b;
   const importManager = new import_utils.ImportManager(config);
   const { props = {}, children = [] } = ui;
-  let uiCode = "";
-  let jsCode = "";
-  let effectCode = "";
+  const isRoot = config.checkIsRoot();
   const slotId = ((_a = ui.meta) == null ? void 0 : _a.id) || ui.id;
-  const renderManager = config.checkIsRoot() ? new import_renderManager.RenderManager() : config.renderManager || new import_renderManager.RenderManager();
-  const currentProvider = config.getCurrentProvider();
   const addDependencyImport = config.addParentDependencyImport || importManager.addImport.bind(importManager);
+  setupImports(addDependencyImport, config, isRoot);
   const indent2 = (0, import_utils.indentation)(config.codeStyle.indent);
-  let envDefineCode = "";
-  if (config.checkIsRoot()) {
-    addDependencyImport({
-      packageName: "react",
-      dependencyNames: ["useRef", "useEffect", "useState"],
-      importType: "named"
-    });
-    addDependencyImport({
-      packageName: "@tarojs/components",
-      dependencyNames: ["View"],
-      importType: "named"
-    });
-    const utilsPackageName = config.getUtilsPackageName();
-    addDependencyImport({
-      packageName: utilsPackageName,
-      dependencyNames: ["WithCom", "WithWrapper"],
-      importType: "named"
-    });
-    addDependencyImport({
-      packageName: "./index.less",
-      dependencyNames: [],
-      importType: "module"
-    });
-    envDefineCode = (0, import_scene.genRootDefineCode)(indent2, utilsPackageName);
-    addDependencyImport({
-      packageName: config.getComponentPackageName(),
-      dependencyNames: ["useAppContext"],
-      importType: "named"
-    });
-  } else {
-    envDefineCode = (0, import_scene.genSlotDefineCode)(indent2);
-    addDependencyImport({
-      packageName: config.getComponentPackageName(),
-      dependencyNames: ["useAppContext"],
-      importType: "named"
-    });
-  }
-  let cssContent = (0, import_utils.convertStyleAryToCss)((_b = props.style) == null ? void 0 : _b.styleAry, slotId);
-  const nextConfig = {
+  const envDefineCode = isRoot ? (0, import_scene.genRootDefineCode)(indent2, config.getUtilsPackageName()) : (0, import_scene.genSlotDefineCode)(indent2);
+  const renderManager = isRoot ? new import_renderManager.RenderManager() : config.renderManager || new import_renderManager.RenderManager();
+  const childResults = (0, import_processChildren.processChildren)(children, {
     ...config,
     depth: config.depth + 1,
     addParentDependencyImport: addDependencyImport,
     renderManager
-    // 传递 renderManager
-  };
-  children.forEach((child) => {
-    if (child.type === "com") {
-      const { ui: ui2, js, cssContent: childCssContent } = (0, import_handleCom.default)(child, nextConfig);
-      uiCode += uiCode ? "\n" + ui2 : ui2;
-      jsCode += js;
-      if (childCssContent) {
-        cssContent += (cssContent ? "\n" : "") + childCssContent;
-      }
-    } else if (child.type === "module") {
-      const { ui: ui2, cssContent: childCssContent } = (0, import_handleModule.default)(child, nextConfig);
-      uiCode += uiCode ? "\n" + ui2 : ui2;
-      if (childCssContent) {
-        cssContent += (cssContent ? "\n" : "") + childCssContent;
-      }
-    } else {
-      const { ui: ui2, js, cssContent: childCssContent } = (0, import_handleDom.default)(child, nextConfig);
-      uiCode += uiCode ? "\n" + ui2 : ui2;
-      jsCode += js;
-      if (childCssContent) {
-        cssContent += (cssContent ? "\n" : "") + childCssContent;
-      }
-    }
   });
-  if (config.checkIsRoot()) {
-    const scene2 = ((_c = ui.meta) == null ? void 0 : _c.scene) || ui.meta;
-    const sceneEvents = (scene2 == null ? void 0 : scene2.events) || ui.events || [];
-    if (Array.isArray(sceneEvents)) {
-      sceneEvents.forEach((eventInfo) => {
-        const { type, diagramId, active } = eventInfo;
-        if (active !== false && type === "defined" && diagramId) {
-          const event = config.getEventByDiagramId(diagramId);
-          if (event) {
-            const process = (0, import_handleProcess.handleProcess)(event, {
-              ...config,
-              target: "comRefs.current",
-              depth: 2,
-              addParentDependencyImport: addDependencyImport,
-              getParams: () => ({})
-            }).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.trim()) {
-              effectCode += `
-${indent2}  ${process.trim()}`;
-            }
-          }
-        }
-      });
-    }
-  }
-  let renderCodeBlock = "";
-  if (config.checkIsRoot() && renderManager) {
-    const renderIndent = (0, import_utils.indentation)(config.codeStyle.indent);
-    renderCodeBlock = renderManager.toCode(renderIndent);
-  }
-  const combinedJsCode = `${envDefineCode}${jsCode}${renderCodeBlock ? `
+  let effectCode = (0, import_processSceneLogic.processSceneLogic)(ui, config, addDependencyImport);
+  let cssContent = ((0, import_utils.convertStyleAryToCss)((_b = props.style) == null ? void 0 : _b.styleAry, slotId) || "") + (childResults.cssContent ? "\n" + childResults.cssContent : "");
+  let renderCodeBlock = isRoot && renderManager ? renderManager.toCode((0, import_utils.indentation)(config.codeStyle.indent)) : "";
+  const combinedJsCode = `${envDefineCode}${childResults.js}${renderCodeBlock ? `
 ${renderCodeBlock}` : ""}${(0, import_scene.wrapInEffect)(indent2, effectCode)}`;
-  const indent = (0, import_utils.indentation)(config.codeStyle.indent * config.depth);
-  const mergedStyle = {
-    width: "100%",
-    height: "100%",
-    ...ui.style,
-    ...props.style || {}
-  };
-  const styleCode = JSON.stringify((0, import_utils.convertRootStyle)({
-    ...mergedStyle,
-    layout: ui.layout || mergedStyle.layout
-  }));
-  const scene = config.getCurrentScene();
-  const rootClassName = (0, import_utils.getRootComponentClassName)(scene, config.checkIsRoot());
-  const classNameAttr = rootClassName ? ` className='${rootClassName}'` : "";
-  const uiResult = `${indent}<View${classNameAttr} style={${styleCode}}>
-${uiCode}
-${indent}</View>`;
-  if (config.checkIsRoot()) {
-    const scene2 = config.getCurrentScene();
-    const fileName = ((_d = config.getFileName) == null ? void 0 : _d.call(config, ui.meta.slotId)) || ui.meta.title || "index";
-    const componentId = ((_e = ui.meta) == null ? void 0 : _e.id) || ui.id || ((_f = ui.meta) == null ? void 0 : _f.slotId) || "Index";
-    const componentName = `I${String(componentId).replace(/[^a-zA-Z0-9]/g, "_")}`;
-    const componentCode = (0, import_scene.genComponentTemplate)({
-      componentName,
-      combinedJsCode,
-      uiResult
-    });
-    config.add({
-      importManager,
-      content: componentCode,
-      cssContent,
-      name: fileName
-    });
+  const uiResult = generateSlotUi(ui, props, childResults.ui, config);
+  if (isRoot) {
+    finalizeRootComponent(ui, config, importManager, combinedJsCode, uiResult, cssContent);
   }
   return {
-    js: jsCode,
+    js: childResults.js,
     combinedJsCode,
     ui: uiResult,
     cssContent,
@@ -194,4 +62,47 @@ ${indent}</View>`;
     scopeSlots: []
   };
 };
+var setupImports = (addImport, config, isRoot) => {
+  const importParams = { isPopup: config.isPopup };
+  const utilsPkg = config.getUtilsPackageName(importParams);
+  const comPkg = config.getComponentPackageName(importParams);
+  addImport({ packageName: "react", dependencyNames: ["useRef", "useEffect", "useState"], importType: "named" });
+  addImport({ packageName: "@tarojs/components", dependencyNames: ["View"], importType: "named" });
+  const dependencyNames = ["WithCom", "WithWrapper"];
+  if (isRoot && config.hasPopups) {
+    dependencyNames.push("PopupRenderer");
+  }
+  addImport({ packageName: utilsPkg, dependencyNames, importType: "named" });
+  addImport({ packageName: comPkg, dependencyNames: ["useAppContext"], importType: "named" });
+  if (isRoot) {
+    if (config.hasPopups) {
+      addImport({ packageName: "../../common/popup", dependencyNames: ["POPUP_MAP", "POPUP_IDS"], importType: "named" });
+    }
+    addImport({ packageName: "./index.less", dependencyNames: [], importType: "module" });
+  }
+};
+var generateSlotUi = (ui, props, childrenUi, config) => {
+  const indent = (0, import_utils.indentation)(config.codeStyle.indent * config.depth);
+  const mergedStyle = { width: "100%", height: "100%", ...ui.style || {}, ...props.style || {} };
+  const styleCode = JSON.stringify((0, import_utils.convertRootStyle)({ ...mergedStyle, layout: ui.layout || mergedStyle.layout }));
+  const rootClassName = (0, import_utils.getRootComponentClassName)(config.getCurrentScene(), config.checkIsRoot());
+  const classNameAttr = rootClassName ? ` className='${rootClassName}'` : "";
+  return `${indent}<View${classNameAttr} style={${styleCode}}>
+${childrenUi}
+${indent}</View>`;
+};
+var finalizeRootComponent = (ui, config, importManager, combinedJsCode, uiResult, cssContent) => {
+  var _a, _b, _c;
+  const fileName = ((_a = config.getFileName) == null ? void 0 : _a.call(config, ui.meta.slotId)) || ui.meta.title || "index";
+  const componentId = ((_b = ui.meta) == null ? void 0 : _b.id) || ui.id || ((_c = ui.meta) == null ? void 0 : _c.slotId) || "Index";
+  const componentName = `I${String(componentId).replace(/[^a-zA-Z0-9]/g, "_")}`;
+  const componentCode = (0, import_scene.genComponentTemplate)({
+    componentName,
+    combinedJsCode,
+    uiResult,
+    isPopup: config.isPopup,
+    hasPopups: config.hasPopups
+  });
+  config.add({ importManager, content: componentCode, cssContent, name: fileName });
+};
 var handleSlot_default = handleSlot;

package/dist/cjs/processors/processComEvents.d.ts

@@ -0,0 +1,9 @@
+import type { HandleComConfig, Com } from "../handleCom";
+/**
+ * 处理组件事件
+ */
+export declare const processComEvents: (com: Com, config: HandleComConfig) => {
+    comEventCode: string;
+    outputsConfig: Record<string, any>;
+    eventConfig: Record<string, any>;
+};

package/dist/cjs/processors/processComEvents.js

@@ -0,0 +1,164 @@
+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/processors/processComEvents.ts
+var processComEvents_exports = {};
+__export(processComEvents_exports, {
+  processComEvents: () => processComEvents
+});
+module.exports = __toCommonJS(processComEvents_exports);
+var import_utils = require("../utils");
+var import_handleProcess = require("../utils/logic/handleProcess");
+var processComEvents = (com, config) => {
+  var _a, _b, _c;
+  const { meta, events } = com;
+  let comEventCode = "";
+  const outputsConfig = {};
+  const eventConfig = {};
+  const outputEvents = events || {};
+  Object.entries(outputEvents).forEach(([eventId, eventInfo]) => {
+    var _a2, _b2;
+    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") {
+      processFxEvent(eventId, com, config, (code) => {
+        comEventCode += code;
+      });
+      eventConfig[eventId] = { connected: true };
+      return;
+    }
+    if (type !== "defined")
+      return;
+    const resolvedDiagramId = diagramId || ((_a2 = eventInfo == null ? void 0 : eventInfo.options) == null ? void 0 : _a2.diagramId) || ((_b2 = eventInfo == null ? void 0 : eventInfo.options) == null ? void 0 : _b2.id);
+    if (!resolvedDiagramId)
+      return;
+    const event = config.getEventByDiagramId(resolvedDiagramId);
+    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: () => ({ [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")) {
+      const importParams = { isPopup: config.isPopup };
+      const controllerName = config.isPopup ? "popupRouter" : "pageRouter";
+      config.addParentDependencyImport({
+        packageName: config.getComponentPackageName(importParams),
+        dependencyNames: [controllerName, "SUBJECT_VALUE"],
+        importType: "named"
+      });
+      const indent = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 3));
+      process = `${indent}const pageParams: any = ${controllerName}.getParams("${config.getCurrentScene().id}")[SUBJECT_VALUE];
+${process}`;
+    }
+    const handlerIndent = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 2));
+    const handlerCode = `(${paramName}: any) => {
+${process}
+${handlerIndent}}`;
+    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 };
+  });
+  if (((_a = meta.def) == null ? void 0 : _a.namespace) === "mybricks.taro.popup") {
+    if (!outputsConfig[meta.id]) {
+      outputsConfig[meta.id] = {};
+    }
+    const importParams = { isPopup: config.isPopup };
+    const sceneCom = (_b = config.getCurrentScene().coms) == null ? void 0 : _b[meta.id];
+    const popupData = ((_c = sceneCom == null ? void 0 : sceneCom.model) == null ? void 0 : _c.data) || {};
+    const isTrue = (v) => v === true || v === "true";
+    if (!eventConfig["onClose"] && isTrue(popupData.visibleClose)) {
+      config.addParentDependencyImport({
+        packageName: config.getComponentPackageName(importParams),
+        dependencyNames: ["popupRouter"],
+        importType: "named"
+      });
+      const handlerIndent = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 2));
+      const processIndent = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 3));
+      outputsConfig[meta.id]["onClose"] = `() => {
+${processIndent}popupRouter.close("${config.getCurrentScene().id}");
+${handlerIndent}}`;
+      eventConfig["onClose"] = { connected: true };
+    }
+    if (!eventConfig["onClickOverlay"] && isTrue(popupData.maskClose)) {
+      config.addParentDependencyImport({
+        packageName: config.getComponentPackageName(importParams),
+        dependencyNames: ["popupRouter"],
+        importType: "named"
+      });
+      const handlerIndent = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 2));
+      const processIndent = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 3));
+      outputsConfig[meta.id]["onClickOverlay"] = `() => {
+${processIndent}popupRouter.close("${config.getCurrentScene().id}");
+${handlerIndent}}`;
+      eventConfig["onClickOverlay"] = { connected: true };
+    }
+  }
+  return { comEventCode, outputsConfig, eventConfig };
+};
+var processFxEvent = (eventId, com, config, addCode) => {
+  const fxsMap = config.getFxsMap();
+  const currentProvider = config.getCurrentProvider();
+  const scene = config.getCurrentScene();
+  const pinProxy = scene.pinProxies[`${com.props.id}-${eventId}`];
+  if (!pinProxy)
+    return;
+  const fxProvider = fxsMap[pinProxy.frameId];
+  if (!fxProvider)
+    return;
+  const isGlobal = fxProvider.name === "global";
+  if (fxProvider.name !== currentProvider.name) {
+    if (isGlobal) {
+      config.addParentDependencyImport({
+        packageName: config.getComponentPackageName(),
+        dependencyNames: ["globalFxs"],
+        importType: "named"
+      });
+    } else {
+      config.addConsumer(fxProvider);
+    }
+  }
+  const indent = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 2));
+  const code = `${indent}${eventId}: ${isGlobal ? "globalFxs" : `comRefs.current.${fxProvider.name}_Fxs`}.${pinProxy.frameId},
+`;
+  addCode(code);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processComEvents
+});

package/dist/cjs/processors/processModule.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 处理模块（Module）
+ * 参考鸿蒙实现，将模块处理逻辑独立出来
+ */
+import type { ToTaroCodeConfig, GeneratedFile } from "../toCodeTaro";
+import toCode from "@mybricks/to-code-react/dist/cjs/toCode";
+import { type Provider } from "../utils/context/createProvider";
+import type { JSModulesMap } from "../utils/context/collectJSModules";
+type ToCodeResult = ReturnType<typeof toCode>;
+type Module = ToCodeResult["modules"][0];
+interface ProcessModuleParams {
+    module: Module;
+    config: ToTaroCodeConfig;
+    globalVarTypeDef: Record<string, any>;
+    defaultFxsMap: Record<string, Provider>;
+    abstractEventTypeDefMap: Record<string, any>;
+    jsModulesMap: JSModulesMap;
+    getExtensionEventById: (id: string) => any;
+    getSceneById: (id: string) => any;
+    getFrameById?: (id: string) => any;
+    addResult: (result: GeneratedFile) => void;
+}
+/**
+ * 处理单个模块
+ */
+export declare const processModule: (params: ProcessModuleParams) => void;
+/**
+ * 处理所有模块
+ */
+export declare const processModules: (modules: Module[], params: Omit<ProcessModuleParams, "module">) => void;
+export {};

package/dist/cjs/processors/processModule.js

@@ -0,0 +1,125 @@
+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/processors/processModule.ts
+var processModule_exports = {};
+__export(processModule_exports, {
+  processModule: () => processModule,
+  processModules: () => processModules
+});
+module.exports = __toCommonJS(processModule_exports);
+var import_handleSlot = __toESM(require("../handleSlot"));
+var import_createProvider = require("../utils/context/createProvider");
+var import_createEventQueries = require("../utils/context/createEventQueries");
+var import_collectJSModules = require("../utils/context/collectJSModules");
+var processModule = (params) => {
+  var _a;
+  const {
+    module: { scene, ui, event },
+    config,
+    globalVarTypeDef,
+    defaultFxsMap,
+    abstractEventTypeDefMap,
+    jsModulesMap,
+    getExtensionEventById,
+    getSceneById,
+    getFrameById,
+    addResult
+  } = params;
+  (0, import_collectJSModules.collectJSModulesFromScene)(scene, jsModulesMap);
+  const fileName = (_a = config.getFileName) == null ? void 0 : _a.call(config, ui.meta.slotId);
+  const currentProvider = (0, import_createProvider.createProvider)(fileName, true);
+  const providerMap = (0, import_createProvider.createProviderMap)(currentProvider);
+  const typeDef = {
+    vars: Object.assign({}, globalVarTypeDef),
+    inputs: {},
+    outputs: {}
+  };
+  const fxsMap = Object.assign({}, defaultFxsMap);
+  const eventQueries = (0, import_createEventQueries.createEventQueries)(event);
+  (0, import_handleSlot.default)(ui, {
+    ...config,
+    getCurrentScene: () => {
+      const originalScene = getSceneById(scene.id);
+      return { ...scene, ...originalScene, event };
+    },
+    add: (value) => {
+      addResult({
+        ...value,
+        type: scene.type,
+        meta: scene
+      });
+    },
+    addJSModule: (module2) => {
+      if (!jsModulesMap.has(module2.id)) {
+        jsModulesMap.set(module2.id, module2);
+      }
+    },
+    getEventByDiagramId: eventQueries.getEventByDiagramId,
+    getFrameInputEvent: eventQueries.getFrameInputEvent,
+    getVarEvents: eventQueries.getVarEvents,
+    getFxEvents: eventQueries.getFxEvents,
+    checkIsRoot: () => true,
+    getEffectEvent: eventQueries.getEffectEvent,
+    getCurrentProvider: () => currentProvider,
+    getRootProvider: () => currentProvider,
+    getProviderMap: () => providerMap,
+    getExtensionEventById,
+    getSceneById,
+    getFrameById,
+    depth: 0,
+    getTypeDef: () => typeDef,
+    getFxsMap: () => fxsMap,
+    setAbstractEventTypeDefMap: (params2) => {
+      const { comId, eventId, typeDef: typeDef2, schema } = params2;
+      if (!abstractEventTypeDefMap[comId]) {
+        abstractEventTypeDefMap[comId] = {
+          typeDef: typeDef2,
+          eventIdMap: {}
+        };
+      }
+      abstractEventTypeDefMap[comId].eventIdMap[eventId] = schema;
+    },
+    getComponentController: ({ com }) => {
+      return com.id;
+    }
+  });
+};
+var processModules = (modules, params) => {
+  modules.forEach((module2) => {
+    processModule({
+      ...params,
+      module: module2
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processModule,
+  processModules
+});

package/dist/cjs/processors/processScene.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 处理场景（Scene）
+ * 参考鸿蒙实现，将场景处理逻辑独立出来
+ */
+import type { ToTaroCodeConfig, GeneratedFile } from "../toCodeTaro";
+import toCode from "@mybricks/to-code-react/dist/cjs/toCode";
+import { type Provider } from "../utils/context/createProvider";
+import type { JSModulesMap } from "../utils/context/collectJSModules";
+type ToCodeResult = ReturnType<typeof toCode>;
+type Scene = ToCodeResult["scenes"][0];
+interface ProcessSceneParams {
+    scene: Scene;
+    config: ToTaroCodeConfig;
+    globalVarTypeDef: Record<string, any>;
+    defaultFxsMap: Record<string, Provider>;
+    abstractEventTypeDefMap: Record<string, any>;
+    jsModulesMap: JSModulesMap;
+    getExtensionEventById: (id: string) => any;
+    getSceneById: (id: string) => any;
+    getFrameById?: (id: string) => any;
+    pageConfigHandler: any;
+    addResult: (result: GeneratedFile) => void;
+}
+/**
+ * 处理单个场景
+ */
+export declare const processScene: (params: ProcessSceneParams) => void;
+/**
+ * 处理所有场景
+ */
+export declare const processScenes: (scenes: Scene[], params: Omit<ProcessSceneParams, "scene">) => void;
+export {};