@tachui/core 0.7.1-alpha → 0.8.1-alpha

package/dist/observed-object-Cos-FtjP.js

@@ -0,0 +1,269 @@
+import { c as l } from "./effect-B9Knft0b.js";
+import { G as f, W as p } from "./scheduler-BKeqwrYE.js";
+import { d as a, g as d, p as g, c as y } from "./dom-bridge-CAa1N2zX.js";
+var j = Object.defineProperty, O = (e, t, n) => t in e ? j(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, s = (e, t, n) => O(e, typeof t != "symbol" ? t + "" : t, n);
+class v {
+  constructor(t) {
+    s(this, "_signal"), s(this, "_setter"), s(this, "_subscribers", /* @__PURE__ */ new Set());
+    const [n, i] = f(t);
+    this._signal = n, this._setter = i;
+  }
+  get value() {
+    return this._signal();
+  }
+  set value(t) {
+    this._setter(t), this.notifySubscribers();
+  }
+  /**
+   * Update a property of the environment object
+   */
+  updateProperty(t, n) {
+    const r = { ...this._signal(), [t]: n };
+    this._setter(r), this.notifySubscribers();
+  }
+  /**
+   * Subscribe to changes
+   */
+  subscribe(t) {
+    return this._subscribers.add(t), () => this._subscribers.delete(t);
+  }
+  notifySubscribers() {
+    for (const t of this._subscribers)
+      try {
+        t();
+      } catch (n) {
+        console.error("Error in environment object subscriber:", n);
+      }
+  }
+  /**
+   * Create a reactive effect that runs when this object changes
+   */
+  onChange(t) {
+    const n = l(() => {
+      t(this._signal());
+    });
+    return () => n.dispose();
+  }
+}
+class _ {
+  constructor(t, n) {
+    s(this, "key"), s(this, "componentContext"), s(this, "_cachedValue"), s(this, "_subscriptionCleanup"), this.key = t, this.componentContext = n, n.onCleanup(() => {
+      this._subscriptionCleanup && this._subscriptionCleanup();
+    });
+  }
+  get wrappedValue() {
+    if (this._cachedValue === void 0 && (this._cachedValue = y(this.key), this._cachedValue && typeof this._cachedValue == "object" && "subscribe" in this._cachedValue)) {
+      const t = this._cachedValue;
+      typeof t.subscribe == "function" && (this._subscriptionCleanup = t.subscribe(() => {
+        this.componentContext.setState(`_env_${this.key.name}_trigger`, Date.now());
+      }));
+    }
+    return this._cachedValue;
+  }
+  get projectedValue() {
+    return this;
+  }
+}
+function $(e) {
+  const t = d();
+  return new _(e, t);
+}
+function I(e, t) {
+  g(e, t);
+}
+function T(e, t) {
+  return new v(t);
+}
+function k(e) {
+  return e && typeof e == "object" && "wrappedValue" in e && "key" in e && "componentContext" in e && e instanceof _;
+}
+const z = {
+  /**
+   * Application theme
+   */
+  Theme: a("Theme", {
+    mode: "light",
+    primaryColor: "#007AFF",
+    secondaryColor: "#5856D6"
+  }),
+  /**
+   * Localization service
+   */
+  Localization: a("Localization"),
+  /**
+   * Navigation service
+   */
+  Navigation: a("Navigation"),
+  /**
+   * Application configuration
+   */
+  Config: a("Config"),
+  /**
+   * User authentication
+   */
+  Auth: a("Auth")
+};
+var w = Object.defineProperty, V = (e, t, n) => t in e ? w(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, c = (e, t, n) => V(e, typeof t != "symbol" ? t + "" : t, n);
+class m {
+  constructor() {
+    c(this, "_objectWillChange"), c(this, "_notifyCount", 0);
+    const [t, n] = f(void 0);
+    this._objectWillChange = {
+      getValue: t,
+      peek: t
+    }, this._notifySetter = n;
+  }
+  get objectWillChange() {
+    return this._objectWillChange;
+  }
+  /**
+   * Notify observers that the object has changed
+   * Call this method whenever properties of the object change
+   */
+  notifyChange() {
+    this._notifyCount++;
+    const t = this._notifySetter;
+    t && t(void 0);
+  }
+  /**
+   * Get the current notification count (for debugging)
+   */
+  get notificationCount() {
+    return this._notifyCount;
+  }
+}
+class x {
+  constructor(t, n, i, r = {}) {
+    c(this, "_object"), c(this, "_metadata"), c(this, "_effectCleanup"), this._object = t, this._metadata = {
+      type: "ObservedObject",
+      propertyName: i,
+      componentId: n.id,
+      options: r
+    }, this.setupObservation();
+    const o = p();
+    o && o.cleanups.push(() => {
+      this.cleanup();
+    });
+  }
+  get wrappedValue() {
+    return this._object;
+  }
+  get projectedValue() {
+    return this;
+  }
+  /**
+   * Get property wrapper metadata
+   */
+  get metadata() {
+    return this._metadata;
+  }
+  /**
+   * Set up reactive observation of the object
+   */
+  setupObservation() {
+    const t = l(() => {
+      this._object.objectWillChange();
+    });
+    this._effectCleanup = () => t.dispose();
+  }
+  /**
+   * Cleanup observation
+   */
+  cleanup() {
+    this._effectCleanup && (this._effectCleanup(), this._effectCleanup = void 0);
+  }
+  /**
+   * Replace the observed object (advanced usage)
+   */
+  updateObject(t) {
+    this.cleanup(), this._object = t, this.setupObservation();
+  }
+}
+const E = (e, t = {}) => {
+  const n = W(), i = P() || "observedObject";
+  return new x(e, n, i, t);
+};
+function N(e, t = {}) {
+  const n = new m();
+  return new Proxy(e, {
+    set(r, o, u) {
+      const C = r[o], b = Reflect.set(r, o, u);
+      return b && C !== u && t.autoNotify !== !1 && n.notifyChange(), b;
+    },
+    get(r, o) {
+      return o === "objectWillChange" ? n.objectWillChange : o === "notifyChange" ? () => n.notifyChange() : o === "notificationCount" ? n.notificationCount : Reflect.get(r, o);
+    }
+  });
+}
+function D(e = {}) {
+  return (t) => class extends t {
+    constructor(...n) {
+      super(...n), c(this, "_observableBase", new m()), e.autoNotify !== !1 && this.setupAutoNotification();
+    }
+    get objectWillChange() {
+      return this._observableBase.objectWillChange;
+    }
+    get notificationCount() {
+      return this._observableBase.notificationCount;
+    }
+    notifyChange() {
+      this._observableBase.notifyChange();
+    }
+    setupAutoNotification() {
+      const n = Object.getOwnPropertyNames(this);
+      for (const i of n) {
+        if (i.startsWith("_") || typeof this[i] == "function")
+          continue;
+        let r = this[i];
+        Object.defineProperty(this, i, {
+          get: () => r,
+          set: (o) => {
+            r !== o && (r = o, this.notifyChange());
+          },
+          enumerable: !0,
+          configurable: !0
+        });
+      }
+    }
+  };
+}
+function W() {
+  const e = p();
+  if (!e?.context.has(h))
+    throw new Error("@ObservedObject can only be used within a component context");
+  return e.context.get(h);
+}
+function P() {
+  try {
+    const e = new Error().stack;
+    if (e)
+      return e.match(/at (\w+)\./)?.[1] || null;
+  } catch {
+  }
+  return null;
+}
+const h = Symbol("TachUI.ComponentContext");
+function S(e) {
+  return e && typeof e == "object" && "objectWillChange" in e && "notifyChange" in e;
+}
+function K(e) {
+  return e && typeof e == "object" && "wrappedValue" in e && "projectedValue" in e && S(e.wrappedValue);
+}
+function L(e, t = {}) {
+  return N({ ...e }, t);
+}
+const R = E;
+export {
+  z as C,
+  $ as E,
+  m as O,
+  L as a,
+  S as b,
+  T as c,
+  K as d,
+  R as e,
+  k as i,
+  N as m,
+  D as o,
+  I as p
+};

package/dist/performance-optimizer-stub-CtfXUwl4.js

@@ -0,0 +1,38 @@
+var a = Object.defineProperty, c = (t, e, i) => e in t ? a(t, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : t[e] = i, o = (t, e, i) => c(t, e + "", i);
+const r = class n {
+  static getInstance() {
+    return this.instance || (this.instance = new n()), this.instance;
+  }
+  configure(e) {
+  }
+  optimizeValidation(e, i) {
+    return i();
+  }
+  getMetrics(e) {
+    if (!e)
+      return /* @__PURE__ */ new Map();
+  }
+  resetMetrics() {
+  }
+};
+o(r, "instance");
+let s = r;
+s.getInstance();
+const u = {
+  configure: (t) => {
+  },
+  getMetrics: (t) => t ? void 0 : /* @__PURE__ */ new Map(),
+  resetMetrics: () => {
+  },
+  getStats: () => ({
+    enabled: !1,
+    targetOverhead: 5,
+    batchSize: 10,
+    cacheStrategy: "moderate",
+    metricsCount: 0,
+    note: "Production stub - full implementation available in @tachui/devtools"
+  })
+};
+export {
+  u as PerformanceOptimizationUtils
+};