@oimdb/react 2.1.2 → 3.0.0

package/dist/index.cjs

@@ -20,496 +20,373 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  OIMCollectionsContext: () => OIMCollectionsContext,
-  OIMCollectionsProvider: () => OIMCollectionsProvider,
-  createOIMCollectionsContext: () => createOIMCollectionsContext,
-  useOIMCollectionsContext: () => useOIMCollectionsContext,
-  useSelectEntitiesByIndexKeyArrayBased: () => useSelectEntitiesByIndexKeyArrayBased,
-  useSelectEntitiesByIndexKeySetBased: () => useSelectEntitiesByIndexKeySetBased,
-  useSelectEntitiesByIndexKeysArrayBased: () => useSelectEntitiesByIndexKeysArrayBased,
-  useSelectEntitiesByIndexKeysSetBased: () => useSelectEntitiesByIndexKeysSetBased,
-  useSelectEntitiesByPks: () => useSelectEntitiesByPks,
-  useSelectEntityByPk: () => useSelectEntityByPk,
-  useSelectEntityByPkSignal: () => useSelectEntityByPkSignal,
-  useSelectPksByIndexKeyArrayBased: () => useSelectPksByIndexKeyArrayBased,
-  useSelectPksByIndexKeyArrayBasedSignal: () => useSelectPksByIndexKeyArrayBasedSignal,
-  useSelectPksByIndexKeySetBased: () => useSelectPksByIndexKeySetBased,
-  useSelectPksByIndexKeySetBasedSignal: () => useSelectPksByIndexKeySetBasedSignal,
-  useSelectPksByIndexKeysArrayBased: () => useSelectPksByIndexKeysArrayBased,
-  useSelectPksByIndexKeysSetBased: () => useSelectPksByIndexKeysSetBased,
-  useSelectValueByObjectKey: () => useSelectValueByObjectKey,
-  useSelectValuesByObjectKeys: () => useSelectValuesByObjectKeys
+  OIMDBContext: () => OIMDBContext,
+  OIMDBProvider: () => OIMDBProvider,
+  useOIMBucketSlots: () => useOIMBucketSlots,
+  useOIMBucketSlotsByKey: () => useOIMBucketSlotsByKey,
+  useOIMComputedCollection: () => useOIMComputedCollection,
+  useOIMComputedValue: () => useOIMComputedValue,
+  useOIMComputedValueByKey: () => useOIMComputedValueByKey,
+  useOIMDB: () => useOIMDB,
+  useOIMEntity: () => useOIMEntity,
+  useOIMField: () => useOIMField,
+  useOIMSingleBucketSlots: () => useOIMSingleBucketSlots,
+  useOIMSingleComputedValue: () => useOIMSingleComputedValue,
+  useOIMSingleEntity: () => useOIMSingleEntity,
+  useOIMSlotsByKeys: () => useOIMSlotsByKeys,
+  useOIMValue: () => useOIMValue
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/hooks/index.ts
-var import_react2 = require("react");
-var import_react3 = require("react");
-
-// src/hooks/signal.ts
+// src/OIMDBContext.ts
 var import_react = require("react");
-var useIsomorphicLayoutEffect = typeof window !== "undefined" ? import_react.useLayoutEffect : import_react.useEffect;
-function useForceUpdate() {
-  const [, force] = (0, import_react.useReducer)((c) => c + 1 | 0, 0);
-  return force;
+var OIMDBContext = (0, import_react.createContext)(void 0);
+
+// src/OIMDBProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function OIMDBProvider({ db, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.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 = (0, import_react2.useRef)();
-  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
-  if (!keysAreEqual) {
-    prevKeysRef.current = keys;
+// src/useOIMDB.ts
+var import_react2 = require("react");
+function useOIMDB() {
+  const db = (0, import_react2.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 = (0, import_react2.useRef)();
-  const subscribe = (0, import_react2.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 = (0, import_react2.useMemo)(() => {
-    return () => {
-      return snapshotValueRef.current;
-    };
-  }, []);
-  const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectPksByIndexKeySetBased = (reactiveIndex, key) => {
-  const snapshotValueRef = (0, import_react2.useRef)();
-  const subscribe = (0, import_react2.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 = (0, import_react2.useMemo)(() => {
-    return () => {
-      return snapshotValueRef.current;
-    };
-  }, []);
-  const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectPksByIndexKeysArrayBased = (reactiveIndex, keys) => {
-  const prevKeysRef = (0, import_react2.useRef)();
-  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
-  if (!keysAreEqual) {
-    prevKeysRef.current = keys;
+  return db;
+}
+
+// src/useOIMValue.ts
+var import_react4 = require("react");
+var import_core2 = require("@oimdb/core");
+
+// src/OIMSnapshotVersion.ts
+var import_core = require("@oimdb/core");
+var OIMSnapshotVersion = class {
+  constructor() {
+    this.version = 0;
+    this.getVersion = () => this.version;
   }
-  const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
-  const snapshotValueRef = (0, import_react2.useRef)();
-  const subscribe = (0, import_react2.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 = (0, import_react2.useMemo)(() => {
-    return () => {
-      return snapshotValueRef.current;
-    };
-  }, []);
-  const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectPksByIndexKeyArrayBased = (reactiveIndex, key) => {
-  const prevKeyRef = (0, import_react2.useRef)();
-  const keyAreEqual = prevKeyRef.current === key;
-  if (!keyAreEqual) {
-    prevKeyRef.current = key;
+  subscribeEffect(channelMap, sourceSlots, sourceComputeds, onStoreChange) {
+    this.version++;
+    return import_core.OIMEffectService.INSTANCE.subscribeEffect(channelMap, sourceSlots, sourceComputeds, () => {
+      this.version++;
+      onStoreChange();
+    });
   }
-  const snapshotValueRef = (0, import_react2.useRef)();
-  const subscribe = (0, import_react2.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 = (0, import_react2.useMemo)(() => {
-    return () => {
-      return snapshotValueRef.current;
-    };
-  }, []);
-  const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
 };
-var useSelectEntityByPk = (reactiveCollection, pk) => {
-  const getSnapshot = (0, import_react2.useMemo)(
-    () => () => reactiveCollection.getOneByPk(pk),
-    [pk, reactiveCollection]
-  );
-  const subscribe = (0, import_react2.useMemo)(() => {
-    return (onStoreChange) => {
-      return reactiveCollection.subscribeOnKey(pk, onStoreChange);
+
+// src/useOIMSnapshotVersion.ts
+var import_react3 = require("react");
+function useOIMSnapshotVersion(snapshotVersion, subscribe) {
+  return (0, import_react3.useSyncExternalStore)(subscribe, snapshotVersion.getVersion, snapshotVersion.getVersion);
+}
+
+// src/useOIMValue.ts
+function useOIMValue(binding) {
+  const db = useOIMDB();
+  const sourceComputeds = binding.sourceComputeds ?? import_core2.OIM_FROZEN_EMPTY_SLOTS;
+  const store = (0, import_react4.useMemo)(() => {
+    const snapshotVersion = new OIMSnapshotVersion();
+    return {
+      snapshotVersion,
+      subscribe: (onStoreChange) => snapshotVersion.subscribeEffect(
+        db,
+        binding.sourceSlots ?? import_core2.OIM_FROZEN_EMPTY_SLOTS,
+        sourceComputeds,
+        onStoreChange
+      )
     };
-  }, [pk, reactiveCollection]);
-  const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectValueByObjectKey = (reactiveObject, key) => {
-  const getSnapshot = (0, import_react2.useMemo)(
-    () => () => reactiveObject.get(key),
-    [key, reactiveObject]
+  }, [db, binding, sourceComputeds]);
+  useOIMSnapshotVersion(store.snapshotVersion, store.subscribe);
+  (0, import_core2.oimRefreshSourceComputeds)(sourceComputeds);
+  return binding.derive();
+}
+
+// src/useOIMComputedValue.ts
+var import_react5 = require("react");
+function useOIMComputedValue(computedSlot) {
+  const binding = (0, import_react5.useMemo)(() => ({
+    sourceComputeds: [computedSlot],
+    derive: () => computedSlot.value
+  }), [computedSlot]);
+  return useOIMValue(binding);
+}
+
+// src/useOIMSlotByKey.ts
+var import_react6 = require("react");
+var import_core3 = require("@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 = (0, import_react2.useMemo)(() => {
-    return (onStoreChange) => {
-      return reactiveObject.subscribeOnKey(key, onStoreChange);
-    };
-  }, [key, reactiveObject]);
-  const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectValuesByObjectKeys = (reactiveObject, keys) => {
-  const prevKeysRef = (0, import_react2.useRef)();
-  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
-  if (!keysAreEqual) {
-    prevKeysRef.current = keys;
-  }
-  const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
-  const snapshotRef = (0, import_react2.useRef)();
-  const subscribe = (0, import_react2.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 = (0, import_react2.useMemo)(() => {
-    return () => {
-      return snapshotRef.current;
-    };
-  }, []);
-  const snapshot = (0, import_react3.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 = (0, import_react2.useRef)();
-  const pksAreEqual = arraysEqual(prevPksRef.current || EMPTY_ARRAY, pks);
-  if (!pksAreEqual) {
-    prevPksRef.current = pks;
-  }
-  const stablePks = pksAreEqual ? prevPksRef.current ?? pks : pks;
-  const snapshotRef = (0, import_react2.useRef)();
-  const subscribe = (0, import_react2.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 = (0, import_react2.useMemo)(() => {
-    return () => {
-      return snapshotRef.current;
-    };
-  }, []);
-  const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-  return snapshot;
-};
-var useSelectEntitiesByIndexKeySetBased = (reactiveCollection, reactiveIndex, key) => {
-  const snapshotRef = (0, import_react2.useRef)();
-  const subscribe = (0, import_react2.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 = (0, import_react2.useMemo)(() => () => snapshotRef.current, []);
-  return (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-};
-var useSelectEntitiesByIndexKeysSetBased = (reactiveCollection, reactiveIndex, keys) => {
-  const prevKeysRef = (0, import_react2.useRef)();
-  const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
-  if (!keysAreEqual) {
-    prevKeysRef.current = keys;
+
+// src/useOIMSlotByKey.ts
+var sourcesOfRootSlot = (rootSlot) => [[rootSlot], import_core3.OIM_FROZEN_EMPTY_SLOTS];
+function useOIMSlotByKey(hookName, slotCollectionService, storeSlot, key, sourcesOfSlot = sourcesOfRootSlot) {
+  const db = useOIMDB();
+  const lastSeenKeyRef = (0, import_react6.useRef)(key);
+  const settledKeyRef = (0, import_react6.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 = (0, import_react2.useRef)();
-  const subscribe = (0, import_react2.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 = (0, import_react6.useMemo)(() => {
+    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 = (0, import_react2.useMemo)(() => () => snapshotRef.current, []);
-  return (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-};
-var useSelectEntitiesByIndexKeyArrayBased = (reactiveCollection, reactiveIndex, key) => {
-  const snapshotRef = (0, import_react2.useRef)();
-  const subscribe = (0, import_react2.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
+var import_react7 = require("react");
+function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot) {
+  const db = useOIMDB();
+  const store = (0, import_react7.useMemo)(() => {
+    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 = (0, import_react2.useMemo)(() => () => snapshotRef.current, []);
-  return (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-};
-var useSelectEntitiesByIndexKeysArrayBased = (reactiveCollection, reactiveIndex, keys) => {
-  const prevKeysRef = (0, import_react2.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
+var import_react8 = require("react");
+
+// src/holdWhileSubscribed.ts
+var import_core4 = require("@oimdb/core");
+function holdWhileSubscribed(slots, subscribe) {
+  (0, import_core4.oimHoldSlots)(slots);
+  const giveEveryHoldBack = () => {
+    (0, import_core4.oimUnholdSlotsIfAlive)(slots);
+  };
+  let disposer;
+  try {
+    disposer = subscribe();
+  } catch (failure) {
+    giveEveryHoldBack();
+    throw failure;
   }
-  const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
-  const snapshotRef = (0, import_react2.useRef)();
-  const subscribe = (0, import_react2.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 = (0, import_react8.useMemo)(() => {
+    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 = (0, import_react2.useMemo)(() => () => snapshotRef.current, []);
-  return (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-};
+  }, [db, entityCollectionService, slot, name]);
+  useOIMSnapshotVersion(store.snapshotVersion, store.subscribe);
+  return slot.entity?.[name];
+}
 
-// src/context/index.tsx
-var import_react4 = require("react");
-var import_jsx_runtime = require("react/jsx-runtime");
-var OIMCollectionsContext = (0, import_react4.createContext)(
-  {}
-);
-function createOIMCollectionsContext() {
-  return (0, import_react4.createContext)({});
+// src/useOIMBucketSlots.ts
+var import_react9 = require("react");
+function useOIMBucketSlots(bucketCollectionService, bucketSlot) {
+  const db = useOIMDB();
+  const binding = (0, import_react9.useMemo)(() => {
+    oimAssertOneChannel(db, bucketSlot, "useOIMBucketSlots");
+    return { sourceSlots: [bucketSlot], derive: () => bucketSlot };
+  }, [db, bucketSlot]);
+  const { changedAtRevision, changedAtEpoch } = useOIMValue(binding);
+  return (0, import_react9.useMemo)(
+    () => 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__ */ (0, import_jsx_runtime.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 = (0, import_react4.useContext)(contextToUse);
-  if (!collections || Object.keys(collections).length === 0) {
-    throw new Error(
-      "useOIMCollectionsContext must be used within an OIMCollectionsProvider"
-    );
+
+// src/useOIMSlotsByKeys.ts
+var import_react10 = require("react");
+var import_core5 = require("@oimdb/core");
+function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
+  const settledKeys = (0, import_react10.useRef)(keys);
+  const previousKeys = settledKeys.current;
+  if (!(0, import_core5.oimSameKeySequence)(previousKeys, keys)) settledKeys.current = keys;
+  const keysToHold = settledKeys.current;
+  const [, resolveAgain] = (0, import_react10.useState)(0);
+  const resolvedSlots = (0, import_react10.useRef)(void 0);
+  const resolvedKeys = (0, import_react10.useRef)(keysToHold);
+  const resolvedSlotCollectionService = (0, import_react10.useRef)(slotCollectionService);
+  const resolvedStoreSlot = (0, import_react10.useRef)(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;
+  (0, import_react10.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
+var import_core6 = require("@oimdb/core");
+var sourcesOfComputedSlot = (computedSlot) => [import_core6.OIM_FROZEN_EMPTY_SLOTS, [computedSlot]];
+function useOIMComputedValueByKey(computedCollectionService, computedStoreSlot, key) {
+  const computedSlot = useOIMSlotByKey(
+    "useOIMComputedValueByKey",
+    computedCollectionService,
+    computedStoreSlot,
+    key,
+    sourcesOfComputedSlot
+  );
+  return computedSlot.computedValueService.getValueForSlot(computedSlot);
+}
+
+// src/useOIMSingleComputedValue.ts
+var import_react11 = require("react");
+function useOIMSingleComputedValue(computedService, derive, createSources, dependencyList) {
+  const db = useOIMDB();
+  const computedStoreSlot = (0, import_react11.useMemo)(
+    () => 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
+var import_react12 = require("react");
+function useOIMComputedCollection(computedService, derive, createSources, dependencyList) {
+  const db = useOIMDB();
+  return (0, import_react12.useMemo)(
+    () => 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]
+  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  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
 });