@oimdb/react 2.1.2 → 3.0.0

package/dist/index.js

@@ -1,470 +1,351 @@
-// src/hooks/index.ts
-import { useMemo, useRef } from "react";
-import { useSyncExternalStore } from "react";
+// src/OIMDBContext.ts
+import { createContext } from "react";
+var OIMDBContext = createContext(void 0);
 
-// src/hooks/signal.ts
-import { useEffect, useLayoutEffect, useReducer } from "react";
-var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
-function useForceUpdate() {
-  const [, force] = useReducer((c) => c + 1 | 0, 0);
-  return force;
+// src/OIMDBProvider.tsx
+import { jsx } from "react/jsx-runtime";
+function OIMDBProvider({ db, children }) {
+  return /* @__PURE__ */ jsx(OIMDBContext.Provider, { value: db, children });
 }
-var useSelectEntityByPkSignal = (reactiveCollection, pk) => {
-  const force = useForceUpdate();
-  useIsomorphicLayoutEffect(
-    () => reactiveCollection.subscribeOnKey(pk, force),
-    [reactiveCollection, pk]
-  );
-  return reactiveCollection.getOneByPk(pk);
-};
-var useSelectPksByIndexKeyArrayBasedSignal = (reactiveIndex, key) => {
-  const force = useForceUpdate();
-  useIsomorphicLayoutEffect(
-    () => reactiveIndex.subscribeOnKey(key, force),
-    [reactiveIndex, key]
-  );
-  return reactiveIndex.getPksByKey(key);
-};
-var useSelectPksByIndexKeySetBasedSignal = (reactiveIndex, key) => {
-  const force = useForceUpdate();
-  useIsomorphicLayoutEffect(
-    () => reactiveIndex.subscribeOnKey(key, force),
-    [reactiveIndex, key]
-  );
-  return reactiveIndex.getPksByKey(key);
-};
 
-// src/hooks/index.ts
-var EMPTY_ARRAY = [];
-var useSelectPksByIndexKeysSetBased = (reactiveIndex, keys) => {
-  const prevKeysRef = useRef();
-  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
-  if (!keysAreEqual) {
-    prevKeysRef.current = keys;
+// src/useOIMDB.ts
+import { useContext } from "react";
+function useOIMDB() {
+  const db = useContext(OIMDBContext);
+  if (db === void 0) {
+    throw new Error(
+      "useOIMDB: no <OIMDBProvider db={...}> above this component. The hooks that build a computed for the component take the database from it."
+    );
   }
-  const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
-  const snapshotValueRef = useRef();
-  const subscribe = useMemo(() => {
-    snapshotValueRef.current = stableKeys.map((key) => Array.from(reactiveIndex.getPksByKey(key))).flat();
-    return (onStoreChange) => {
-      const updateSnapshot = () => {
-        snapshotValueRef.current = stableKeys.map((key) => Array.from(reactiveIndex.getPksByKey(key))).flat();
-        onStoreChange();
-      };
-      const unsubscribe = reactiveIndex.subscribeOnKeys(
-        stableKeys,
-        updateSnapshot
-      );
-      return () => {
-        unsubscribe();
-      };
-    };
-  }, [reactiveIndex, stableKeys]);
-  const getSnapshot = useMemo(() => {
-    return () => {
-      return snapshotValueRef.current;
-    };
-  }, []);
-  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectPksByIndexKeySetBased = (reactiveIndex, key) => {
-  const snapshotValueRef = useRef();
-  const subscribe = useMemo(() => {
-    snapshotValueRef.current = reactiveIndex.getPksByKey(key);
-    return (onStoreChange) => {
-      const updateSnapshot = () => {
-        snapshotValueRef.current = reactiveIndex.getPksByKey(key);
-        onStoreChange();
-      };
-      return reactiveIndex.subscribeOnKey(key, updateSnapshot);
-    };
-  }, [key, reactiveIndex]);
-  const getSnapshot = useMemo(() => {
-    return () => {
-      return snapshotValueRef.current;
-    };
-  }, []);
-  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectPksByIndexKeysArrayBased = (reactiveIndex, keys) => {
-  const prevKeysRef = useRef();
-  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
-  if (!keysAreEqual) {
-    prevKeysRef.current = keys;
+  return db;
+}
+
+// src/useOIMValue.ts
+import { useMemo } from "react";
+import { OIM_FROZEN_EMPTY_SLOTS, oimRefreshSourceComputeds } from "@oimdb/core";
+
+// src/OIMSnapshotVersion.ts
+import { OIMEffectService } from "@oimdb/core";
+var OIMSnapshotVersion = class {
+  constructor() {
+    this.version = 0;
+    this.getVersion = () => this.version;
   }
-  const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
-  const snapshotValueRef = useRef();
-  const subscribe = useMemo(() => {
-    snapshotValueRef.current = stableKeys.map((key) => reactiveIndex.getPksByKey(key)).flat();
-    return (onStoreChange) => {
-      const updateSnapshot = () => {
-        snapshotValueRef.current = stableKeys.map((key) => reactiveIndex.getPksByKey(key)).flat();
-        onStoreChange();
-      };
-      const unsubscribe = reactiveIndex.subscribeOnKeys(
-        stableKeys,
-        updateSnapshot
-      );
-      return () => {
-        unsubscribe();
-      };
-    };
-  }, [reactiveIndex, stableKeys]);
-  const getSnapshot = useMemo(() => {
-    return () => {
-      return snapshotValueRef.current;
-    };
-  }, []);
-  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectPksByIndexKeyArrayBased = (reactiveIndex, key) => {
-  const prevKeyRef = useRef();
-  const keyAreEqual = prevKeyRef.current === key;
-  if (!keyAreEqual) {
-    prevKeyRef.current = key;
+  subscribeEffect(channelMap, sourceSlots, sourceComputeds, onStoreChange) {
+    this.version++;
+    return OIMEffectService.INSTANCE.subscribeEffect(channelMap, sourceSlots, sourceComputeds, () => {
+      this.version++;
+      onStoreChange();
+    });
   }
-  const snapshotValueRef = useRef();
-  const subscribe = useMemo(() => {
-    snapshotValueRef.current = reactiveIndex.getPksByKey(key);
-    return (onStoreChange) => {
-      const prevKey = prevKeyRef.current;
-      if (!prevKey) {
-        return () => {
-        };
-      }
-      const updateSnapshot = () => {
-        snapshotValueRef.current = reactiveIndex.getPksByKey(prevKey);
-        onStoreChange();
-      };
-      const unsubscribe = reactiveIndex.subscribeOnKey(
-        prevKey,
-        updateSnapshot
-      );
-      return () => {
-        unsubscribe();
-      };
-    };
-  }, [key, reactiveIndex]);
-  const getSnapshot = useMemo(() => {
-    return () => {
-      return snapshotValueRef.current;
-    };
-  }, []);
-  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
 };
-var useSelectEntityByPk = (reactiveCollection, pk) => {
-  const getSnapshot = useMemo(
-    () => () => reactiveCollection.getOneByPk(pk),
-    [pk, reactiveCollection]
-  );
-  const subscribe = useMemo(() => {
-    return (onStoreChange) => {
-      return reactiveCollection.subscribeOnKey(pk, onStoreChange);
+
+// src/useOIMSnapshotVersion.ts
+import { useSyncExternalStore } from "react";
+function useOIMSnapshotVersion(snapshotVersion, subscribe) {
+  return useSyncExternalStore(subscribe, snapshotVersion.getVersion, snapshotVersion.getVersion);
+}
+
+// src/useOIMValue.ts
+function useOIMValue(binding) {
+  const db = useOIMDB();
+  const sourceComputeds = binding.sourceComputeds ?? OIM_FROZEN_EMPTY_SLOTS;
+  const store = useMemo(() => {
+    const snapshotVersion = new OIMSnapshotVersion();
+    return {
+      snapshotVersion,
+      subscribe: (onStoreChange) => snapshotVersion.subscribeEffect(
+        db,
+        binding.sourceSlots ?? OIM_FROZEN_EMPTY_SLOTS,
+        sourceComputeds,
+        onStoreChange
+      )
     };
-  }, [pk, reactiveCollection]);
-  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectValueByObjectKey = (reactiveObject, key) => {
-  const getSnapshot = useMemo(
-    () => () => reactiveObject.get(key),
-    [key, reactiveObject]
+  }, [db, binding, sourceComputeds]);
+  useOIMSnapshotVersion(store.snapshotVersion, store.subscribe);
+  oimRefreshSourceComputeds(sourceComputeds);
+  return binding.derive();
+}
+
+// src/useOIMComputedValue.ts
+import { useMemo as useMemo2 } from "react";
+function useOIMComputedValue(computedSlot) {
+  const binding = useMemo2(() => ({
+    sourceComputeds: [computedSlot],
+    derive: () => computedSlot.value
+  }), [computedSlot]);
+  return useOIMValue(binding);
+}
+
+// src/useOIMSlotByKey.ts
+import { useMemo as useMemo3, useRef } from "react";
+import { OIM_FROZEN_EMPTY_SLOTS as OIM_FROZEN_EMPTY_SLOTS2 } from "@oimdb/core";
+
+// src/oimAssertOneChannel.ts
+function oimAssertOneChannel(channelMap, slot, door) {
+  const storeSlot = slot.storeSlot;
+  if (storeSlot === void 0 || storeSlot.channelSlot === channelMap.defaultChannelSlot) return;
+  throw new Error(
+    `${door}: the slot was filed on another OIMDB than the one <OIMDBProvider> was given, so a write would never wake this component. Build the services and their store slots on the one OIMDB the provider holds.`
   );
-  const subscribe = useMemo(() => {
-    return (onStoreChange) => {
-      return reactiveObject.subscribeOnKey(key, onStoreChange);
-    };
-  }, [key, reactiveObject]);
-  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectValuesByObjectKeys = (reactiveObject, keys) => {
-  const prevKeysRef = useRef();
-  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
-  if (!keysAreEqual) {
-    prevKeysRef.current = keys;
-  }
-  const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
-  const snapshotRef = useRef();
-  const subscribe = useMemo(() => {
-    snapshotRef.current = stableKeys.map((key) => reactiveObject.get(key));
-    return (onStoreChange) => {
-      const updateSnapshot = () => {
-        snapshotRef.current = stableKeys.map(
-          (key) => reactiveObject.get(key)
-        );
-        onStoreChange();
-      };
-      const unsubscribe = reactiveObject.subscribeOnKeys(
-        stableKeys,
-        updateSnapshot
-      );
-      return () => {
-        unsubscribe();
-      };
-    };
-  }, [reactiveObject, stableKeys]);
-  const getSnapshot = useMemo(() => {
-    return () => {
-      return snapshotRef.current;
-    };
-  }, []);
-  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-function arraysEqual(a, b) {
-  if (a === b) return true;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
 }
-var useSelectEntitiesByPks = (reactiveCollection, pks) => {
-  const prevPksRef = useRef();
-  const pksAreEqual = arraysEqual(prevPksRef.current || EMPTY_ARRAY, pks);
-  if (!pksAreEqual) {
-    prevPksRef.current = pks;
-  }
-  const stablePks = pksAreEqual ? prevPksRef.current ?? pks : pks;
-  const snapshotRef = useRef();
-  const subscribe = useMemo(() => {
-    snapshotRef.current = stablePks.map(
-      (pk) => reactiveCollection.getOneByPk(pk)
-    );
-    return (onStoreChange) => {
-      const updateSnapshot = () => {
-        snapshotRef.current = stablePks.map(
-          (pk) => reactiveCollection.getOneByPk(pk)
-        );
-        onStoreChange();
-      };
-      const unsubscribe = reactiveCollection.subscribeOnKeys(
-        stablePks,
-        updateSnapshot
-      );
-      return () => {
-        unsubscribe();
-      };
-    };
-  }, [reactiveCollection, stablePks]);
-  const getSnapshot = useMemo(() => {
-    return () => {
-      return snapshotRef.current;
-    };
-  }, []);
-  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectEntitiesByIndexKeySetBased = (reactiveCollection, reactiveIndex, key) => {
-  const snapshotRef = useRef();
-  const subscribe = useMemo(() => {
-    const readSnapshot = () => Array.from(
-      reactiveIndex.getPksByKey(key),
-      (pk) => reactiveCollection.getOneByPk(pk)
-    );
-    const readPks = () => Array.from(reactiveIndex.getPksByKey(key));
-    snapshotRef.current = readSnapshot();
-    return (onStoreChange) => {
-      let unsubscribeFromCollection = reactiveCollection.subscribeOnKeys(readPks(), () => {
-        snapshotRef.current = readSnapshot();
-        onStoreChange();
-      });
-      const resubscribeCollection = () => {
-        unsubscribeFromCollection();
-        unsubscribeFromCollection = reactiveCollection.subscribeOnKeys(
-          readPks(),
-          () => {
-            snapshotRef.current = readSnapshot();
-            onStoreChange();
-          }
-        );
-      };
-      const unsubscribeFromIndex = reactiveIndex.subscribeOnKey(key, () => {
-        resubscribeCollection();
-        snapshotRef.current = readSnapshot();
-        onStoreChange();
-      });
-      return () => {
-        unsubscribeFromIndex();
-        unsubscribeFromCollection();
-      };
-    };
-  }, [key, reactiveCollection, reactiveIndex]);
-  const getSnapshot = useMemo(() => () => snapshotRef.current, []);
-  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-};
-var useSelectEntitiesByIndexKeysSetBased = (reactiveCollection, reactiveIndex, keys) => {
-  const prevKeysRef = useRef();
-  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
-  if (!keysAreEqual) {
-    prevKeysRef.current = keys;
+
+// src/useOIMSlotByKey.ts
+var sourcesOfRootSlot = (rootSlot) => [[rootSlot], OIM_FROZEN_EMPTY_SLOTS2];
+function useOIMSlotByKey(hookName, slotCollectionService, storeSlot, key, sourcesOfSlot = sourcesOfRootSlot) {
+  const db = useOIMDB();
+  const lastSeenKeyRef = useRef(key);
+  const settledKeyRef = useRef(key);
+  if (key !== lastSeenKeyRef.current) {
+    lastSeenKeyRef.current = key;
+    if (slotCollectionService.getSlotByKey(storeSlot, key) !== slotCollectionService.getSlotByKey(storeSlot, settledKeyRef.current)) {
+      settledKeyRef.current = key;
+    }
   }
-  const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
-  const snapshotRef = useRef();
-  const subscribe = useMemo(() => {
-    const readPks = () => stableKeys.flatMap(
-      (key) => Array.from(reactiveIndex.getPksByKey(key))
-    );
-    const readSnapshot = () => readPks().map((pk) => reactiveCollection.getOneByPk(pk));
-    snapshotRef.current = readSnapshot();
-    return (onStoreChange) => {
-      let unsubscribeFromCollection = reactiveCollection.subscribeOnKeys(readPks(), () => {
-        snapshotRef.current = readSnapshot();
-        onStoreChange();
-      });
-      const resubscribeCollection = () => {
-        unsubscribeFromCollection();
-        unsubscribeFromCollection = reactiveCollection.subscribeOnKeys(
-          readPks(),
-          () => {
-            snapshotRef.current = readSnapshot();
-            onStoreChange();
-          }
-        );
-      };
-      const unsubscribeFromIndex = reactiveIndex.subscribeOnKeys(
-        stableKeys,
-        () => {
-          resubscribeCollection();
-          snapshotRef.current = readSnapshot();
-          onStoreChange();
+  const settledKey = settledKeyRef.current;
+  const store = useMemo3(() => {
+    const snapshotVersion = new OIMSnapshotVersion();
+    let subscribedSlot = void 0;
+    return {
+      snapshotVersion,
+      subscribe: (onStoreChange) => {
+        const holdingSlot = slotCollectionService.holdSlotByKey(storeSlot, settledKey);
+        try {
+          oimAssertOneChannel(db, holdingSlot, hookName);
+          const [sourceSlots, sourceComputeds] = sourcesOfSlot(holdingSlot);
+          const disposeEffect = snapshotVersion.subscribeEffect(db, sourceSlots, sourceComputeds, onStoreChange);
+          subscribedSlot = holdingSlot;
+          return () => {
+            subscribedSlot = void 0;
+            disposeEffect();
+          };
+        } finally {
+          holdingSlot.owner.unholdSlot(holdingSlot);
         }
-      );
-      return () => {
-        unsubscribeFromIndex();
-        unsubscribeFromCollection();
-      };
+      },
+      getSlot: () => subscribedSlot ?? slotCollectionService.getSlotByKey(storeSlot, settledKey)
     };
-  }, [reactiveCollection, reactiveIndex, stableKeys]);
-  const getSnapshot = useMemo(() => () => snapshotRef.current, []);
-  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-};
-var useSelectEntitiesByIndexKeyArrayBased = (reactiveCollection, reactiveIndex, key) => {
-  const snapshotRef = useRef();
-  const subscribe = useMemo(() => {
-    const readSnapshot = () => reactiveIndex.getPksByKey(key).map((pk) => reactiveCollection.getOneByPk(pk));
-    const readPks = () => reactiveIndex.getPksByKey(key);
-    snapshotRef.current = readSnapshot();
-    return (onStoreChange) => {
-      let unsubscribeFromCollection = reactiveCollection.subscribeOnKeys(readPks(), () => {
-        snapshotRef.current = readSnapshot();
-        onStoreChange();
-      });
-      const resubscribeCollection = () => {
-        unsubscribeFromCollection();
-        unsubscribeFromCollection = reactiveCollection.subscribeOnKeys(
-          readPks(),
-          () => {
-            snapshotRef.current = readSnapshot();
-            onStoreChange();
-          }
-        );
-      };
-      const unsubscribeFromIndex = reactiveIndex.subscribeOnKey(key, () => {
-        resubscribeCollection();
-        snapshotRef.current = readSnapshot();
-        onStoreChange();
-      });
-      return () => {
-        unsubscribeFromIndex();
-        unsubscribeFromCollection();
-      };
+  }, [hookName, db, slotCollectionService, storeSlot, settledKey, sourcesOfSlot]);
+  useOIMSnapshotVersion(store.snapshotVersion, store.subscribe);
+  return store.getSlot();
+}
+
+// src/useOIMEntity.ts
+function useOIMEntity(entityCollectionService, entityStoreSlot, key) {
+  return useOIMSlotByKey("useOIMEntity", entityCollectionService, entityStoreSlot, key).entity;
+}
+
+// src/useOIMSingleSlot.ts
+import { useMemo as useMemo4 } from "react";
+function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot) {
+  const db = useOIMDB();
+  const store = useMemo4(() => {
+    const snapshotVersion = new OIMSnapshotVersion();
+    let subscribedSlot = void 0;
+    return {
+      snapshotVersion,
+      subscribe: (onStoreChange) => {
+        const holdingSlot = singleSlotService.holdSingleSlot(singleSlotStoreSlot);
+        try {
+          oimAssertOneChannel(db, holdingSlot, hookName);
+          const disposeEffect = snapshotVersion.subscribeEffect(db, [holdingSlot], [], onStoreChange);
+          subscribedSlot = holdingSlot;
+          return () => {
+            subscribedSlot = void 0;
+            disposeEffect();
+          };
+        } finally {
+          holdingSlot.owner.unholdSlot(holdingSlot);
+        }
+      },
+      getSlot: () => subscribedSlot ?? singleSlotService.getSingleSlot(singleSlotStoreSlot)
     };
-  }, [key, reactiveCollection, reactiveIndex]);
-  const getSnapshot = useMemo(() => () => snapshotRef.current, []);
-  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-};
-var useSelectEntitiesByIndexKeysArrayBased = (reactiveCollection, reactiveIndex, keys) => {
-  const prevKeysRef = useRef();
-  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
-  if (!keysAreEqual) {
-    prevKeysRef.current = keys;
+  }, [hookName, db, singleSlotService, singleSlotStoreSlot]);
+  useOIMSnapshotVersion(store.snapshotVersion, store.subscribe);
+  return store.getSlot();
+}
+
+// src/useOIMSingleEntity.ts
+function useOIMSingleEntity(singleSlotService, singleSlotStoreSlot) {
+  return useOIMSingleSlot("useOIMSingleEntity", singleSlotService, singleSlotStoreSlot).entity;
+}
+
+// src/useOIMSingleBucketSlots.ts
+function useOIMSingleBucketSlots(singleSlotService, singleSlotStoreSlot) {
+  const bucketSlot = useOIMSingleSlot("useOIMSingleBucketSlots", singleSlotService, singleSlotStoreSlot);
+  return Array.from(singleSlotService.slotContentService.getBucketMemberSlots(bucketSlot));
+}
+
+// src/useOIMField.ts
+import { useMemo as useMemo5 } from "react";
+
+// src/holdWhileSubscribed.ts
+import { oimHoldSlots, oimUnholdSlotsIfAlive } from "@oimdb/core";
+function holdWhileSubscribed(slots, subscribe) {
+  oimHoldSlots(slots);
+  const giveEveryHoldBack = () => {
+    oimUnholdSlotsIfAlive(slots);
+  };
+  let disposer;
+  try {
+    disposer = subscribe();
+  } catch (failure) {
+    giveEveryHoldBack();
+    throw failure;
   }
-  const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
-  const snapshotRef = useRef();
-  const subscribe = useMemo(() => {
-    const readPks = () => stableKeys.flatMap((key) => reactiveIndex.getPksByKey(key));
-    const readSnapshot = () => readPks().map((pk) => reactiveCollection.getOneByPk(pk));
-    snapshotRef.current = readSnapshot();
-    return (onStoreChange) => {
-      let unsubscribeFromCollection = reactiveCollection.subscribeOnKeys(readPks(), () => {
-        snapshotRef.current = readSnapshot();
-        onStoreChange();
-      });
-      const resubscribeCollection = () => {
-        unsubscribeFromCollection();
-        unsubscribeFromCollection = reactiveCollection.subscribeOnKeys(
-          readPks(),
-          () => {
-            snapshotRef.current = readSnapshot();
-            onStoreChange();
-          }
-        );
-      };
-      const unsubscribeFromIndex = reactiveIndex.subscribeOnKeys(
-        stableKeys,
-        () => {
-          resubscribeCollection();
-          snapshotRef.current = readSnapshot();
-          onStoreChange();
-        }
-      );
-      return () => {
-        unsubscribeFromIndex();
-        unsubscribeFromCollection();
-      };
+  return () => {
+    try {
+      disposer();
+    } finally {
+      giveEveryHoldBack();
+    }
+  };
+}
+
+// src/useOIMField.ts
+function useOIMField(entityCollectionService, slot, name) {
+  const db = useOIMDB();
+  const store = useMemo5(() => {
+    oimAssertOneChannel(db, slot, "useOIMField");
+    const holds = [slot];
+    const snapshotVersion = new OIMSnapshotVersion();
+    return {
+      snapshotVersion,
+      subscribe: (onStoreChange) => holdWhileSubscribed(holds, () => snapshotVersion.subscribeEffect(
+        db,
+        [entityCollectionService.getColumn(slot, name)],
+        [],
+        onStoreChange
+      ))
     };
-  }, [reactiveCollection, reactiveIndex, stableKeys]);
-  const getSnapshot = useMemo(() => () => snapshotRef.current, []);
-  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-};
+  }, [db, entityCollectionService, slot, name]);
+  useOIMSnapshotVersion(store.snapshotVersion, store.subscribe);
+  return slot.entity?.[name];
+}
 
-// src/context/index.tsx
-import { createContext, useContext } from "react";
-import { jsx } from "react/jsx-runtime";
-var OIMCollectionsContext = createContext(
-  {}
-);
-function createOIMCollectionsContext() {
-  return createContext({});
+// src/useOIMBucketSlots.ts
+import { useMemo as useMemo6 } from "react";
+function useOIMBucketSlots(bucketCollectionService, bucketSlot) {
+  const db = useOIMDB();
+  const binding = useMemo6(() => {
+    oimAssertOneChannel(db, bucketSlot, "useOIMBucketSlots");
+    return { sourceSlots: [bucketSlot], derive: () => bucketSlot };
+  }, [db, bucketSlot]);
+  const { changedAtRevision, changedAtEpoch } = useOIMValue(binding);
+  return useMemo6(
+    () => Array.from(bucketCollectionService.slotContentService.getBucketMemberSlots(bucketSlot)),
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- the bucket slot's change stamp moves exactly when its members do
+    [bucketCollectionService, bucketSlot, changedAtRevision, changedAtEpoch]
+  );
 }
-function OIMCollectionsProvider({ collections, children, context }) {
-  const ContextToUse = context || OIMCollectionsContext;
-  return /* @__PURE__ */ jsx(ContextToUse.Provider, { value: collections, children });
+
+// src/useOIMBucketSlotsByKey.ts
+function useOIMBucketSlotsByKey(bucketCollectionService, bucketStoreSlot, key) {
+  const bucketSlot = useOIMSlotByKey("useOIMBucketSlotsByKey", bucketCollectionService, bucketStoreSlot, key);
+  return Array.from(bucketCollectionService.slotContentService.getBucketMemberSlots(bucketSlot));
 }
-function useOIMCollectionsContext(context) {
-  const contextToUse = context || OIMCollectionsContext;
-  const collections = useContext(contextToUse);
-  if (!collections || Object.keys(collections).length === 0) {
-    throw new Error(
-      "useOIMCollectionsContext must be used within an OIMCollectionsProvider"
-    );
+
+// src/useOIMSlotsByKeys.ts
+import { useEffect, useRef as useRef2, useState } from "react";
+import { oimSameKeySequence } from "@oimdb/core";
+function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
+  const settledKeys = useRef2(keys);
+  const previousKeys = settledKeys.current;
+  if (!oimSameKeySequence(previousKeys, keys)) settledKeys.current = keys;
+  const keysToHold = settledKeys.current;
+  const [, resolveAgain] = useState(0);
+  const resolvedSlots = useRef2(void 0);
+  const resolvedKeys = useRef2(keysToHold);
+  const resolvedSlotCollectionService = useRef2(slotCollectionService);
+  const resolvedStoreSlot = useRef2(storeSlot);
+  if (resolvedSlots.current === void 0 || resolvedKeys.current !== keysToHold || resolvedSlotCollectionService.current !== slotCollectionService || resolvedStoreSlot.current !== storeSlot) {
+    const slots2 = [];
+    for (let i = 0; i < keysToHold.length; i++) {
+      slots2.push(slotCollectionService.getSlotByKey(storeSlot, keysToHold[i]));
+    }
+    resolvedSlots.current = slots2;
+    resolvedKeys.current = keysToHold;
+    resolvedSlotCollectionService.current = slotCollectionService;
+    resolvedStoreSlot.current = storeSlot;
   }
-  return collections;
+  const slots = resolvedSlots.current;
+  useEffect(() => {
+    const renderedSlots = resolvedSlots.current;
+    const heldSlots = [];
+    let someKeyNamesAnotherIdentityNow = false;
+    for (let i = 0; i < keysToHold.length; i++) {
+      const slot = slotCollectionService.holdSlotByKey(storeSlot, keysToHold[i]);
+      heldSlots.push(slot);
+      if (slot !== renderedSlots?.[i]) someKeyNamesAnotherIdentityNow = true;
+    }
+    if (someKeyNamesAnotherIdentityNow) {
+      resolvedSlots.current = void 0;
+      resolveAgain((version) => version + 1);
+    }
+    return () => {
+      for (let i = 0; i < heldSlots.length; i++) {
+        const heldSlot = heldSlots[i];
+        heldSlot.owner.unholdSlot(heldSlot);
+      }
+    };
+  }, [slotCollectionService, storeSlot, keysToHold]);
+  return slots;
+}
+
+// src/useOIMComputedValueByKey.ts
+import { OIM_FROZEN_EMPTY_SLOTS as OIM_FROZEN_EMPTY_SLOTS3 } from "@oimdb/core";
+var sourcesOfComputedSlot = (computedSlot) => [OIM_FROZEN_EMPTY_SLOTS3, [computedSlot]];
+function useOIMComputedValueByKey(computedCollectionService, computedStoreSlot, key) {
+  const computedSlot = useOIMSlotByKey(
+    "useOIMComputedValueByKey",
+    computedCollectionService,
+    computedStoreSlot,
+    key,
+    sourcesOfComputedSlot
+  );
+  return computedSlot.computedValueService.getValueForSlot(computedSlot);
+}
+
+// src/useOIMSingleComputedValue.ts
+import { useMemo as useMemo7 } from "react";
+function useOIMSingleComputedValue(computedService, derive, createSources, dependencyList) {
+  const db = useOIMDB();
+  const computedStoreSlot = useMemo7(
+    () => computedService.createComputedStoreSlot(db, derive, createSources),
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- the caller's list is checked at the call site
+    [db, computedService, ...dependencyList]
+  );
+  return useOIMComputedValueByKey(
+    computedService.computedCollectionService,
+    computedStoreSlot,
+    void 0
+  );
+}
+
+// src/useOIMComputedCollection.ts
+import { useMemo as useMemo8 } from "react";
+function useOIMComputedCollection(computedService, derive, createSources, dependencyList) {
+  const db = useOIMDB();
+  return useMemo8(
+    () => computedService.createComputedStoreSlot(db, derive, createSources),
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- the caller's list is checked at the call site
+    [db, computedService, ...dependencyList]
+  );
 }
 export {
-  OIMCollectionsContext,
-  OIMCollectionsProvider,
-  createOIMCollectionsContext,
-  useOIMCollectionsContext,
-  useSelectEntitiesByIndexKeyArrayBased,
-  useSelectEntitiesByIndexKeySetBased,
-  useSelectEntitiesByIndexKeysArrayBased,
-  useSelectEntitiesByIndexKeysSetBased,
-  useSelectEntitiesByPks,
-  useSelectEntityByPk,
-  useSelectEntityByPkSignal,
-  useSelectPksByIndexKeyArrayBased,
-  useSelectPksByIndexKeyArrayBasedSignal,
-  useSelectPksByIndexKeySetBased,
-  useSelectPksByIndexKeySetBasedSignal,
-  useSelectPksByIndexKeysArrayBased,
-  useSelectPksByIndexKeysSetBased,
-  useSelectValueByObjectKey,
-  useSelectValuesByObjectKeys
+  OIMDBContext,
+  OIMDBProvider,
+  useOIMBucketSlots,
+  useOIMBucketSlotsByKey,
+  useOIMComputedCollection,
+  useOIMComputedValue,
+  useOIMComputedValueByKey,
+  useOIMDB,
+  useOIMEntity,
+  useOIMField,
+  useOIMSingleBucketSlots,
+  useOIMSingleComputedValue,
+  useOIMSingleEntity,
+  useOIMSlotsByKeys,
+  useOIMValue
 };