@blac/react 2.0.0-rc-6 → 2.0.0-rc-8

package/dist/index.es.js

@@ -1,163 +1,387 @@
-import { useMemo as y, useRef as S, useCallback as I, useSyncExternalStore as P, useEffect as E } from "react";
-import { generateUUID as K, Blac as C } from "@blac/core";
-const k = (a, n) => {
-  var r;
-  const { id: f, props: m, selector: g } = n ?? {}, c = y(() => K(), []), h = a.isolated ? c : f, l = S(/* @__PURE__ */ new Set()), d = S(/* @__PURE__ */ new Set()), b = I(() => C.getBloc(a, {
-    id: h,
-    props: m,
-    instanceRef: c
-  }), [a, h, m, c]), s = S(b());
-  y(() => {
-    s.current = b();
-  }, [b]);
-  const v = y(
-    () => (e) => {
-      const t = s.current;
-      if (!t)
-        return [];
-      if (g)
-        return g(e);
-      if (t.defaultDependencySelector)
-        return t.defaultDependencySelector(e);
-      if (typeof e != "object")
-        return [[e]];
-      const o = [];
-      for (const i of l.current)
-        i in e && o.push(e[i]);
-      const p = [];
-      for (const i of d.current)
-        if (i in t)
-          try {
-            const x = t[i];
-            switch (typeof x) {
-              case "function":
-                continue;
-              default:
-                p.push(x);
-                continue;
+var W = Object.defineProperty;
+var z = (c, e, s) => e in c ? W(c, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : c[e] = s;
+var g = (c, e, s) => z(c, typeof e != "symbol" ? e + "" : e, s);
+import { useMemo as D, useRef as p, useCallback as $, useSyncExternalStore as N, useEffect as O } from "react";
+import { generateUUID as _, Blac as I } from "@blac/core";
+const j = (c, e) => {
+  var k, F;
+  const { id: s, props: h, selector: f } = e ?? {}, n = D(() => _(), []), o = c.isolated ? n : s, b = p(/* @__PURE__ */ new Set()), B = p(/* @__PURE__ */ new Set()), A = p(!1), K = $(() => I.getBloc(c, {
+    id: o,
+    props: h,
+    instanceRef: n
+  }), [c, o, h, n]), v = p(K());
+  D(() => {
+    v.current = K();
+  }, [K]);
+  const R = p(void 0), E = p(void 0), M = p(void 0), t = p(void 0);
+  t.current !== ((k = v.current) == null ? void 0 : k.uid) && (t.current = (F = v.current) == null ? void 0 : F.uid);
+  const l = D(
+    () => (u, C) => {
+      const d = v.current;
+      if (!d)
+        return [[], []];
+      const S = C ?? R.current;
+      let y;
+      if (f)
+        y = [f(u, S, d), []];
+      else if (d.defaultDependencySelector)
+        y = [d.defaultDependencySelector(u, S, d), []];
+      else if (typeof u != "object")
+        y = [[u], []];
+      else {
+        const m = [], P = [];
+        for (const T of b.current)
+          T in u && m.push(u[T]);
+        for (const T of B.current)
+          if (T in d)
+            try {
+              const w = d[T];
+              typeof w != "function" && P.push(w);
+            } catch (w) {
+              I.instance.log("useBloc Error", w);
             }
-          } catch (x) {
-            C.instance.log("useBloc Error", x);
-          }
-      return l.current.size === 0 ? d.current.size > 0 ? [p] : [[]] : [o, p];
+        b.current.size === 0 && B.current.size === 0 && (A.current || m.push(u)), y = [m, P];
+      }
+      return R.current = u, y;
     },
     []
-  ), w = y(() => ({
-    subscribe: (e) => {
-      const t = s.current;
-      if (!t)
+  ), a = p(/* @__PURE__ */ new Map()), x = D(() => ({
+    subscribe: (u) => {
+      const C = v.current;
+      if (!C)
         return () => {
         };
-      const o = {
+      const d = a.current.get(u);
+      if (d)
+        return d.unsubscribe;
+      const S = {
         fn: () => {
           try {
-            l.current = /* @__PURE__ */ new Set(), d.current = /* @__PURE__ */ new Set(), e(t.state);
-          } catch (i) {
+            !f && !C.defaultDependencySelector && (b.current = /* @__PURE__ */ new Set(), B.current = /* @__PURE__ */ new Set()), u(C.state);
+          } catch (P) {
             console.error({
-              e: i,
-              blocInstance: t,
-              dependencyArray: v
+              e: P,
+              blocInstance: C,
+              dependencyArray: l
             });
           }
         },
         // Pass the dependency array to control when the subscription is updated
-        dependencyArray: v,
+        dependencyArray: l,
         // Use the provided id to identify this subscription
-        id: c
+        id: n
       };
-      C.activateBloc(t);
-      const p = t._observer.subscribe(o);
-      return () => {
-        p();
+      I.activateBloc(C);
+      const y = C._observer.subscribe(S), m = () => {
+        a.current.delete(u), y();
       };
+      return a.current.set(u, { observer: S, unsubscribe: m }), m;
     },
     // Return an immutable snapshot of the current bloc state
     getSnapshot: () => {
-      const e = s.current;
-      return e ? e.state : {};
+      const u = v.current;
+      if (!u)
+        return {};
+      const C = u.state, d = l(C, R.current), S = E.current;
+      let y = !1;
+      if (!S)
+        y = !0;
+      else if (S.length !== d.length)
+        y = !0;
+      else
+        for (let m = 0; m < d.length; m++) {
+          const P = S[m] || [], T = d[m] || [];
+          if (P.length !== T.length) {
+            y = !0;
+            break;
+          }
+          for (let w = 0; w < T.length; w++)
+            if (!Object.is(P[w], T[w])) {
+              y = !0;
+              break;
+            }
+          if (y) break;
+        }
+      return E.current = d, !y && M.current ? M.current : (M.current = C, C);
     },
     // Server snapshot mirrors the client snapshot in this implementation
     getServerSnapshot: () => {
-      const e = s.current;
-      return e ? e.state : {};
+      const u = v.current;
+      return u ? u.state : {};
     }
-  }), [(r = s.current) == null ? void 0 : r.uid]);
+  }), []);
   return {
-    usedKeys: l,
-    usedClassPropKeys: d,
-    externalStore: w,
-    instance: s,
-    rid: c
+    usedKeys: b,
+    usedClassPropKeys: B,
+    externalStore: x,
+    instance: v,
+    rid: n,
+    hasProxyTracking: A
   };
 };
-function z(a, n) {
-  var v, w;
+class U {
+  constructor(e = {}) {
+    g(this, "stateKeys", /* @__PURE__ */ new Set());
+    g(this, "classKeys", /* @__PURE__ */ new Set());
+    g(this, "batchedCallbacks", /* @__PURE__ */ new Set());
+    g(this, "flushScheduled", !1);
+    g(this, "flushTimeoutId");
+    g(this, "metrics", {
+      stateAccessCount: 0,
+      classAccessCount: 0,
+      proxyCreationCount: 0,
+      batchFlushCount: 0,
+      averageResolutionTime: 0,
+      memoryUsageKB: 0
+    });
+    g(this, "resolutionTimes", []);
+    g(this, "config");
+    g(this, "stateProxyCache", /* @__PURE__ */ new WeakMap());
+    g(this, "classProxyCache", /* @__PURE__ */ new WeakMap());
+    g(this, "lastStateSnapshot", null);
+    g(this, "lastClassSnapshot", null);
+    this.config = {
+      enableBatching: !0,
+      batchTimeout: 0,
+      // Use React's scheduler
+      enableMetrics: process.env.NODE_ENV === "development",
+      maxCacheSize: 1e3,
+      enableDeepTracking: !1,
+      ...e
+    };
+  }
+  trackStateAccess(e) {
+    this.config.enableMetrics && this.metrics.stateAccessCount++, this.stateKeys.add(e), this.config.enableBatching && this.scheduleFlush();
+  }
+  trackClassAccess(e) {
+    this.config.enableMetrics && this.metrics.classAccessCount++, this.classKeys.add(e), this.config.enableBatching && this.scheduleFlush();
+  }
+  createStateProxy(e, s) {
+    const h = this.stateProxyCache.get(e);
+    if (h)
+      return h;
+    const f = this.config.enableMetrics ? performance.now() : 0, n = new Proxy(e, {
+      get: (r, i) => {
+        typeof i == "string" && (this.trackStateAccess(i), s == null || s(i));
+        const o = r[i];
+        return this.config.enableDeepTracking && o && typeof o == "object" && !Array.isArray(o) ? this.createStateProxy(o) : o;
+      },
+      has: (r, i) => i in r,
+      ownKeys: (r) => Reflect.ownKeys(r),
+      getOwnPropertyDescriptor: (r, i) => Reflect.getOwnPropertyDescriptor(r, i)
+    });
+    if (this.stateProxyCache.set(e, n), this.config.enableMetrics) {
+      this.metrics.proxyCreationCount++;
+      const r = performance.now();
+      this.resolutionTimes.push(r - f), this.updateAverageResolutionTime();
+    }
+    return n;
+  }
+  createClassProxy(e, s) {
+    const h = this.classProxyCache.get(e);
+    if (h)
+      return h;
+    const f = this.config.enableMetrics ? performance.now() : 0, n = new Proxy(e, {
+      get: (r, i) => {
+        const o = r[i];
+        return typeof i == "string" && typeof o != "function" && (this.trackClassAccess(i), s == null || s(i)), o;
+      }
+    });
+    if (this.classProxyCache.set(e, n), this.config.enableMetrics) {
+      this.metrics.proxyCreationCount++;
+      const r = performance.now();
+      this.resolutionTimes.push(r - f), this.updateAverageResolutionTime();
+    }
+    return n;
+  }
+  getStateKeys() {
+    return new Set(this.stateKeys);
+  }
+  getClassKeys() {
+    return new Set(this.classKeys);
+  }
+  reset() {
+    this.stateKeys.clear(), this.classKeys.clear(), this.cancelScheduledFlush();
+  }
+  subscribe(e) {
+    return this.batchedCallbacks.add(e), () => {
+      this.batchedCallbacks.delete(e);
+    };
+  }
+  computeDependencyArray(e, s) {
+    const h = this.config.enableMetrics ? performance.now() : 0;
+    if (typeof e != "object" || e === null)
+      return [[e]];
+    const f = [];
+    for (const r of this.stateKeys)
+      r in e && f.push(e[r]);
+    const n = [];
+    for (const r of this.classKeys)
+      if (r in s)
+        try {
+          const i = s[r];
+          typeof i != "function" && n.push(i);
+        } catch {
+        }
+    if (this.config.enableMetrics) {
+      const r = performance.now();
+      this.resolutionTimes.push(r - h), this.updateAverageResolutionTime();
+    }
+    return f.length === 0 && n.length === 0 ? [[]] : n.length === 0 ? [f] : f.length === 0 ? [n] : [f, n];
+  }
+  getMetrics() {
+    if (!this.config.enableMetrics)
+      return {
+        stateAccessCount: 0,
+        classAccessCount: 0,
+        proxyCreationCount: 0,
+        batchFlushCount: 0,
+        averageResolutionTime: 0,
+        memoryUsageKB: 0
+      };
+    const e = this.stateKeys.size * 50 + this.classKeys.size * 50 + (this.stateProxyCache instanceof WeakMap ? 100 : 0) + (this.classProxyCache instanceof WeakMap ? 100 : 0);
+    return {
+      ...this.metrics,
+      memoryUsageKB: Math.round(e / 1024)
+    };
+  }
+  clearCaches() {
+    this.stateProxyCache = /* @__PURE__ */ new WeakMap(), this.classProxyCache = /* @__PURE__ */ new WeakMap(), this.resolutionTimes = [], this.config.enableMetrics && (this.metrics = {
+      stateAccessCount: 0,
+      classAccessCount: 0,
+      proxyCreationCount: 0,
+      batchFlushCount: 0,
+      averageResolutionTime: 0,
+      memoryUsageKB: 0
+    });
+  }
+  scheduleFlush() {
+    this.flushScheduled || (this.flushScheduled = !0, this.config.batchTimeout > 0 ? this.flushTimeoutId = setTimeout(() => {
+      this.flushBatchedChanges();
+    }, this.config.batchTimeout) : Promise.resolve().then(() => this.flushBatchedChanges()));
+  }
+  cancelScheduledFlush() {
+    this.flushTimeoutId && (clearTimeout(this.flushTimeoutId), this.flushTimeoutId = void 0), this.flushScheduled = !1;
+  }
+  flushBatchedChanges() {
+    if (!this.flushScheduled)
+      return;
+    this.flushScheduled = !1, this.flushTimeoutId = void 0, this.config.enableMetrics && this.metrics.batchFlushCount++;
+    const e = /* @__PURE__ */ new Set([...this.stateKeys, ...this.classKeys]);
+    for (const s of this.batchedCallbacks)
+      try {
+        s(e);
+      } catch (h) {
+        console.error("Error in dependency change callback:", h);
+      }
+  }
+  updateAverageResolutionTime() {
+    if (this.resolutionTimes.length === 0)
+      return;
+    this.resolutionTimes.length > 100 && (this.resolutionTimes = this.resolutionTimes.slice(-100));
+    const e = this.resolutionTimes.reduce((s, h) => s + h, 0);
+    this.metrics.averageResolutionTime = e / this.resolutionTimes.length;
+  }
+}
+function V(c) {
+  return new U(c);
+}
+V();
+function J(c, e) {
+  var E, M;
   const {
-    externalStore: f,
-    usedKeys: m,
-    usedClassPropKeys: g,
-    instance: c,
-    rid: B
-  } = k(a, n), u = P(
-    f.subscribe,
+    externalStore: s,
+    usedKeys: h,
+    usedClassPropKeys: f,
+    instance: n,
+    rid: r,
+    hasProxyTracking: i
+  } = j(c, e), o = N(
+    s.subscribe,
     () => {
-      const r = f.getSnapshot();
-      if (r === void 0)
-        throw new Error(`[useBloc] State snapshot is undefined for bloc ${a.name}. Bloc may not be properly initialized.`);
-      return r;
+      const t = s.getSnapshot();
+      if (t === void 0)
+        throw new Error(
+          `[useBloc] State snapshot is undefined for bloc ${c.name}. Bloc may not be properly initialized.`
+        );
+      return t;
     },
-    f.getServerSnapshot ? () => {
-      const r = f.getServerSnapshot();
-      if (r === void 0)
-        throw new Error(`[useBloc] Server state snapshot is undefined for bloc ${a.name}. Bloc may not be properly initialized.`);
-      return r;
+    s.getServerSnapshot ? () => {
+      const t = s.getServerSnapshot();
+      if (t === void 0)
+        throw new Error(
+          `[useBloc] Server state snapshot is undefined for bloc ${c.name}. Bloc may not be properly initialized.`
+        );
+      return t;
     } : void 0
-  ), h = S(/* @__PURE__ */ new WeakMap()), l = S(/* @__PURE__ */ new WeakMap()), d = y(() => {
-    if (typeof u != "object" || u === null)
-      return u;
-    let r = h.current.get(u);
-    return r || (r = new Proxy(u, {
-      get(e, t) {
-        return setTimeout(() => {
-          m.current.add(t);
-        }, 0), e[t];
+  ), b = p(null);
+  b.current || (b.current = new U({
+    enableBatching: !0,
+    enableMetrics: process.env.NODE_ENV === "development",
+    enableDeepTracking: !1
+  }));
+  const B = p(/* @__PURE__ */ new WeakMap()), A = p(/* @__PURE__ */ new WeakMap()), K = D(() => {
+    if (e != null && e.selector || (i.current = !0, typeof o != "object" || o === null))
+      return o;
+    let t = B.current.get(o);
+    return t || (t = new Proxy(o, {
+      get(l, a) {
+        var k;
+        return typeof a == "string" && (h.current.add(a), (k = b.current) == null || k.trackStateAccess(a)), l[a];
       },
-      // Handle symbols and non-enumerable properties
-      has(e, t) {
-        return t in e;
+      has(l, a) {
+        return a in l;
       },
-      ownKeys(e) {
-        return Reflect.ownKeys(e);
+      ownKeys(l) {
+        return Reflect.ownKeys(l);
       },
-      getOwnPropertyDescriptor(e, t) {
-        return Reflect.getOwnPropertyDescriptor(e, t);
+      getOwnPropertyDescriptor(l, a) {
+        return Reflect.getOwnPropertyDescriptor(l, a);
       }
-    }), h.current.set(u, r)), r;
-  }, [u]), b = y(() => {
-    if (!c.current)
-      return null;
-    let r = l.current.get(c.current);
-    return r || (r = new Proxy(c.current, {
-      get(e, t) {
-        if (!e)
-          return null;
-        const o = e[t];
-        return typeof o != "function" && g.current.add(t), o;
+    }), B.current.set(o, t)), t;
+  }, [o]), v = D(() => {
+    if (!n.current)
+      throw new Error(
+        `[useBloc] Bloc instance is null for ${c.name}. This should never happen - bloc instance must be defined.`
+      );
+    let t = A.current.get(n.current);
+    return t || (t = new Proxy(n.current, {
+      get(l, a) {
+        var k;
+        if (!l)
+          throw new Error(
+            `[useBloc] Bloc target is null for ${c.name}. This should never happen - bloc target must be defined.`
+          );
+        const x = l[a];
+        return typeof x != "function" && typeof a == "string" && (f.current.add(a), (k = b.current) == null || k.trackClassAccess(a)), x;
       }
-    }), l.current.set(c.current, r)), r;
-  }, [(v = c.current) == null ? void 0 : v.uid]), s = S({});
-  return E(() => {
-    var e;
-    const r = c.current;
-    if (r)
-      return r._addConsumer(B, s.current), (e = n == null ? void 0 : n.onMount) == null || e.call(n, r), () => {
-        var t;
-        r && ((t = n == null ? void 0 : n.onUnmount) == null || t.call(n, r), r._removeConsumer(B));
+    }), A.current.set(n.current, t)), t;
+  }, [(E = n.current) == null ? void 0 : E.uid]), R = p({});
+  if (O(() => {
+    var l;
+    const t = n.current;
+    if (t)
+      return t._addConsumer(r, R.current), (l = e == null ? void 0 : e.onMount) == null || l.call(e, t), () => {
+        var a, x;
+        t && ((a = e == null ? void 0 : e.onUnmount) == null || a.call(e, t), t._removeConsumer(r), (x = b.current) == null || x.reset());
       };
-  }, [(w = c.current) == null ? void 0 : w.uid, B]), [d, b];
+  }, [(M = n.current) == null ? void 0 : M.uid, r]), O(() => {
+    if (process.env.NODE_ENV === "development" && b.current) {
+      const t = b.current.getMetrics();
+      (t.stateAccessCount > 0 || t.classAccessCount > 0) && console.debug(`[useBloc] ${c.name} Performance Metrics:`, t);
+    }
+  }), K === void 0)
+    throw new Error(
+      `[useBloc] State is undefined for ${c.name}. This should never happen - state must be defined.`
+    );
+  if (!v)
+    throw new Error(
+      `[useBloc] Instance is null for ${c.name}. This should never happen - instance must be defined.`
+    );
+  return [K, v];
 }
 export {
-  k as externalBlocStore,
-  z as useBloc
+  j as externalBlocStore,
+  J as useBloc
 };
 //# sourceMappingURL=index.es.js.map