@mybricks/to-code-taro 1.0.0

package/dist/cjs/core/mybricks/index.js

@@ -0,0 +1,871 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/mybricks/index.js
+var mybricks_exports = {};
+__export(mybricks_exports, {
+  BaseController: () => BaseController,
+  Page: () => Page,
+  Vars: () => Vars,
+  createBus: () => createBus,
+  createData: () => createData,
+  createEventsHandle: () => createEventsHandle,
+  createFx: () => createFx,
+  createInputsHandle: () => createInputsHandle,
+  createModifier: () => createModifier,
+  createModuleInputsHandle: () => createModuleInputsHandle,
+  createSlotsIO: () => createSlotsIO,
+  createStyles: () => createStyles,
+  emit: () => emit,
+  join: () => join,
+  merge: () => merge,
+  pageController: () => pageController,
+  transformApi: () => transformApi,
+  transformBus: () => transformBus
+});
+module.exports = __toCommonJS(mybricks_exports);
+var import_constant = require("./constant");
+var import_log = require("./log");
+var import_Subject = require("./Subject");
+var import_context = require("./context");
+var import_utils = require("./utils");
+var import_createReactiveInputHandler = require("./createReactiveInputHandler");
+__reExport(mybricks_exports, require("./MyBricksDescriptor"), module.exports);
+__reExport(mybricks_exports, require("./createModuleEventsHandle"), module.exports);
+__reExport(mybricks_exports, require("./createJSHandle"), module.exports);
+__reExport(mybricks_exports, require("./Subject"), module.exports);
+__reExport(mybricks_exports, require("./createEnv"), module.exports);
+__reExport(mybricks_exports, require("./variables"), module.exports);
+__reExport(mybricks_exports, require("./event"), module.exports);
+var merge = (...subjects) => {
+  const merge2 = new import_Subject.Subject();
+  subjects.forEach((subject) => {
+    if (subject == null ? void 0 : subject[SUBJECT_SUBSCRIBE]) {
+      subject[SUBJECT_SUBSCRIBE]((value) => {
+        merge2[import_constant.SUBJECT_NEXT](value);
+      });
+    } else {
+      merge2[import_constant.SUBJECT_NEXT](subject);
+    }
+  });
+  return merge2;
+};
+var createInputsHandle = (params, init = false) => {
+  var _a;
+  if (init) {
+    const _inputEvents = {};
+    const _inputEventsTodo = {};
+    const _comInfo = {};
+    const controllerContext = {
+      initStyles: {},
+      initData: {},
+      dataChangedSubjects: {},
+      // 唯一标记
+      mark: {}
+    };
+    const proxy = new Proxy({}, {
+      get(_, key) {
+        if (key === "_inputEvents") {
+          return _inputEvents;
+        } else if (key === "_inputEventsTodo") {
+          return _inputEventsTodo;
+        } else if (key === "_comInfo") {
+          return _comInfo;
+        } else if (key === import_constant.CONTROLLER_CONTEXT) {
+          return controllerContext;
+        } else if (key === "_setStyle") {
+          return (value0, value1) => {
+            const next = (value) => {
+              if (Object.prototype.toString.call(value) === "[object Object]") {
+                Object.entries(value).forEach(([selector, nextStyle]) => {
+                  if (!controllerContext.styles) {
+                    const { initStyles } = controllerContext;
+                    if (!initStyles[selector]) {
+                      initStyles[selector] = nextStyle;
+                    } else {
+                      const initStyle = initStyles[selector];
+                      Object.entries(nextStyle).forEach(([key2, value2]) => {
+                        initStyle[key2] = value2;
+                      });
+                    }
+                    return;
+                  }
+                  const { style } = controllerContext.styles.getStyle(selector);
+                  const updators = controllerContext.styles.getUpdators(selector);
+                  Object.entries(nextStyle).forEach(([key2, value2]) => {
+                    style[key2] = value2;
+                  });
+                  if (updators) {
+                    updators.forEach((updator) => {
+                      updator(selector, style);
+                    });
+                  }
+                });
+              }
+            };
+            if (typeof value0 === "string" && value1) {
+              if (value1 == null ? void 0 : value1[SUBJECT_SUBSCRIBE]) {
+                value1[SUBJECT_SUBSCRIBE]((value) => {
+                  next({
+                    [value0]: value
+                  });
+                });
+              } else {
+                next({
+                  [value0]: value1
+                });
+              }
+            } else {
+              if (value0 == null ? void 0 : value0[SUBJECT_SUBSCRIBE]) {
+                value0[SUBJECT_SUBSCRIBE]((value) => {
+                  next(value);
+                });
+              } else {
+                next(value0);
+              }
+            }
+          };
+        } else if (key === "_setData") {
+          return (...args) => {
+            if (args.length === 2) {
+              const [path, value] = args;
+              const next = (params2) => {
+                const { path: path2, value: value2 } = params2;
+                if (!controllerContext.data) {
+                  const { initData } = controllerContext;
+                  initData[path2] = value2;
+                  return;
+                }
+                (0, import_utils.safeSetByPath)({
+                  data: controllerContext.data,
+                  path: path2.split("."),
+                  value: {
+                    value: value2,
+                    [import_constant.EXCUTE_TYPE_KEY]: import_constant.EXCUTE_TYPE_VALUE.DATACHANGED
+                  }
+                });
+              };
+              if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+                value[SUBJECT_SUBSCRIBE]((value2, extra) => {
+                  if ((extra == null ? void 0 : extra[import_constant.EXCUTE_TYPE_KEY]) === import_constant.EXCUTE_TYPE_VALUE.DATACHANGED && (extra == null ? void 0 : extra.controllerMark) === controllerContext.mark) {
+                    return;
+                  }
+                  next({ value: value2, path });
+                });
+              } else {
+                next({ value, path });
+              }
+            }
+          };
+        } else if (key === "_dataChanged") {
+          return (path) => {
+            const subject = new import_Subject.Subject();
+            controllerContext.dataChangedSubjects[path] = subject;
+            return subject;
+          };
+        }
+        return (value) => {
+          if (!_inputEvents[key]) {
+            if (!_inputEventsTodo[key]) {
+              _inputEventsTodo[key] = [];
+            }
+            const rels = {};
+            _inputEventsTodo[key].push({
+              value,
+              rels
+            });
+            return new Proxy({}, {
+              get(_2, key2) {
+                return rels[key2] || (rels[key2] = new import_Subject.Subject());
+              }
+            });
+          }
+          return (0, import_createReactiveInputHandler.createReactiveInputHandler)({
+            input(value2, proxy2) {
+              (0, import_log.log)(`${import_constant.EXE_TITLE_MAP["input"]} ${_comInfo.title} | ${key}`, JSON.stringify(value2));
+              return _inputEvents[key](value2, proxy2);
+            },
+            title: _comInfo.title,
+            value,
+            rels: {}
+          });
+        };
+      }
+    });
+    return proxy;
+  } else {
+    if (!params.controller[import_constant.CONTROLLER_CONTEXT].inputs) {
+      const { controller, title, styles } = params;
+      const { _inputEvents, _comInfo, _inputEventsTodo, [import_constant.CONTROLLER_CONTEXT]: controllerContext } = controller;
+      _comInfo.title = title;
+      controllerContext.initModifier = {
+        visibility: ((_a = styles == null ? void 0 : styles.root) == null ? void 0 : _a.display) === "none" ? Visibility.None : Visibility.Visible
+      };
+      const createVisibilityHandler = (visibilityState) => {
+        return (value) => {
+          const setVisibility = () => {
+            var _a2, _b;
+            if (!((_a2 = controllerContext.modifier) == null ? void 0 : _a2.attribute)) {
+              controllerContext.initModifier.visibility = visibilityState;
+            } else {
+              (_b = controllerContext.modifier.attribute) == null ? void 0 : _b.visibility(visibilityState);
+            }
+          };
+          if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+            value[SUBJECT_SUBSCRIBE](setVisibility);
+          } else {
+            setVisibility();
+          }
+        };
+      };
+      _inputEvents.show = createVisibilityHandler(Visibility.Visible);
+      _inputEvents.hide = createVisibilityHandler(Visibility.None);
+      _inputEvents.showOrHide = (value) => {
+        const setVisibility = (value2) => {
+          var _a2, _b;
+          if (!((_a2 = controllerContext.modifier) == null ? void 0 : _a2.attribute)) {
+            controllerContext.initModifier.visibility = !!value2 ? Visibility.Visible : Visibility.None;
+          } else {
+            (_b = controllerContext.modifier.attribute) == null ? void 0 : _b.visibility(!!value2 ? Visibility.Visible : Visibility.None);
+          }
+        };
+        if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+          value[SUBJECT_SUBSCRIBE](setVisibility);
+        } else {
+          setVisibility(value);
+        }
+      };
+      ["show", "hide", "showOrHide"].forEach((key) => {
+        const todo = _inputEventsTodo[key];
+        if (todo) {
+          Reflect.deleteProperty(_inputEventsTodo, key);
+          todo.forEach(({ value }) => {
+            _inputEvents[key](value);
+          });
+        }
+      });
+      const proxy = new Proxy(controller, {
+        get(_, key) {
+          return (input) => {
+            if (!_inputEvents[key]) {
+              if (_inputEventsTodo[key]) {
+                _inputEventsTodo[key].forEach(({ value, rels }) => {
+                  (0, import_createReactiveInputHandler.createReactiveInputHandler)({
+                    input(value2, proxy2) {
+                      (0, import_log.log)(`${import_constant.EXE_TITLE_MAP["input"]} ${title} | ${key}`, JSON.stringify(value2));
+                      return input(value2, proxy2);
+                    },
+                    title,
+                    value,
+                    rels
+                  });
+                });
+                Reflect.deleteProperty(_inputEventsTodo, key);
+              }
+            }
+            _inputEvents[key] = input;
+          };
+        }
+      });
+      params.controller[import_constant.CONTROLLER_CONTEXT].inputs = proxy;
+    }
+    return params.controller[import_constant.CONTROLLER_CONTEXT].inputs;
+  }
+};
+var createEventsHandle = (params) => {
+  if (!params.controller[import_constant.CONTROLLER_CONTEXT].outputs) {
+    params.controller[import_constant.CONTROLLER_CONTEXT].outputs = new Proxy(params.events || {}, {
+      get(target, key) {
+        var _a, _b, _c;
+        const event = (_c = (_b = (_a = params.controller[import_constant.CONTROLLER_CONTEXT].appContext) == null ? void 0 : _a.comEvent) == null ? void 0 : _b[params.uid]) == null ? void 0 : _c[key];
+        if (event) {
+          const { getVar, getOutput, getInput } = params.controller[import_constant.CONTROLLER_CONTEXT];
+          return (value) => {
+            event(value, {
+              getVar,
+              getOutput,
+              getInput
+            });
+          };
+        }
+        return target[key] || (() => {
+        });
+      }
+    });
+  }
+  return params.controller[import_constant.CONTROLLER_CONTEXT].outputs;
+};
+var pageController = () => {
+  return new Proxy({
+    commit: new import_Subject.Subject(),
+    cancel: new import_Subject.Subject(),
+    apply: new import_Subject.Subject(),
+    close: new import_Subject.Subject()
+  }, {
+    get(target, key) {
+      return target[key];
+    }
+  });
+};
+var Page = class {
+  appRouter;
+  constructor(appRouter) {
+    this.appRouter = appRouter;
+  }
+  /** 获取当前页面入参 */
+  getParams(name) {
+    const params = this.appRouter.getParams(name);
+    const subject = new import_Subject.Subject();
+    subject[import_constant.SUBJECT_NEXT](params == null ? void 0 : params.value);
+    return subject;
+  }
+  /** 打开 */
+  open(name, value) {
+    const controller = pageController();
+    if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+      value[SUBJECT_SUBSCRIBE]((value2) => {
+        this.appRouter.push(name, { value: value2, controller });
+      });
+    } else {
+      this.appRouter.push(name, { value, controller });
+    }
+    return controller;
+  }
+  /** 打开 */
+  replace(name, value) {
+    const controller = pageController();
+    if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+      value[SUBJECT_SUBSCRIBE]((value2) => {
+        this.appRouter.replace(name, { value: value2, controller });
+      });
+    } else {
+      this.appRouter.replace(name, { value, controller });
+    }
+    return controller;
+  }
+  /** 确定 */
+  commit(name, value) {
+    const params = this.appRouter.getParams(name);
+    if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+      value[SUBJECT_SUBSCRIBE]((value2) => {
+        this.appRouter.pop();
+        setTimeout(() => {
+          params.controller.commit[import_constant.SUBJECT_NEXT](value2);
+        }, 100);
+      });
+    } else {
+      this.appRouter.pop();
+      setTimeout(() => {
+        params.controller.commit[import_constant.SUBJECT_NEXT](value);
+      }, 100);
+    }
+  }
+  /** 取消 */
+  cancel(name, value) {
+    const params = this.appRouter.getParams(name);
+    if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+      value[SUBJECT_SUBSCRIBE]((value2) => {
+        this.appRouter.pop();
+        setTimeout(() => {
+          params.controller.cancel[import_constant.SUBJECT_NEXT](value2);
+        }, 100);
+      });
+    } else {
+      this.appRouter.pop();
+      setTimeout(() => {
+        params.controller.cancel[import_constant.SUBJECT_NEXT](value);
+      }, 100);
+    }
+  }
+  /** 应用，不关闭 */
+  apply(name, value) {
+    const params = this.appRouter.getParams(name);
+    if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+      value[SUBJECT_SUBSCRIBE]((value2) => {
+        params.controller.apply[import_constant.SUBJECT_NEXT](value2);
+      });
+    } else {
+      params.controller.apply[import_constant.SUBJECT_NEXT](value);
+    }
+  }
+  /** 关闭 */
+  close(name, value) {
+    const params = this.appRouter.getParams(name);
+    if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+      value[SUBJECT_SUBSCRIBE]((value2) => {
+        this.appRouter.pop();
+        setTimeout(() => {
+          params.controller.close[import_constant.SUBJECT_NEXT](value2);
+        }, 100);
+      });
+    } else {
+      this.appRouter.pop();
+      setTimeout(() => {
+        params.controller.close[import_constant.SUBJECT_NEXT](value);
+      }, 100);
+    }
+  }
+};
+var emit = (fn, value) => {
+  const subject = new import_Subject.Subject();
+  if (!fn) {
+    return subject;
+  }
+  if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+    value[SUBJECT_SUBSCRIBE]((value2) => {
+      const res = fn(value2);
+      if (res instanceof Promise) {
+        res.then((value3) => {
+          subject[import_constant.SUBJECT_NEXT](value3);
+        });
+      } else {
+        subject[import_constant.SUBJECT_NEXT](res);
+      }
+    });
+  } else {
+    const res = fn(value);
+    if (res instanceof Promise) {
+      res.then((value2) => {
+        subject[import_constant.SUBJECT_NEXT](value2);
+      });
+    } else {
+      subject[import_constant.SUBJECT_NEXT](res);
+    }
+  }
+  return subject;
+};
+var createFx = (fx) => {
+  return (value, ...args) => {
+    const outputs = {};
+    const proxy = new Proxy({}, {
+      get(_, key) {
+        return outputs[key] || (outputs[key] = new import_Subject.Subject());
+      }
+    });
+    const next = (value2) => {
+      const res = fx(value2, ...args);
+      if (res) {
+        Object.entries(res).forEach(([key, value3]) => {
+          if (!outputs[key]) {
+            outputs[key] = new import_Subject.Subject();
+          }
+          if (value3 == null ? void 0 : value3[SUBJECT_SUBSCRIBE]) {
+            value3[SUBJECT_SUBSCRIBE]((value4) => {
+              outputs[key][import_constant.SUBJECT_NEXT](value4);
+            });
+          } else {
+            outputs[key][import_constant.SUBJECT_NEXT](value3);
+          }
+        });
+      }
+    };
+    if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+      value[SUBJECT_SUBSCRIBE]((value2) => {
+        next(value2);
+      });
+    } else {
+      next(value);
+    }
+    return proxy;
+  };
+};
+var createSlotsIO = (params) => {
+  if (!params.controller[import_constant.CONTROLLER_CONTEXT].slotsIO) {
+    const slotsIOMap = {};
+    params.controller[import_constant.CONTROLLER_CONTEXT].slotsIO = new Proxy({}, {
+      get(_, key) {
+        if (!slotsIOMap[key]) {
+          const inputsMap = {};
+          slotsIOMap[key] = {
+            inputs: new Proxy({}, {
+              get(_2, key2) {
+                if (!inputsMap[key2]) {
+                  inputsMap[key2] = new import_Subject.Subject();
+                }
+                const next = (value) => {
+                  inputsMap[key2][import_constant.SUBJECT_NEXT](value);
+                };
+                next[SUBJECT_SUBSCRIBE] = (next2) => {
+                  inputsMap[key2][SUBJECT_SUBSCRIBE](next2);
+                };
+                return next;
+              }
+            }),
+            outputs: new Proxy({}, {
+              get(_2, key2) {
+                return (next) => {
+                  return (value) => {
+                    if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+                      value[SUBJECT_SUBSCRIBE]((value2) => {
+                        next(value2);
+                      });
+                    } else {
+                      next(value);
+                    }
+                  };
+                };
+              }
+            })
+          };
+        }
+        return slotsIOMap[key];
+      }
+    });
+  }
+  return params.controller[import_constant.CONTROLLER_CONTEXT].slotsIO;
+};
+var createModuleInputsHandle = () => {
+  const inputsMap = {};
+  const outputsMap = {};
+  return new Proxy({}, {
+    get(_, key) {
+      if (key === "outputs") {
+        return new Proxy({}, {
+          get(_2, key2) {
+            if (!outputsMap[key2]) {
+              outputsMap[key2] = new import_Subject.Subject();
+            }
+            return (value) => {
+              if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+                value[SUBJECT_SUBSCRIBE]((value2) => {
+                  outputsMap[key2][import_constant.SUBJECT_NEXT](value2);
+                });
+              } else {
+                outputsMap[key2][import_constant.SUBJECT_NEXT](value);
+              }
+            };
+          }
+        });
+      }
+      if (!inputsMap[key]) {
+        inputsMap[key] = new import_Subject.Subject();
+      }
+      const next = (value) => {
+        if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+          value[SUBJECT_SUBSCRIBE]((value2) => {
+            inputsMap[key][import_constant.SUBJECT_NEXT](value2);
+          });
+        } else {
+          inputsMap[key][import_constant.SUBJECT_NEXT](value);
+        }
+        return new Proxy({}, {
+          get(_2, key2) {
+            return outputsMap[key2] || (outputsMap[key2] = new import_Subject.Subject());
+          }
+        });
+      };
+      return new Proxy(next, {
+        get(_2, proxyKey) {
+          if (proxyKey === "subscribe" || proxyKey === SUBJECT_SUBSCRIBE) {
+            return (next2) => {
+              inputsMap[key][SUBJECT_SUBSCRIBE](next2);
+            };
+          } else if (proxyKey === "value" || proxyKey === import_constant.SUBJECT_VALUE) {
+            return inputsMap[key][import_constant.SUBJECT_VALUE];
+          }
+        }
+      });
+    }
+  });
+};
+var Styles = class {
+  styles = {};
+  map = /* @__PURE__ */ new Map();
+  constructor(styles) {
+    this.styles = styles;
+  }
+  getStyle(selector) {
+    let style = this.styles[selector];
+    if (!style) {
+      this.styles[selector] = {};
+      style = this.styles[selector];
+    }
+    return {
+      selector,
+      style,
+      setUpdator: (updator, uid) => {
+        if (!this.map.has(selector)) {
+          this.map.set(selector, /* @__PURE__ */ new Map());
+        }
+        const selectorMap = this.map.get(selector);
+        selectorMap.set(uid, updator);
+      },
+      ...style
+    };
+  }
+  getUpdators(selector) {
+    return this.map.get(selector);
+  }
+};
+var createStyles = (params) => {
+  if (!params.controller[import_constant.CONTROLLER_CONTEXT].styles) {
+    const initStyles = params.controller[import_constant.CONTROLLER_CONTEXT].initStyles;
+    const { styles, parentSlot } = params;
+    Object.entries(initStyles).forEach(([selector, initStyle]) => {
+      if (!styles[selector]) {
+        styles[selector] = initStyle;
+      } else {
+        const style = styles[selector];
+        Object.entries(initStyle).forEach(([key, value]) => {
+          style[key] = value;
+        });
+      }
+    });
+    if (parentSlot == null ? void 0 : parentSlot.itemWrap) {
+      const { root, ...other } = styles;
+      params.controller[import_constant.CONTROLLER_CONTEXT].styles = new Styles(other);
+    } else {
+      params.controller[import_constant.CONTROLLER_CONTEXT].styles = new Styles(styles);
+    }
+  }
+  return new Proxy({}, {
+    ownKeys() {
+      return Object.keys(params.styles);
+    },
+    getOwnPropertyDescriptor(k) {
+      return {
+        enumerable: true,
+        configurable: true
+      };
+    },
+    get(_, key) {
+      return params.controller[import_constant.CONTROLLER_CONTEXT].styles.getStyle(key);
+    }
+  });
+};
+var transformApi = (api) => {
+  return (value, cb) => {
+    const id = `${Math.random()}_${(/* @__PURE__ */ new Date()).getTime()}`;
+    const outputs = {};
+    const dispose = () => {
+    };
+    const proxy = new Proxy(dispose, {
+      get(_, key) {
+        return outputs[key] || (outputs[key] = new import_Subject.Subject());
+      }
+    });
+    let isDispose = false;
+    import_context.context.apiRun = id;
+    const res = api(value);
+    import_context.context.apiRun = null;
+    if (res) {
+      Object.entries(res).forEach(([key, value2]) => {
+        var _a, _b;
+        if (!outputs[key]) {
+          outputs[key] = new import_Subject.Subject();
+        }
+        if (value2 == null ? void 0 : value2[SUBJECT_SUBSCRIBE]) {
+          value2[SUBJECT_SUBSCRIBE]((value3) => {
+            var _a2, _b2;
+            if (isDispose) {
+              return;
+            }
+            isDispose = true;
+            outputs[key][import_constant.SUBJECT_NEXT](value3);
+            (_a2 = cb == null ? void 0 : cb[key]) == null ? void 0 : _a2.call(cb, value3);
+            (_b2 = import_context.context.apiRunVariablesSubject[id]) == null ? void 0 : _b2.forEach((subject) => {
+              subject.destroy();
+            });
+          });
+        } else {
+          if (isDispose) {
+            return;
+          }
+          isDispose = true;
+          outputs[key][import_constant.SUBJECT_NEXT](value2);
+          (_a = cb == null ? void 0 : cb[key]) == null ? void 0 : _a.call(cb, value2);
+          (_b = import_context.context.apiRunVariablesSubject[id]) == null ? void 0 : _b.forEach((subject) => {
+            subject.destroy();
+          });
+        }
+      });
+    }
+    return proxy;
+  };
+};
+var transformBus = (bus) => {
+  return (newBus) => {
+    Object.entries(newBus).forEach(([key, newBus2]) => {
+      bus[key] = (value) => {
+        const outputs = {};
+        const callBack = new Proxy({}, {
+          get(_, key2) {
+            return (value2) => {
+              const output = outputs[key2] || (outputs[key2] = new import_Subject.Subject());
+              output[import_constant.SUBJECT_NEXT](value2);
+            };
+          }
+        });
+        if (value == null ? void 0 : value[SUBJECT_SUBSCRIBE]) {
+          value[SUBJECT_SUBSCRIBE]((value2) => {
+            newBus2(value2, callBack);
+          });
+        } else {
+          newBus2(value, callBack);
+        }
+        return new Proxy({}, {
+          get(_, key2) {
+            return outputs[key2] || (outputs[key2] = new import_Subject.Subject());
+          }
+        });
+      };
+    });
+  };
+};
+var createBus = (bus) => {
+  return () => {
+    return new Proxy({}, {
+      get() {
+        return new import_Subject.Subject();
+      }
+    });
+  };
+};
+var join = (lastSubject, nextSubject) => {
+  const subject = new import_Subject.Subject();
+  const next = () => {
+    if (nextSubject == null ? void 0 : nextSubject[SUBJECT_SUBSCRIBE]) {
+      subject[import_constant.SUBJECT_NEXT](nextSubject[import_constant.SUBJECT_VALUE]);
+    } else {
+      subject[import_constant.SUBJECT_NEXT](nextSubject);
+    }
+  };
+  if (lastSubject == null ? void 0 : lastSubject[SUBJECT_SUBSCRIBE]) {
+    lastSubject[SUBJECT_SUBSCRIBE](() => {
+      next();
+    });
+  } else {
+    next();
+  }
+  return subject;
+};
+var createModifier = (params, Modifier) => {
+  if (!params.controller[import_constant.CONTROLLER_CONTEXT].modifier) {
+    params.controller[import_constant.CONTROLLER_CONTEXT].modifier = new Modifier(params.controller[import_constant.CONTROLLER_CONTEXT].initModifier);
+  }
+  return params.controller[import_constant.CONTROLLER_CONTEXT].modifier;
+};
+var DATA_PROXY = Symbol("DATA_PROXY");
+var dataProxy = (params) => {
+  const { data, path, config } = params;
+  return new Proxy(data, {
+    get(target, key, receiver) {
+      if (key === DATA_PROXY) {
+        return true;
+      }
+      const value = Reflect.get(target, key, receiver);
+      if (typeof key !== "string" || target.hasOwnProperty(key)) {
+        return value;
+      }
+      if ((0, import_utils.isObject)(value)) {
+        if (value[DATA_PROXY]) {
+          return value;
+        }
+        return dataProxy({
+          data: value,
+          path: path ? `${path}.${key}` : key,
+          config
+        });
+      }
+      return value;
+    },
+    set(target, key, value, receiver) {
+      var _a;
+      if (typeof key !== "string" || target.hasOwnProperty(key)) {
+        Reflect.set(target, key, value, receiver);
+      } else {
+        if (!(value == null ? void 0 : value[import_constant.EXCUTE_TYPE_KEY])) {
+          Reflect.set(target, key, value, receiver);
+          (_a = config == null ? void 0 : config.set) == null ? void 0 : _a.call(config, {
+            value,
+            path: path ? `${path}.${key}` : key
+          });
+        } else {
+          Reflect.set(target, key, value.value, receiver);
+        }
+      }
+      return true;
+    }
+  });
+};
+var createData = (params, Data) => {
+  if (!params.controller[import_constant.CONTROLLER_CONTEXT].data) {
+    const { initData, dataChangedSubjects, mark } = params.controller[import_constant.CONTROLLER_CONTEXT];
+    const nextData = Object.assign({}, params.data);
+    Object.entries(initData).forEach(([path, value]) => {
+      (0, import_utils.safeSetByPath)({
+        data: nextData,
+        path: path.split("."),
+        value
+      });
+    });
+    const data = new Data(nextData);
+    const observeData = dataProxy({
+      data,
+      path: "",
+      config: {
+        set(params2) {
+          const dataChangedSubject = dataChangedSubjects[params2.path];
+          if (dataChangedSubject) {
+            dataChangedSubject[import_constant.SUBJECT_NEXT](params2.value, {
+              [import_constant.EXCUTE_TYPE_KEY]: import_constant.EXCUTE_TYPE_VALUE.DATACHANGED,
+              controllerMark: mark
+            });
+          }
+        }
+      }
+    });
+    params.controller[import_constant.CONTROLLER_CONTEXT].data = observeData;
+  }
+  return params.controller[import_constant.CONTROLLER_CONTEXT].data;
+};
+var Vars = class {
+  [import_constant.VARS_MARK] = true;
+};
+var BaseController = class {
+  [import_constant.BASECONTROLLER_MARK] = true;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseController,
+  Page,
+  Vars,
+  createBus,
+  createData,
+  createEventsHandle,
+  createFx,
+  createInputsHandle,
+  createModifier,
+  createModuleInputsHandle,
+  createSlotsIO,
+  createStyles,
+  emit,
+  join,
+  merge,
+  pageController,
+  transformApi,
+  transformBus,
+  ...require("./MyBricksDescriptor"),
+  ...require("./createModuleEventsHandle"),
+  ...require("./createJSHandle"),
+  ...require("./Subject"),
+  ...require("./createEnv"),
+  ...require("./variables"),
+  ...require("./event")
+});