@tachybase/schema 0.23.41 → 0.23.48

package/lib/core/models/Form.js

@@ -0,0 +1,483 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var Form_exports = {};
+__export(Form_exports, {
+  Form: () => Form
+});
+module.exports = __toCommonJS(Form_exports);
+var import_reactive = require("../../reactive");
+var import_shared = require("../../shared");
+var import_checkers = require("../shared/checkers");
+var import_effective = require("../shared/effective");
+var import_internals = require("../shared/internals");
+var import_types = require("../types");
+var import_ArrayField = require("./ArrayField");
+var import_Field = require("./Field");
+var import_Graph = require("./Graph");
+var import_Heart = require("./Heart");
+var import_ObjectField = require("./ObjectField");
+var import_Query = require("./Query");
+var import_VoidField = require("./VoidField");
+const DEV_TOOLS_HOOK = "__FORMILY_DEV_TOOLS_HOOK__";
+const _Form = class _Form {
+  constructor(props) {
+    this.displayName = "Form";
+    this.fields = {};
+    this.requests = {};
+    this.indexes = {};
+    this.disposers = [];
+    /** 创建字段 **/
+    this.createField = /* @__PURE__ */ __name((props) => {
+      const address = import_shared.FormPath.parse(props.basePath).concat(props.name);
+      const identifier = address.toString();
+      if (!identifier) return;
+      if (!this.fields[identifier] || this.props.designable) {
+        (0, import_reactive.batch)(() => {
+          new import_Field.Field(address, props, this, this.props.designable);
+        });
+        this.notify(import_types.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
+      }
+      return this.fields[identifier];
+    }, "createField");
+    this.createArrayField = /* @__PURE__ */ __name((props) => {
+      const address = import_shared.FormPath.parse(props.basePath).concat(props.name);
+      const identifier = address.toString();
+      if (!identifier) return;
+      if (!this.fields[identifier] || this.props.designable) {
+        (0, import_reactive.batch)(() => {
+          new import_ArrayField.ArrayField(
+            address,
+            {
+              ...props,
+              value: (0, import_shared.isArr)(props.value) ? props.value : []
+            },
+            this,
+            this.props.designable
+          );
+        });
+        this.notify(import_types.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
+      }
+      return this.fields[identifier];
+    }, "createArrayField");
+    this.createObjectField = /* @__PURE__ */ __name((props) => {
+      const address = import_shared.FormPath.parse(props.basePath).concat(props.name);
+      const identifier = address.toString();
+      if (!identifier) return;
+      if (!this.fields[identifier] || this.props.designable) {
+        (0, import_reactive.batch)(() => {
+          new import_ObjectField.ObjectField(
+            address,
+            {
+              ...props,
+              value: (0, import_shared.isObj)(props.value) ? props.value : {}
+            },
+            this,
+            this.props.designable
+          );
+        });
+        this.notify(import_types.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
+      }
+      return this.fields[identifier];
+    }, "createObjectField");
+    this.createVoidField = /* @__PURE__ */ __name((props) => {
+      const address = import_shared.FormPath.parse(props.basePath).concat(props.name);
+      const identifier = address.toString();
+      if (!identifier) return;
+      if (!this.fields[identifier] || this.props.designable) {
+        (0, import_reactive.batch)(() => {
+          new import_VoidField.VoidField(address, props, this, this.props.designable);
+        });
+        this.notify(import_types.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
+      }
+      return this.fields[identifier];
+    }, "createVoidField");
+    /** 状态操作模型 **/
+    this.setValues = /* @__PURE__ */ __name((values, strategy = "merge") => {
+      if (!(0, import_shared.isPlainObj)(values)) return;
+      if (strategy === "merge" || strategy === "deepMerge") {
+        (0, import_shared.merge)(this.values, values, {
+          // never reach
+          arrayMerge: /* @__PURE__ */ __name((target, source) => source, "arrayMerge"),
+          assign: true
+        });
+      } else if (strategy === "shallowMerge") {
+        Object.assign(this.values, values);
+      } else {
+        this.values = values;
+      }
+    }, "setValues");
+    this.setInitialValues = /* @__PURE__ */ __name((initialValues, strategy = "merge") => {
+      if (!(0, import_shared.isPlainObj)(initialValues)) return;
+      if (strategy === "merge" || strategy === "deepMerge") {
+        (0, import_shared.merge)(this.initialValues, initialValues, {
+          // never reach
+          arrayMerge: /* @__PURE__ */ __name((target, source) => source, "arrayMerge"),
+          assign: true
+        });
+      } else if (strategy === "shallowMerge") {
+        Object.assign(this.initialValues, initialValues);
+      } else {
+        this.initialValues = initialValues;
+      }
+    }, "setInitialValues");
+    this.setValuesIn = /* @__PURE__ */ __name((pattern, value) => {
+      import_shared.FormPath.setIn(this.values, pattern, value);
+    }, "setValuesIn");
+    this.deleteValuesIn = /* @__PURE__ */ __name((pattern) => {
+      import_shared.FormPath.deleteIn(this.values, pattern);
+    }, "deleteValuesIn");
+    this.existValuesIn = /* @__PURE__ */ __name((pattern) => {
+      return import_shared.FormPath.existIn(this.values, pattern);
+    }, "existValuesIn");
+    this.getValuesIn = /* @__PURE__ */ __name((pattern) => {
+      return import_shared.FormPath.getIn(this.values, pattern);
+    }, "getValuesIn");
+    this.setInitialValuesIn = /* @__PURE__ */ __name((pattern, initialValue) => {
+      import_shared.FormPath.setIn(this.initialValues, pattern, initialValue);
+    }, "setInitialValuesIn");
+    this.deleteInitialValuesIn = /* @__PURE__ */ __name((pattern) => {
+      import_shared.FormPath.deleteIn(this.initialValues, pattern);
+    }, "deleteInitialValuesIn");
+    this.existInitialValuesIn = /* @__PURE__ */ __name((pattern) => {
+      return import_shared.FormPath.existIn(this.initialValues, pattern);
+    }, "existInitialValuesIn");
+    this.getInitialValuesIn = /* @__PURE__ */ __name((pattern) => {
+      return import_shared.FormPath.getIn(this.initialValues, pattern);
+    }, "getInitialValuesIn");
+    this.setLoading = /* @__PURE__ */ __name((loading) => {
+      (0, import_internals.setLoading)(this, loading);
+    }, "setLoading");
+    this.setSubmitting = /* @__PURE__ */ __name((submitting) => {
+      (0, import_internals.setSubmitting)(this, submitting);
+    }, "setSubmitting");
+    this.setValidating = /* @__PURE__ */ __name((validating) => {
+      (0, import_internals.setValidating)(this, validating);
+    }, "setValidating");
+    this.setDisplay = /* @__PURE__ */ __name((display) => {
+      this.display = display;
+    }, "setDisplay");
+    this.setPattern = /* @__PURE__ */ __name((pattern) => {
+      this.pattern = pattern;
+    }, "setPattern");
+    this.addEffects = /* @__PURE__ */ __name((id, effects) => {
+      if (!this.heart.hasLifeCycles(id)) {
+        this.heart.addLifeCycles(id, (0, import_effective.runEffects)(this, effects));
+      }
+    }, "addEffects");
+    this.removeEffects = /* @__PURE__ */ __name((id) => {
+      this.heart.removeLifeCycles(id);
+    }, "removeEffects");
+    this.setEffects = /* @__PURE__ */ __name((effects) => {
+      this.heart.setLifeCycles((0, import_effective.runEffects)(this, effects));
+    }, "setEffects");
+    this.clearErrors = /* @__PURE__ */ __name((pattern = "*") => {
+      this.query(pattern).forEach((field) => {
+        if (!(0, import_checkers.isVoidField)(field)) {
+          field.setFeedback({
+            type: "error",
+            messages: []
+          });
+        }
+      });
+    }, "clearErrors");
+    this.clearWarnings = /* @__PURE__ */ __name((pattern = "*") => {
+      this.query(pattern).forEach((field) => {
+        if (!(0, import_checkers.isVoidField)(field)) {
+          field.setFeedback({
+            type: "warning",
+            messages: []
+          });
+        }
+      });
+    }, "clearWarnings");
+    this.clearSuccesses = /* @__PURE__ */ __name((pattern = "*") => {
+      this.query(pattern).forEach((field) => {
+        if (!(0, import_checkers.isVoidField)(field)) {
+          field.setFeedback({
+            type: "success",
+            messages: []
+          });
+        }
+      });
+    }, "clearSuccesses");
+    this.query = /* @__PURE__ */ __name((pattern) => {
+      return new import_Query.Query({
+        pattern,
+        base: "",
+        form: this
+      });
+    }, "query");
+    this.queryFeedbacks = /* @__PURE__ */ __name((search) => {
+      return this.query(search.address || search.path || "*").reduce((messages, field) => {
+        if ((0, import_checkers.isVoidField)(field)) return messages;
+        return messages.concat(
+          field.queryFeedbacks(search).map((feedback) => ({
+            ...feedback,
+            address: field.address.toString(),
+            path: field.path.toString()
+          })).filter((feedback) => feedback.messages.length > 0)
+        );
+      }, []);
+    }, "queryFeedbacks");
+    this.notify = /* @__PURE__ */ __name((type, payload) => {
+      this.heart.publish(type, payload ?? this);
+    }, "notify");
+    this.subscribe = /* @__PURE__ */ __name((subscriber) => {
+      return this.heart.subscribe(subscriber);
+    }, "subscribe");
+    this.unsubscribe = /* @__PURE__ */ __name((id) => {
+      this.heart.unsubscribe(id);
+    }, "unsubscribe");
+    /**事件钩子**/
+    this.onInit = /* @__PURE__ */ __name(() => {
+      this.initialized = true;
+      this.notify(import_types.LifeCycleTypes.ON_FORM_INIT);
+    }, "onInit");
+    this.onMount = /* @__PURE__ */ __name(() => {
+      this.mounted = true;
+      this.notify(import_types.LifeCycleTypes.ON_FORM_MOUNT);
+      if (import_shared.globalThisPolyfill[DEV_TOOLS_HOOK] && !this.props.designable) {
+        import_shared.globalThisPolyfill[DEV_TOOLS_HOOK].inject(this.id, this);
+      }
+    }, "onMount");
+    this.onUnmount = /* @__PURE__ */ __name(() => {
+      this.notify(import_types.LifeCycleTypes.ON_FORM_UNMOUNT);
+      this.query("*").forEach((field) => field.destroy(false));
+      this.disposers.forEach((dispose) => dispose());
+      this.unmounted = true;
+      this.indexes = {};
+      this.heart.clear();
+      if (import_shared.globalThisPolyfill[DEV_TOOLS_HOOK] && !this.props.designable) {
+        import_shared.globalThisPolyfill[DEV_TOOLS_HOOK].unmount(this.id);
+      }
+    }, "onUnmount");
+    this.setState = (0, import_internals.createStateSetter)(this);
+    this.getState = (0, import_internals.createStateGetter)(this);
+    this.setFormState = (0, import_internals.createStateSetter)(this);
+    this.getFormState = (0, import_internals.createStateGetter)(this);
+    this.setFieldState = (0, import_internals.createBatchStateSetter)(this);
+    this.getFieldState = (0, import_internals.createBatchStateGetter)(this);
+    this.getFormGraph = /* @__PURE__ */ __name(() => {
+      return this.graph.getGraph();
+    }, "getFormGraph");
+    this.setFormGraph = /* @__PURE__ */ __name((graph) => {
+      this.graph.setGraph(graph);
+    }, "setFormGraph");
+    this.clearFormGraph = /* @__PURE__ */ __name((pattern = "*", forceClear = true) => {
+      this.query(pattern).forEach((field) => {
+        field.destroy(forceClear);
+      });
+    }, "clearFormGraph");
+    this.validate = /* @__PURE__ */ __name((pattern = "*") => {
+      return (0, import_internals.batchValidate)(this, pattern);
+    }, "validate");
+    this.submit = /* @__PURE__ */ __name((onSubmit) => {
+      return (0, import_internals.batchSubmit)(this, onSubmit);
+    }, "submit");
+    this.reset = /* @__PURE__ */ __name((pattern = "*", options) => {
+      return (0, import_internals.batchReset)(this, pattern, options);
+    }, "reset");
+    this.initialize(props);
+    this.makeObservable();
+    this.makeReactive();
+    this.makeValues();
+    this.onInit();
+  }
+  initialize(props) {
+    this.id = (0, import_shared.uid)();
+    this.props = { ...props };
+    this.initialized = false;
+    this.submitting = false;
+    this.validating = false;
+    this.loading = false;
+    this.modified = false;
+    this.mounted = false;
+    this.unmounted = false;
+    this.display = this.props.display || "visible";
+    this.pattern = this.props.pattern || "editable";
+    this.editable = this.props.editable;
+    this.disabled = this.props.disabled;
+    this.readOnly = this.props.readOnly;
+    this.readPretty = this.props.readPretty;
+    this.visible = this.props.visible;
+    this.hidden = this.props.hidden;
+    this.graph = new import_Graph.Graph(this);
+    this.heart = new import_Heart.Heart({
+      lifecycles: this.lifecycles,
+      context: this
+    });
+  }
+  makeValues() {
+    this.values = (0, import_internals.getValidFormValues)(this.props.values);
+    this.initialValues = (0, import_internals.getValidFormValues)(this.props.initialValues);
+  }
+  makeObservable() {
+    (0, import_reactive.define)(this, {
+      fields: import_reactive.observable.shallow,
+      indexes: import_reactive.observable.shallow,
+      initialized: import_reactive.observable.ref,
+      validating: import_reactive.observable.ref,
+      submitting: import_reactive.observable.ref,
+      loading: import_reactive.observable.ref,
+      modified: import_reactive.observable.ref,
+      pattern: import_reactive.observable.ref,
+      display: import_reactive.observable.ref,
+      mounted: import_reactive.observable.ref,
+      unmounted: import_reactive.observable.ref,
+      values: import_reactive.observable,
+      initialValues: import_reactive.observable,
+      valid: import_reactive.observable.computed,
+      invalid: import_reactive.observable.computed,
+      errors: import_reactive.observable.computed,
+      warnings: import_reactive.observable.computed,
+      successes: import_reactive.observable.computed,
+      hidden: import_reactive.observable.computed,
+      visible: import_reactive.observable.computed,
+      editable: import_reactive.observable.computed,
+      readOnly: import_reactive.observable.computed,
+      readPretty: import_reactive.observable.computed,
+      disabled: import_reactive.observable.computed,
+      setValues: import_reactive.action,
+      setValuesIn: import_reactive.action,
+      setInitialValues: import_reactive.action,
+      setInitialValuesIn: import_reactive.action,
+      setPattern: import_reactive.action,
+      setDisplay: import_reactive.action,
+      setState: import_reactive.action,
+      deleteInitialValuesIn: import_reactive.action,
+      deleteValuesIn: import_reactive.action,
+      setSubmitting: import_reactive.action,
+      setValidating: import_reactive.action,
+      reset: import_reactive.action,
+      submit: import_reactive.action,
+      validate: import_reactive.action,
+      onMount: import_reactive.batch,
+      onUnmount: import_reactive.batch,
+      onInit: import_reactive.batch
+    });
+  }
+  makeReactive() {
+    this.disposers.push(
+      (0, import_reactive.observe)(
+        this,
+        (change) => {
+          (0, import_internals.triggerFormInitialValuesChange)(this, change);
+          (0, import_internals.triggerFormValuesChange)(this, change);
+        },
+        true
+      )
+    );
+  }
+  get valid() {
+    return !this.invalid;
+  }
+  get invalid() {
+    return this.errors.length > 0;
+  }
+  get errors() {
+    return this.queryFeedbacks({
+      type: "error"
+    });
+  }
+  get warnings() {
+    return this.queryFeedbacks({
+      type: "warning"
+    });
+  }
+  get successes() {
+    return this.queryFeedbacks({
+      type: "success"
+    });
+  }
+  get lifecycles() {
+    return (0, import_effective.runEffects)(this, this.props.effects);
+  }
+  get hidden() {
+    return this.display === "hidden";
+  }
+  get visible() {
+    return this.display === "visible";
+  }
+  set hidden(hidden) {
+    if (!(0, import_shared.isValid)(hidden)) return;
+    if (hidden) {
+      this.display = "hidden";
+    } else {
+      this.display = "visible";
+    }
+  }
+  set visible(visible) {
+    if (!(0, import_shared.isValid)(visible)) return;
+    if (visible) {
+      this.display = "visible";
+    } else {
+      this.display = "none";
+    }
+  }
+  get editable() {
+    return this.pattern === "editable";
+  }
+  set editable(editable) {
+    if (!(0, import_shared.isValid)(editable)) return;
+    if (editable) {
+      this.pattern = "editable";
+    } else {
+      this.pattern = "readPretty";
+    }
+  }
+  get readOnly() {
+    return this.pattern === "readOnly";
+  }
+  set readOnly(readOnly) {
+    if (!(0, import_shared.isValid)(readOnly)) return;
+    if (readOnly) {
+      this.pattern = "readOnly";
+    } else {
+      this.pattern = "editable";
+    }
+  }
+  get disabled() {
+    return this.pattern === "disabled";
+  }
+  set disabled(disabled) {
+    if (!(0, import_shared.isValid)(disabled)) return;
+    if (disabled) {
+      this.pattern = "disabled";
+    } else {
+      this.pattern = "editable";
+    }
+  }
+  get readPretty() {
+    return this.pattern === "readPretty";
+  }
+  set readPretty(readPretty) {
+    if (!(0, import_shared.isValid)(readPretty)) return;
+    if (readPretty) {
+      this.pattern = "readPretty";
+    } else {
+      this.pattern = "editable";
+    }
+  }
+};
+__name(_Form, "Form");
+let Form = _Form;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Form
+});

package/lib/core/models/Graph.d.ts

@@ -0,0 +1,8 @@
+import { IFormGraph } from '../types';
+import { Form } from './Form';
+export declare class Graph {
+    form: Form;
+    constructor(form: Form);
+    getGraph: () => IFormGraph;
+    setGraph: (graph: IFormGraph) => void;
+}

package/lib/core/models/Graph.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var Graph_exports = {};
+__export(Graph_exports, {
+  Graph: () => Graph
+});
+module.exports = __toCommonJS(Graph_exports);
+var import_reactive = require("../../reactive");
+var import_shared = require("../../shared");
+var import_checkers = require("../shared/checkers");
+const _Graph = class _Graph {
+  constructor(form) {
+    this.getGraph = /* @__PURE__ */ __name(() => {
+      const graph = {};
+      graph[""] = this.form.getState();
+      (0, import_shared.each)(this.form.fields, (field, identifier) => {
+        graph[identifier] = field.getState();
+      });
+      return graph;
+    }, "getGraph");
+    this.setGraph = /* @__PURE__ */ __name((graph) => {
+      const form = this.form;
+      const createField = /* @__PURE__ */ __name((identifier, state) => {
+        const address = import_shared.FormPath.parse(identifier);
+        const name = address.segments[address.segments.length - 1];
+        const basePath = address.parent();
+        if ((0, import_checkers.isFieldState)(state)) {
+          return this.form.createField({ name, basePath });
+        } else if ((0, import_checkers.isArrayFieldState)(state)) {
+          return this.form.createArrayField({ name, basePath });
+        } else if ((0, import_checkers.isObjectFieldState)(state)) {
+          return this.form.createObjectField({ name, basePath });
+        } else {
+          return this.form.createVoidField({ name, basePath });
+        }
+      }, "createField");
+      (0, import_shared.each)(graph, (state, address) => {
+        if ((0, import_checkers.isFormState)(state)) {
+          form.setState(state);
+        } else {
+          const field = form.fields[address];
+          if (field) {
+            field.setState(state);
+          } else {
+            createField(address, state).setState(state);
+          }
+        }
+      });
+    }, "setGraph");
+    this.form = form;
+    (0, import_reactive.define)(this, {
+      setGraph: import_reactive.batch
+    });
+  }
+};
+__name(_Graph, "Graph");
+let Graph = _Graph;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Graph
+});

package/lib/core/models/Heart.d.ts

@@ -0,0 +1,16 @@
+import { Subscribable } from '../../shared';
+import { IHeartProps } from '../types';
+import { LifeCycle } from './LifeCycle';
+export declare class Heart<Payload = any, Context = any> extends Subscribable {
+    lifecycles: LifeCycle<Payload>[];
+    outerLifecycles: Map<any, LifeCycle<Payload>[]>;
+    context: Context;
+    constructor({ lifecycles, context }?: IHeartProps<Context>);
+    buildLifeCycles: (lifecycles: LifeCycle[]) => any;
+    addLifeCycles: (id: any, lifecycles?: LifeCycle[]) => void;
+    hasLifeCycles: (id: any) => boolean;
+    removeLifeCycles: (id: any) => void;
+    setLifeCycles: (lifecycles?: LifeCycle[]) => void;
+    publish: <P, C>(type: any, payload?: P, context?: C) => void;
+    clear: () => void;
+}

package/lib/core/models/Heart.js

@@ -0,0 +1,91 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var Heart_exports = {};
+__export(Heart_exports, {
+  Heart: () => Heart
+});
+module.exports = __toCommonJS(Heart_exports);
+var import_shared = require("../../shared");
+var import_LifeCycle = require("./LifeCycle");
+const _Heart = class _Heart extends import_shared.Subscribable {
+  constructor({ lifecycles, context } = {}) {
+    super();
+    this.lifecycles = [];
+    this.outerLifecycles = /* @__PURE__ */ new Map();
+    this.buildLifeCycles = /* @__PURE__ */ __name((lifecycles) => {
+      return lifecycles.reduce((buf, item) => {
+        if (item instanceof import_LifeCycle.LifeCycle) {
+          return buf.concat(item);
+        } else {
+          if ((0, import_shared.isArr)(item)) {
+            return this.buildLifeCycles(item);
+          } else if (typeof item === "object") {
+            this.context = item;
+            return buf;
+          }
+          return buf;
+        }
+      }, []);
+    }, "buildLifeCycles");
+    this.addLifeCycles = /* @__PURE__ */ __name((id, lifecycles = []) => {
+      const observers = this.buildLifeCycles(lifecycles);
+      if (observers.length) {
+        this.outerLifecycles.set(id, observers);
+      }
+    }, "addLifeCycles");
+    this.hasLifeCycles = /* @__PURE__ */ __name((id) => {
+      return this.outerLifecycles.has(id);
+    }, "hasLifeCycles");
+    this.removeLifeCycles = /* @__PURE__ */ __name((id) => {
+      this.outerLifecycles.delete(id);
+    }, "removeLifeCycles");
+    this.setLifeCycles = /* @__PURE__ */ __name((lifecycles = []) => {
+      this.lifecycles = this.buildLifeCycles(lifecycles);
+    }, "setLifeCycles");
+    this.publish = /* @__PURE__ */ __name((type, payload, context) => {
+      if ((0, import_shared.isStr)(type)) {
+        this.lifecycles.forEach((lifecycle) => {
+          lifecycle.notify(type, payload, context || this.context);
+        });
+        this.outerLifecycles.forEach((lifecycles) => {
+          lifecycles.forEach((lifecycle) => {
+            lifecycle.notify(type, payload, context || this.context);
+          });
+        });
+        this.notify({
+          type,
+          payload
+        });
+      }
+    }, "publish");
+    this.clear = /* @__PURE__ */ __name(() => {
+      this.lifecycles = [];
+      this.outerLifecycles.clear();
+      this.unsubscribe();
+    }, "clear");
+    this.lifecycles = this.buildLifeCycles(lifecycles || []);
+    this.context = context;
+  }
+};
+__name(_Heart, "Heart");
+let Heart = _Heart;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Heart
+});

package/lib/core/models/LifeCycle.d.ts

@@ -0,0 +1,14 @@
+import { LifeCycleHandler } from '../types';
+type LifeCycleParams<Payload> = Array<string | LifeCycleHandler<Payload> | {
+    [key: string]: LifeCycleHandler<Payload>;
+}>;
+export declare class LifeCycle<Payload = any> {
+    private listener;
+    constructor(...params: LifeCycleParams<Payload>);
+    buildListener: (params: any[]) => (payload: {
+        type: string;
+        payload: Payload;
+    }, ctx: any) => void;
+    notify: <Payload_1>(type: any, payload?: Payload_1, ctx?: any) => void;
+}
+export {};