@mybricks/to-code-taro 1.0.0

package/dist/cjs/handleGlobal.js

@@ -0,0 +1,155 @@
+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/handleGlobal.ts
+var handleGlobal_exports = {};
+__export(handleGlobal_exports, {
+  default: () => handleGlobal_default
+});
+module.exports = __toCommonJS(handleGlobal_exports);
+var import_utils = require("./utils");
+var import_handleProcess = require("./utils/handleProcess");
+var handleGlobal = (params, config) => {
+  const { tojson, globalFxs, globalVars } = params;
+  const globalImportManager = new import_utils.ImportManager(config);
+  const globalAddDependencyImport = globalImportManager.addImport.bind(globalImportManager);
+  globalAddDependencyImport({
+    packageName: config.getComponentPackageName(),
+    dependencyNames: ["useAppContext"],
+    importType: "named"
+  });
+  let globalVarsInitCode = "";
+  let globalVarsRegisterChangeCode = "";
+  const indent = (0, import_utils.indentation)(config.codeStyle.indent);
+  const indent2 = (0, import_utils.indentation)(config.codeStyle.indent * 2);
+  Object.entries(tojson.global.comsReg).forEach(([, com]) => {
+    if (com.def.namespace !== "mybricks.core-comlib.var") {
+      return;
+    }
+    const event = globalVars.find((globalVar) => {
+      return globalVar.meta.id === com.id;
+    });
+    const res = (0, import_handleProcess.handleProcess)(event, {
+      ...config,
+      depth: 2,
+      getParams: () => {
+        return {
+          [event.paramId]: "value"
+        };
+      },
+      getComponentPackageName: (props) => {
+        if (props == null ? void 0 : props.meta.global) {
+          return "";
+        }
+        return config.getComponentPackageName(props);
+      },
+      addParentDependencyImport: globalAddDependencyImport,
+      getComponentMeta: config.getComponentMeta,
+      getCurrentScene: () => {
+        return tojson.global;
+      }
+    });
+    globalVarsRegisterChangeCode += `
+${indent2}this.${com.title}.registerChange((value: any) => {
+${res}
+${indent2}})`;
+    globalVarsInitCode += `${indent}${com.title}: any = createVariable(${JSON.stringify(com.model.data.initValue || {})})
+`;
+  });
+  let globalFxsInitCode = "";
+  globalFxs.forEach((event) => {
+    const currentScene = tojson.global.fxFrames.find(
+      (fxFrame) => fxFrame.id === event.frameId
+    );
+    const res = (0, import_handleProcess.handleProcess)(event, {
+      ...config,
+      depth: 2,
+      getCurrentScene: () => {
+        return currentScene;
+      },
+      getParams: () => {
+        return event.paramPins.reduce(
+          (pre, cur, index) => {
+            pre[cur.id] = `value${index}`;
+            return pre;
+          },
+          {}
+        );
+      },
+      getComponentPackageName: (props) => {
+        if (props == null ? void 0 : props.meta.global) {
+          return "";
+        }
+        return config.getComponentPackageName(props);
+      },
+      addParentDependencyImport: (params2) => {
+        const { dependencyNames } = params2;
+        const filterDependencyNames = dependencyNames.filter(
+          (dependencyName) => {
+            return !["globalVars", "globalFxs"].includes(dependencyName);
+          }
+        );
+        if (filterDependencyNames.length) {
+          globalAddDependencyImport({
+            ...params2,
+            dependencyNames: filterDependencyNames
+          });
+        }
+      },
+      getComponentMeta: config.getComponentMeta
+    });
+    const values = event.paramPins.map((paramPin, index) => {
+      if (paramPin.type === "config") {
+        return `value${index}: any = ${JSON.stringify(event.initValues[paramPin.id])}`;
+      }
+      return `value${index}: any`;
+    }).join(", ");
+    globalFxsInitCode += `${indent}/** ${event.title} */
+${indent}${event.frameId}: any = createFx((${values}) => {
+${res}
+${indent}})
+`;
+  });
+  const varCode = `/** 全局变量 */
+class GlobalVars {
+${globalVarsInitCode}
+${indent}init() {${globalVarsRegisterChangeCode}
+${indent}}
+}
+
+export const globalVars = new GlobalVars()`;
+  const fxCode = `/** 全局Fx */
+class GlobalFxs {
+${globalFxsInitCode}}
+
+export const globalFxs = new GlobalFxs()`;
+  if (fxCode.includes("merge(")) {
+    globalAddDependencyImport({
+      packageName: config.getUtilsPackageName(),
+      dependencyNames: ["merge"],
+      importType: "named"
+    });
+  }
+  return {
+    type: "global",
+    content: varCode + "\n\n" + fxCode,
+    importManager: globalImportManager,
+    name: "global"
+  };
+};
+var handleGlobal_default = handleGlobal;

package/dist/cjs/handleModule.d.ts

@@ -0,0 +1,15 @@
+import type { UI, BaseConfig } from "./toCodeTaro";
+import { ImportManager } from "./utils";
+type Module = Extract<UI["children"][0], {
+    type: "module";
+}>;
+interface HandleModuleConfig extends BaseConfig {
+    addParentDependencyImport: (typeof ImportManager)["prototype"]["addImport"];
+    addConsumer: (provider: ReturnType<BaseConfig["getCurrentProvider"]>) => void;
+    addComId: (comId: string) => void;
+}
+declare const handleModule: (module: Module, config: HandleModuleConfig) => {
+    ui: string;
+    cssContent: string;
+};
+export default handleModule;

package/dist/cjs/handleModule.js

@@ -0,0 +1,108 @@
+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/handleModule.ts
+var handleModule_exports = {};
+__export(handleModule_exports, {
+  default: () => handleModule_default
+});
+module.exports = __toCommonJS(handleModule_exports);
+var import_utils = require("./utils");
+var import_handleProcess = require("./utils/handleProcess");
+var handleModule = (module2, config) => {
+  var _a, _b, _c;
+  const { events, moduleId, props } = module2;
+  const moduleScene = config.getSceneById(moduleId);
+  const rawName = ((_a = config.getFileName) == null ? void 0 : _a.call(config, moduleId)) || moduleScene.title;
+  const name = (0, import_utils.firstCharToUpperCase)(rawName);
+  let comEventCode = "";
+  const indent = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 1));
+  Object.entries(events).forEach(([eventId, { diagramId }]) => {
+    if (!diagramId) {
+      return;
+    }
+    const event = config.getEventByDiagramId(diagramId);
+    if (!event) {
+      return;
+    }
+    const defaultValue = "value";
+    let process = (0, import_handleProcess.handleProcess)(event, {
+      ...config,
+      depth: config.depth + 2,
+      addParentDependencyImport: config.addParentDependencyImport,
+      getParams: () => {
+        return {
+          [eventId]: defaultValue
+        };
+      }
+    });
+    if (process.includes("pageParams")) {
+      config.addParentDependencyImport({
+        packageName: config.getComponentPackageName(),
+        dependencyNames: ["page"],
+        importType: "named"
+      });
+      process = (0, import_utils.indentation)(config.codeStyle.indent * (config.depth + 2)) + `const pageParams: any = page.getParams("${config.getCurrentScene().id}");
+` + process;
+    }
+    comEventCode += `${indent}${eventId}: (${defaultValue}: any) => {
+` + process + `
+${indent}},
+`;
+  });
+  config.addParentDependencyImport({
+    packageName: "../sections/Index",
+    dependencyNames: [name],
+    importType: "named"
+  });
+  const configs = module2.meta.model.data.configs;
+  const currentProvider = config.getCurrentProvider();
+  currentProvider.coms.add(module2.meta.id);
+  currentProvider.controllers.add(module2.meta.id);
+  const resultStyle = (0, import_utils.convertComponentStyle)(module2.props.style);
+  const cssContent = (0, import_utils.convertStyleAryToCss)((_b = props.style) == null ? void 0 : _b.styleAry, module2.meta.id);
+  const componentController = ((_c = config.getComponentController) == null ? void 0 : _c.call(config, {
+    com: module2.meta,
+    scene: config.getCurrentScene()
+  })) || `controller_${module2.meta.id}`;
+  const initialIndent = config.codeStyle.indent * config.depth;
+  const indentView = (0, import_utils.indentation)(initialIndent);
+  const indent2 = (0, import_utils.indentation)(initialIndent + config.codeStyle.indent);
+  const indent3 = (0, import_utils.indentation)(initialIndent + config.codeStyle.indent * 2);
+  const moduleCode = `${indent2}<${name}` + (config.verbose ? `
+${indent3}title="${module2.meta.title}"` : "") + (configs ? `
+${indent3}data={${(0, import_utils.genObjectCode)(configs, {
+    initialIndent: initialIndent + config.codeStyle.indent * 2,
+    indentSize: config.codeStyle.indent
+  })}}` : "") + `
+${indent3}controller={this.${currentProvider.name}.${componentController}}` + (comEventCode ? `
+${indent3}onEvents={{${comEventCode.replace(/\n/g, "\n" + indent3)}}}` : "") + `
+${indent2}/>`;
+  const ui = `${indentView}<View id="${module2.meta.id}" className="${module2.meta.id}" style={${JSON.stringify(resultStyle.root)}}>
+${moduleCode}
+${indentView}</View>`;
+  return {
+    ui,
+    cssContent
+  };
+  return {
+    ui,
+    cssContent
+  };
+};
+var handleModule_default = handleModule;

package/dist/cjs/handleSlot.d.ts

@@ -0,0 +1,27 @@
+import { ImportManager } from "./utils";
+import { RenderManager } from "./utils/code/renderManager";
+import type { UI, BaseConfig } from "./toCodeTaro";
+interface HandleSlotConfig extends BaseConfig {
+    addParentDependencyImport?: (typeof ImportManager)["prototype"]["addImport"];
+    addComId?: (comId: string) => void;
+    addConsumer?: (provider: ReturnType<BaseConfig["getCurrentProvider"]>) => void;
+    checkIsRoot: () => boolean;
+    renderManager?: RenderManager;
+    addJSModule?: (module: {
+        id: string;
+        title: string;
+        transformCode: string;
+        inputs: string[];
+        outputs: string[];
+        data: any;
+    }) => void;
+}
+declare const handleSlot: (ui: UI, config: HandleSlotConfig) => {
+    js: string;
+    combinedJsCode: string;
+    ui: string;
+    cssContent: string;
+    slots: any[];
+    scopeSlots: any[];
+};
+export default handleSlot;

package/dist/cjs/handleSlot.js

@@ -0,0 +1,197 @@
+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/handleSlot.ts
+var handleSlot_exports = {};
+__export(handleSlot_exports, {
+  default: () => handleSlot_default
+});
+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 handleSlot = (ui, config) => {
+  var _a, _b, _c, _d, _e, _f;
+  const importManager = new import_utils.ImportManager(config);
+  const { props = {}, children = [] } = ui;
+  let uiCode = "";
+  let jsCode = "";
+  let effectCode = "";
+  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);
+  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 = {
+    ...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 ? `
+${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
+    });
+  }
+  return {
+    js: jsCode,
+    combinedJsCode,
+    ui: uiResult,
+    cssContent,
+    slots: [],
+    scopeSlots: []
+  };
+};
+var handleSlot_default = handleSlot;

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './toCodeTaro';
+export { default as generateTaroProjectJson } from './generate/generateTaroProjectJson';
+export { default as generateTaroTempalteJson } from './generate/generateTaroTempalteJson';

package/dist/cjs/index.js

@@ -0,0 +1,44 @@
+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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => import_toCodeTaro.default,
+  generateTaroProjectJson: () => import_generateTaroProjectJson.default,
+  generateTaroTempalteJson: () => import_generateTaroTempalteJson.default
+});
+module.exports = __toCommonJS(src_exports);
+var import_toCodeTaro = __toESM(require("./toCodeTaro"));
+var import_generateTaroProjectJson = __toESM(require("./generate/generateTaroProjectJson"));
+var import_generateTaroTempalteJson = __toESM(require("./generate/generateTaroTempalteJson"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateTaroProjectJson,
+  generateTaroTempalteJson
+});