@almadar/ui 2.28.2 → 2.30.0

package/dist/components/index.js

@@ -6029,43 +6029,43 @@ function useQuerySingleton(query) {
   if (!query) {
     return null;
   }
-  const store = useMemo(() => getOrCreateStore(query), [query]);
+  const store2 = useMemo(() => getOrCreateStore(query), [query]);
   useMemo(() => {
     const listener = () => forceUpdate({});
-    store.listeners.add(listener);
+    store2.listeners.add(listener);
     return () => {
-      store.listeners.delete(listener);
+      store2.listeners.delete(listener);
     };
-  }, [store]);
+  }, [store2]);
   const notifyListeners = useCallback(() => {
-    store.listeners.forEach((listener) => listener());
-  }, [store]);
+    store2.listeners.forEach((listener) => listener());
+  }, [store2]);
   const setSearch = useCallback((value) => {
-    store.search = value;
+    store2.search = value;
     notifyListeners();
-  }, [store, notifyListeners]);
+  }, [store2, notifyListeners]);
   const setFilter = useCallback((key, value) => {
-    store.filters = { ...store.filters, [key]: value };
+    store2.filters = { ...store2.filters, [key]: value };
     notifyListeners();
-  }, [store, notifyListeners]);
+  }, [store2, notifyListeners]);
   const clearFilters = useCallback(() => {
-    store.filters = {};
-    store.search = "";
+    store2.filters = {};
+    store2.search = "";
     notifyListeners();
-  }, [store, notifyListeners]);
+  }, [store2, notifyListeners]);
   const setSort = useCallback((field, direction) => {
-    store.sortField = field;
-    store.sortDirection = direction;
+    store2.sortField = field;
+    store2.sortDirection = direction;
     notifyListeners();
-  }, [store, notifyListeners]);
+  }, [store2, notifyListeners]);
   return {
-    search: store.search,
+    search: store2.search,
     setSearch,
-    filters: store.filters,
+    filters: store2.filters,
     setFilter,
     clearFilters,
-    sortField: store.sortField,
-    sortDirection: store.sortDirection,
+    sortField: store2.sortField,
+    sortDirection: store2.sortDirection,
     setSort
   };
 }
@@ -27463,7 +27463,7 @@ function SequencerBoard({
     setPlayState("playing");
     setCurrentStep(0);
     let step = 0;
-    const advance = () => {
+    const advance2 = () => {
       step++;
       if (step >= entity.maxSlots) {
         const playerSeq = slots.map((s) => s?.id);
@@ -27494,10 +27494,10 @@ function SequencerBoard({
         }
       } else {
         setCurrentStep(step);
-        timerRef.current = setTimeout(advance, stepDurationMs);
+        timerRef.current = setTimeout(advance2, stepDurationMs);
       }
     };
-    timerRef.current = setTimeout(advance, stepDurationMs);
+    timerRef.current = setTimeout(advance2, stepDurationMs);
   }, [canPlay, slots, entity.maxSlots, entity.solutions, stepDurationMs, playEvent, completeEvent, emit]);
   const machine = {
     name: entity.title,
@@ -29606,6 +29606,55 @@ function calculateDamage(attack, defense, isDefending = false, criticalChance =
 function generateCombatMessage(event) {
   return event.message;
 }
+var store = /* @__PURE__ */ new Map();
+var storeListeners = /* @__PURE__ */ new Set();
+var watchCallbacks = /* @__PURE__ */ new Map();
+function advance(entityType, data) {
+  const prev = store.get(entityType);
+  const oldData = prev?.data ?? [];
+  store.set(entityType, { data, version: (prev?.version ?? 0) + 1 });
+  for (const listener of storeListeners) {
+    listener();
+  }
+  const cbs = watchCallbacks.get(entityType);
+  if (cbs) {
+    for (const cb of cbs) {
+      try {
+        cb(oldData, data);
+      } catch {
+      }
+    }
+  }
+}
+function getSnapshot2(entityType) {
+  return store.get(entityType)?.data ?? [];
+}
+function getVersion(entityType) {
+  return store.get(entityType)?.version ?? 0;
+}
+function subscribeToStore(listener) {
+  storeListeners.add(listener);
+  return () => {
+    storeListeners.delete(listener);
+  };
+}
+function useEntityRef(entityType) {
+  const versionRef = useRef(0);
+  const dataRef = useRef([]);
+  const getSnapshotStable = React91__default.useCallback(() => {
+    const currentVersion = getVersion(entityType);
+    if (currentVersion !== versionRef.current) {
+      versionRef.current = currentVersion;
+      dataRef.current = getSnapshot2(entityType);
+    }
+    return dataRef.current;
+  }, [entityType]);
+  return useSyncExternalStore(subscribeToStore, getSnapshotStable, () => []);
+}
+createContext({
+  advance,
+  getSnapshot: getSnapshot2
+});
 var ClientEffectConfigContext = createContext(null);
 ClientEffectConfigContext.Provider;
 
@@ -35006,6 +35055,9 @@ function SlotContentRenderer({
   content,
   onDismiss
 }) {
+  const entityProp = content.props.entity;
+  const entityType = typeof entityProp === "string" ? entityProp : "";
+  const storeData = useEntityRef(entityType);
   const PatternComponent = getComponentForPattern(content.pattern);
   if (PatternComponent) {
     const childrenConfig = content.props.children;
@@ -35013,13 +35065,14 @@ function SlotContentRenderer({
     const renderedChildren = hasChildren ? renderPatternChildren(childrenConfig, onDismiss, content.id) : void 0;
     const { children: _childrenConfig, ...restProps } = content.props;
     const renderedProps = renderPatternProps(restProps, onDismiss);
+    const finalProps = entityType ? { ...renderedProps, entity: storeData } : renderedProps;
     return /* @__PURE__ */ jsx(
       Box,
       {
         className: "slot-content",
         "data-pattern": content.pattern,
         "data-id": content.id,
-        children: /* @__PURE__ */ jsx(PatternComponent, { ...renderedProps, children: renderedChildren })
+        children: /* @__PURE__ */ jsx(PatternComponent, { ...finalProps, children: renderedChildren })
       }
     );
   }
@@ -37574,13 +37627,13 @@ function clearEntities() {
   entities = /* @__PURE__ */ new Map();
   notify();
 }
-function getSnapshot2() {
+function getSnapshot3() {
   return entities;
 }
 
 // hooks/useEntities.ts
 function useEntities() {
-  const entities2 = useSyncExternalStore(subscribe, getSnapshot2, getSnapshot2);
+  const entities2 = useSyncExternalStore(subscribe, getSnapshot3, getSnapshot3);
   return {
     entities: entities2,
     getEntity,
@@ -37595,15 +37648,15 @@ function useEntities() {
   };
 }
 function useEntity2(id) {
-  const entities2 = useSyncExternalStore(subscribe, getSnapshot2, getSnapshot2);
+  const entities2 = useSyncExternalStore(subscribe, getSnapshot3, getSnapshot3);
   return entities2.get(id);
 }
 function useEntitiesByType(type) {
-  const entities2 = useSyncExternalStore(subscribe, getSnapshot2, getSnapshot2);
+  const entities2 = useSyncExternalStore(subscribe, getSnapshot3, getSnapshot3);
   return [...entities2.values()].filter((e) => e.type === type);
 }
 function useSingletonEntity(type) {
-  const entities2 = useSyncExternalStore(subscribe, getSnapshot2, getSnapshot2);
+  const entities2 = useSyncExternalStore(subscribe, getSnapshot3, getSnapshot3);
   return [...entities2.values()].find((e) => e.type === type);
 }
 function usePlayer() {

package/dist/providers/EntityStoreProvider.d.ts

@@ -0,0 +1,49 @@
+/**
+ * EntityStoreProvider
+ *
+ * Reactive entity store for Orbital applications. Holds per-entity-type snapshots.
+ * When `advance()` is called (after a persist/set/swap!/atomic response from the server),
+ * all `useEntityRef` subscribers for that entity type re-render with fresh data.
+ * `useEntityWatch` callbacks fire for side effects (toasts, cross-orbital emits).
+ *
+ * This is the client-side half of the `ref` operator. The server-side half is the
+ * initial DB query and auto-fetch-after-mutation in the generated handler / runtime.
+ *
+ * @packageDocumentation
+ */
+import React, { type ReactNode } from 'react';
+type StoreListener = () => void;
+type WatchCallback = (oldData: unknown[], newData: unknown[]) => void;
+export declare function subscribeToStore(listener: StoreListener): () => void;
+/**
+ * Subscribe to an entity type's data reactively.
+ * Re-renders only when the data for this specific entity type changes.
+ *
+ * This is the client-side implementation of the `["ref", "EntityType"]` operator.
+ */
+export declare function useEntityRef(entityType: string): unknown[];
+/**
+ * Register a callback that fires when an entity type's data changes.
+ *
+ * This is the client-side implementation of the `["watch", "EntityType", effects]` operator.
+ * The callback receives (oldData, newData) and should execute side effects (notify, emit, log).
+ */
+export declare function useEntityWatch(entityType: string, callback: WatchCallback): void;
+export interface EntityStoreContextValue {
+    advance: (entityType: string, data: unknown[]) => void;
+    getSnapshot: (entityType: string) => unknown[];
+}
+export declare const EntityStoreContext: React.Context<EntityStoreContextValue>;
+/**
+ * Access the entity store's advance function.
+ * Used by useOrbitalBridge and OrbPreview to push server response data into the store.
+ */
+export declare function useEntityStore(): EntityStoreContextValue;
+/**
+ * Provider component. Wrap the app or page with this to enable entity reactivity.
+ * Already included in OrbitalProvider.
+ */
+export declare function EntityStoreProvider({ children }: {
+    children: ReactNode;
+}): React.ReactElement;
+export {};