@tachui/core 0.8.1-alpha → 0.8.8

package/dist/state/index.js

@@ -0,0 +1,319 @@
+import { p as g, C as p, c as u, o as m, m as l, E as c } from "../observed-object-p1CLdrFm.js";
+import { O as z, e as W, a as K, i as k, b as F, d as q } from "../observed-object-p1CLdrFm.js";
+import { d as f, e as _, S as h } from "../binding-DCV5PKkK.js";
+import { B as L, b as Q, c as X, f as Y, a as Z, i as ee, u as te } from "../binding-DCV5PKkK.js";
+import "../scheduler-DppMK9mR.js";
+import { a as se, b as re, c as ae } from "../theme-CRLPHryV.js";
+import { c as oe } from "../effect-BsW3fy1q.js";
+import "@tachui/types/reactive";
+import { d as O } from "../component-context-B9HI2nZH.js";
+var w = Object.defineProperty, v = (s, e, n) => e in s ? w(s, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : s[e] = n, a = (s, e, n) => v(s, typeof e != "symbol" ? e + "" : e, n);
+class j {
+  constructor(e) {
+    this.componentContext = e, a(this, "states", /* @__PURE__ */ new Map()), a(this, "bindings", /* @__PURE__ */ new Map()), a(this, "observedObjects", /* @__PURE__ */ new Map()), a(this, "environmentObjects", /* @__PURE__ */ new Map()), a(this, "registry"), this.registry = new y();
+  }
+  /**
+   * Register a @State property wrapper
+   */
+  registerState(e, n = {}) {
+    const t = e.metadata;
+    if (t) {
+      const r = `${t.componentId}_${t.propertyName}`;
+      this.states.set(r, e), this.registry.register(t), process.env.NODE_ENV === "development" && this.setupStateDebugging(e, t);
+    }
+  }
+  /**
+   * Register a @Binding property wrapper
+   */
+  registerBinding(e, n = {}) {
+    const t = `${this.componentContext.id}_${n.name || "binding"}_${Date.now()}`;
+    this.bindings.set(t, e);
+    const r = {
+      type: "Binding",
+      propertyName: n.name || "binding",
+      componentId: this.componentContext.id,
+      options: n
+    };
+    this.registry.register(r);
+  }
+  /**
+   * Register an @ObservedObject property wrapper
+   */
+  registerObservedObject(e, n = {}) {
+    const t = e.metadata;
+    if (t) {
+      const r = `${t.componentId}_${t.propertyName}`;
+      this.observedObjects.set(r, e), this.registry.register(t), process.env.NODE_ENV === "development" && this.setupObservedObjectDebugging(e, t);
+    }
+  }
+  /**
+   * Register an @EnvironmentObject property wrapper
+   */
+  registerEnvironmentObject(e, n) {
+    const t = e.metadata;
+    if (t) {
+      const r = `${t.componentId}_${t.propertyName}`;
+      this.environmentObjects.set(r, e), this.registry.register(t);
+    }
+  }
+  /**
+   * Clean up all property wrappers for this component
+   */
+  cleanup() {
+    this.states.clear(), this.bindings.clear(), this.observedObjects.clear(), this.environmentObjects.clear(), this.registry.cleanup(this.componentContext.id);
+  }
+  /**
+   * Get all registered states (for debugging)
+   */
+  getStates() {
+    return new Map(this.states);
+  }
+  /**
+   * Get all registered bindings (for debugging)
+   */
+  getBindings() {
+    return new Map(this.bindings);
+  }
+  /**
+   * Get all registered observed objects (for debugging)
+   */
+  getObservedObjects() {
+    return new Map(this.observedObjects);
+  }
+  /**
+   * Get all registered environment objects (for debugging)
+   */
+  getEnvironmentObjects() {
+    return new Map(this.environmentObjects);
+  }
+  /**
+   * Get property wrapper registry
+   */
+  getRegistry() {
+    return this.registry;
+  }
+  /**
+   * Set up debugging for @State property wrappers
+   */
+  setupStateDebugging(e, n) {
+    if (typeof window < "u") {
+      const t = window.__TACHUI_DEBUG__ || {};
+      t.states || (t.states = {}), t.states[`${n.componentId}_${n.propertyName}`] = {
+        state: e,
+        metadata: n,
+        getValue: () => e.wrappedValue,
+        setValue: (r) => {
+          e.projectedValue.set(r);
+        },
+        getBinding: () => e.projectedValue
+      }, window.__TACHUI_DEBUG__ = t;
+    }
+  }
+  /**
+   * Set up debugging for @ObservedObject property wrappers
+   */
+  setupObservedObjectDebugging(e, n) {
+    if (typeof window < "u") {
+      const t = window.__TACHUI_DEBUG__ || {};
+      t.observedObjects || (t.observedObjects = {}), t.observedObjects[`${n.componentId}_${n.propertyName}`] = {
+        observedObject: e,
+        metadata: n,
+        getObject: () => e.wrappedValue,
+        getNotificationCount: () => e.wrappedValue.notificationCount || 0,
+        triggerChange: () => e.wrappedValue.notifyChange()
+      }, window.__TACHUI_DEBUG__ = t;
+    }
+  }
+}
+class y {
+  constructor() {
+    a(this, "metadata", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Register property wrapper metadata
+   */
+  register(e) {
+    const n = e.componentId, t = this.metadata.get(n) || [];
+    t.push(e), this.metadata.set(n, t);
+  }
+  /**
+   * Unregister a specific property wrapper
+   */
+  unregister(e, n) {
+    const r = (this.metadata.get(e) || []).filter((b) => b.propertyName !== n);
+    r.length > 0 ? this.metadata.set(e, r) : this.metadata.delete(e);
+  }
+  /**
+   * Clean up all metadata for a component
+   */
+  cleanup(e) {
+    this.metadata.delete(e);
+  }
+  /**
+   * Get all metadata for a component
+   */
+  getMetadata(e) {
+    return this.metadata.get(e) || [];
+  }
+  /**
+   * Get all registered metadata (for debugging)
+   */
+  getAllMetadata() {
+    return new Map(this.metadata);
+  }
+}
+function V(s) {
+  return new j(s);
+}
+const d = class i {
+  constructor() {
+    a(this, "managers", /* @__PURE__ */ new Map());
+  }
+  static getInstance() {
+    return i.instance || (i.instance = new i()), i.instance;
+  }
+  register(e, n) {
+    this.managers.set(e, n);
+  }
+  unregister(e) {
+    this.managers.delete(e);
+  }
+  getManager(e) {
+    return this.managers.get(e);
+  }
+  getAllManagers() {
+    return new Map(this.managers);
+  }
+  /**
+   * Get debugging information for all components
+   */
+  getDebugInfo() {
+    const e = {};
+    for (const [n, t] of this.managers)
+      e[n] = {
+        states: t.getStates().size,
+        bindings: t.getBindings().size,
+        observedObjects: t.getObservedObjects().size,
+        environmentObjects: t.getEnvironmentObjects().size,
+        metadata: t.getRegistry().getMetadata(n)
+      };
+    return e;
+  }
+};
+a(d, "instance");
+let o = d;
+function x(s, e) {
+  o.getInstance().register(s, e);
+}
+function A(s) {
+  o.getInstance().unregister(s);
+}
+function M(s) {
+  return o.getInstance().getManager(s);
+}
+function E() {
+  return o.getInstance().getAllManagers();
+}
+function I() {
+  return o.getInstance().getDebugInfo();
+}
+function $() {
+  if (typeof window < "u" && process.env.NODE_ENV === "development") {
+    const s = window.__TACHUI_DEBUG__ || {};
+    s.stateManagers = {
+      getAll: E,
+      getDebugInfo: I,
+      getManager: M
+    }, window.__TACHUI_DEBUG__ = s, console.log(
+      "TachUI State Management debugging enabled. Use window.__TACHUI_DEBUG__.stateManagers"
+    );
+  }
+}
+const G = g;
+function T(s) {
+  return console.warn("useEnvironmentObject is deprecated, use EnvironmentObject instead"), c(s);
+}
+const D = {
+  /**
+   * Check if a value is any kind of property wrapper
+   */
+  isPropertyWrapper(s) {
+    return s && typeof s == "object" && "wrappedValue" in s && "projectedValue" in s;
+  },
+  /**
+   * Extract the wrapped value from any property wrapper
+   */
+  unwrap(s) {
+    return this.isPropertyWrapper(s) ? s.wrappedValue : s;
+  },
+  /**
+   * Create a debug snapshot of all property wrappers in a component
+   */
+  createDebugSnapshot(s) {
+    if (typeof window < "u") {
+      const e = window.__TACHUI_DEBUG__;
+      if (e)
+        return {
+          states: e.states ? Object.keys(e.states).filter((n) => n.startsWith(s)).reduce((n, t) => (n[t] = e.states[t].getValue(), n), {}) : {},
+          observedObjects: e.observedObjects ? Object.keys(e.observedObjects).filter((n) => n.startsWith(s)).reduce((n, t) => (n[t] = {
+            notificationCount: e.observedObjects[t].getNotificationCount(),
+            object: e.observedObjects[t].getObject()
+          }, n), {}) : {}
+        };
+    }
+    return null;
+  }
+}, H = {
+  State: h,
+  EnvironmentObject: c,
+  createStateBinding: _,
+  createBinding: f,
+  makeObservable: l,
+  observable: m,
+  createEnvironmentKey: O,
+  provideEnvironmentObject: g,
+  createObservableEnvironmentObject: u,
+  CommonEnvironmentKeys: p,
+  StateUtils: D
+};
+export {
+  L as BindingImpl,
+  Q as BindingUtils,
+  p as CommonEnvironmentKeys,
+  c as EnvironmentObject,
+  z as ObservableObjectBase,
+  W as ObservedObject,
+  h as State,
+  j as StateManagerImpl,
+  D as StateUtils,
+  f as createBinding,
+  se as createComputed,
+  oe as createEffect,
+  X as createEnhancedBinding,
+  O as createEnvironmentKey,
+  G as createEnvironmentObjectProvider,
+  re as createMemo,
+  u as createObservableEnvironmentObject,
+  K as createObservableStore,
+  ae as createSignal,
+  _ as createStateBinding,
+  V as createStateManager,
+  H as default,
+  E as getAllStateManagers,
+  M as getStateManager,
+  I as getStateManagerDebugInfo,
+  $ as initializeStateDebugging,
+  Y as isBinding,
+  Z as isEnhancedBinding,
+  k as isEnvironmentObject,
+  F as isObservableObject,
+  q as isObservedObject,
+  ee as isState,
+  l as makeObservable,
+  m as observable,
+  g as provideEnvironmentObject,
+  x as registerStateManager,
+  A as unregisterStateManager,
+  te as unwrapValue,
+  T as useEnvironmentObject
+};