@oimdb/react 3.0.0 → 3.2.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { DependencyList } from 'react';
-import { OIMDB, TOIMSlot, TOIMComputedSlot, TOIMStoreKey, OIMSlotCollectionService, TOIMEntitySlot, TOIMStoreSlot, OIMSingleSlotService, TOIMSingleSlotStore, TOIMBucketSlot, OIMSlotContentBucketService, TOIMEntityColumnName, TOIMColumnSlot, TOIMEntityColumnValue, TOIMIndexableSlot, OIMComputedService, TOIMComputedSources, TOIMComputedStoreSlot } from '@oimdb/core';
+import { OIMDB, TOIMSlot, TOIMComputedContentSlot, TOIMStoreKey, TOIMStoreSlot, TOIMEntitySlot, OIMSlotCollectionService, TOIMSingleSlotStore, TOIMEntityContentSlot, OIMSingleSlotService, TOIMBucketContentSlot, OIMSlotContentBucketService, TOIMEntityColumnName, OIMColumnSlotService, TOIMColumnSlot, OIMColumnSlotOwner, TOIMEntityColumnValue, TOIMBucketSlot, TOIMIndexableSlot, TOIMComputedSlot, OIMSingleComputedService, TOIMComputedSources, OIMComputedService, TOIMComputedStoreSlot } from '@oimdb/core';
 
 declare const OIMDBContext: React.Context<OIMDB | undefined>;
 
@@ -13,7 +13,7 @@ declare function useOIMDB(): OIMDB;
 
 type TOIMBinding<TValue> = {
     readonly sourceSlots?: readonly TOIMSlot[] | undefined;
-    readonly sourceComputeds?: readonly TOIMComputedSlot[] | undefined;
+    readonly sourceComputeds?: readonly TOIMComputedContentSlot[] | undefined;
     readonly derive: () => TValue;
 };
 
@@ -26,32 +26,36 @@ type TOIMBinding<TValue> = {
  */
 declare function useOIMValue<TValue>(binding: TOIMBinding<TValue>): TValue;
 
-declare function useOIMComputedValue<TValue>(computedSlot: TOIMComputedSlot<TValue>): TValue;
+declare function useOIMComputedValue<TValue>(computedSlot: TOIMComputedContentSlot<TValue>): TValue;
 
-declare function useOIMEntity<TEntity extends object, TKey = TOIMStoreKey, TStore = unknown>(entityCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, entityStoreSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, key: TKey): TEntity | undefined;
+declare function useOIMEntity<TEntity extends object, TKey extends NonNullable<unknown> = TOIMStoreKey, TStore = unknown>(entityStoreSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>, unknown, Pick<OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>>, key: TKey): TEntity | undefined;
 
-declare function useOIMSingleEntity<TEntity extends object>(singleSlotService: Pick<OIMSingleSlotService<TOIMEntitySlot<TEntity, void>, unknown>, 'getSingleSlot' | 'holdSingleSlot'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMEntitySlot<TEntity, void>>, TOIMEntitySlot<TEntity, void>>): TEntity | undefined;
+declare function useOIMSingleEntity<TEntity extends object>(singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMEntityContentSlot<TEntity>>, TOIMEntityContentSlot<TEntity>, unknown, Pick<OIMSingleSlotService<TOIMEntityContentSlot<TEntity>, unknown>, 'getSingleSlot' | 'holdSingleSlot'>>): TEntity | undefined;
 
-declare function useOIMSingleBucketSlots<TEntity extends object, TSlots = unknown>(singleSlotService: Pick<OIMSingleSlotService<TOIMBucketSlot<TSlots, void>, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSingleSlot' | 'holdSingleSlot' | 'slotContentService'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMBucketSlot<TSlots, void>>, TOIMBucketSlot<TSlots, void>>): readonly TOIMEntitySlot<TEntity>[];
+declare function useOIMSingleBucketSlots<TEntity extends object, TSlots = unknown>(singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMBucketContentSlot<TSlots>>, TOIMBucketContentSlot<TSlots>, unknown, Pick<OIMSingleSlotService<TOIMBucketContentSlot<TSlots>, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSingleSlot' | 'holdSingleSlot' | 'slotContentService'>>): readonly TOIMEntitySlot<TEntity>[];
 
 /**
  * One field of one identity. It cannot go through {@link useOIMValue}: a column identity is
  * minted INSIDE the subscription, so there is no root slot a binding could name. `slot` is an
  * ENTITY SLOT because an entity slot is what can be taken out from under this component — ../README.md.
  */
-declare function useOIMField<TEntity extends object, TName extends TOIMEntityColumnName<TEntity>, TKey = TOIMStoreKey>(entityCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, unknown, unknown, TName, TOIMColumnSlot>, 'getColumn'>, slot: TOIMEntitySlot<TEntity, TKey>, name: TName): TOIMEntityColumnValue<TEntity, TName> | undefined;
+declare function useOIMField<TEntity extends object, TName extends TOIMEntityColumnName<TEntity>, TKey extends NonNullable<unknown> = TOIMStoreKey>(entityCollectionService: {
+    readonly columnSlotService: Pick<OIMColumnSlotService<TOIMEntitySlot<TEntity, TKey>, TName, TOIMColumnSlot, OIMColumnSlotOwner<TOIMSlot, TOIMColumnSlot>>, 'getColumn'>;
+}, slot: TOIMEntitySlot<TEntity, TKey>, name: TName): TOIMEntityColumnValue<TEntity, TName> | undefined;
 
 /** A bucket's slots, copied out of the service's LIVE container, in the collection's order. */
-declare function useOIMBucketSlots<TEntity extends object, TSlots = unknown>(bucketCollectionService: Pick<OIMSlotCollectionService<unknown, TOIMBucketSlot<TSlots>, unknown, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'slotContentService'>, bucketSlot: TOIMBucketSlot<TSlots>): readonly TOIMEntitySlot<TEntity>[];
+declare function useOIMBucketSlots<TEntity extends object, TSlots = unknown>(bucketCollectionService: {
+    readonly slotContentService: Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>;
+}, bucketSlot: TOIMBucketContentSlot<TSlots>): readonly TOIMEntitySlot<TEntity>[];
 
-declare function useOIMBucketSlotsByKey<TEntity extends object, TSlots = unknown, TKey = TOIMStoreKey, TStore = unknown>(bucketCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSlotByKey' | 'holdSlotByKey' | 'slotContentService'>, bucketStoreSlot: TOIMStoreSlot<TStore, TOIMBucketSlot<TSlots, TKey>>, key: TKey): readonly TOIMEntitySlot<TEntity>[];
+declare function useOIMBucketSlotsByKey<TEntity extends object, TSlots = unknown, TKey extends NonNullable<unknown> = TOIMStoreKey, TStore = unknown>(bucketStoreSlot: TOIMStoreSlot<TStore, TOIMBucketSlot<TSlots, TKey>, unknown, Pick<OIMSlotCollectionService<TKey, TOIMBucketSlot<TSlots, TKey>, TStore, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSlotByKey' | 'holdSlotByKey' | 'slotContentService'>>, key: TKey): readonly TOIMEntitySlot<TEntity>[];
 
-declare function useOIMSlotsByKeys<TKey, TSlot extends TOIMIndexableSlot<TKey>, TStore = unknown>(slotCollectionService: Pick<OIMSlotCollectionService<TKey, TSlot, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, storeSlot: TOIMStoreSlot<TStore, TSlot>, keys: readonly TKey[]): readonly TSlot[];
+declare function useOIMSlotsByKeys<TKey extends NonNullable<unknown>, TSlot extends TOIMIndexableSlot<TKey>, TStore = unknown>(storeSlot: TOIMStoreSlot<TStore, TSlot, unknown, Pick<OIMSlotCollectionService<TKey, TSlot, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>>, keys: readonly TKey[]): readonly TSlot[];
 
-declare function useOIMComputedValueByKey<TValue, TKey = TOIMStoreKey, TStore = unknown>(computedCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMComputedSlot<TValue, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, computedStoreSlot: TOIMStoreSlot<TStore, TOIMComputedSlot<TValue, TKey>>, key: TKey): TValue;
+declare function useOIMComputedValueByKey<TValue, TKey extends NonNullable<unknown> = TOIMStoreKey, TStore = unknown>(computedStoreSlot: TOIMStoreSlot<TStore, TOIMComputedSlot<TValue, TKey>, unknown, Pick<OIMSlotCollectionService<TKey, TOIMComputedSlot<TValue, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>>, key: TKey): TValue;
 
-declare function useOIMSingleComputedValue<TValue>(computedService: OIMComputedService<void, TValue, TOIMSingleSlotStore<TOIMComputedSlot<TValue, void>>>, derive: ((computedSlot: TOIMComputedSlot<TValue, void>) => TValue) | undefined, createSources: ((key: void, storeSlot: TOIMStoreSlot | undefined) => Partial<TOIMComputedSources>) | undefined, dependencyList: DependencyList): TValue;
+declare function useOIMSingleComputedValue<TValue>(computedService: OIMSingleComputedService<TValue>, derive: ((computedSlot: TOIMComputedContentSlot<TValue>) => TValue) | undefined, createSources: ((computedSlot: TOIMComputedContentSlot<TValue>) => Partial<TOIMComputedSources>) | undefined, dependencyList: DependencyList): TValue;
 
-declare function useOIMComputedCollection<TKey, TValue, TStore>(computedService: OIMComputedService<TKey, TValue, TStore>, derive: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined, createSources: ((key: TKey, storeSlot: TOIMStoreSlot | undefined) => Partial<TOIMComputedSources>) | undefined, dependencyList: DependencyList): TOIMComputedStoreSlot<TStore, TValue, TKey>;
+declare function useOIMComputedCollection<TKey extends NonNullable<unknown>, TValue, TStore>(computedService: OIMComputedService<TKey, TValue, TStore>, derive: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => TValue) | undefined, createSources: ((computedSlot: TOIMComputedSlot<TValue, TKey>) => Partial<TOIMComputedSources>) | undefined, dependencyList: DependencyList): TOIMComputedStoreSlot<TStore, TValue, TOIMComputedSlot<TValue, TKey>, OIMComputedService<TKey, TValue, TStore>['computedCollectionService']>;
 
 export { OIMDBContext, OIMDBProvider, type TOIMBinding, useOIMBucketSlots, useOIMBucketSlotsByKey, useOIMComputedCollection, useOIMComputedValue, useOIMComputedValueByKey, useOIMDB, useOIMEntity, useOIMField, useOIMSingleBucketSlots, useOIMSingleComputedValue, useOIMSingleEntity, useOIMSlotsByKeys, useOIMValue };

package/dist/index.js

@@ -31,12 +31,12 @@ var OIMSnapshotVersion = class {
     this.version = 0;
     this.getVersion = () => this.version;
   }
-  subscribeEffect(channelMap, sourceSlots, sourceComputeds, onStoreChange) {
+  subscribeEffect(channelMap, onStoreChange, sourceSlots, sourceComputeds) {
     this.version++;
-    return OIMEffectService.INSTANCE.subscribeEffect(channelMap, sourceSlots, sourceComputeds, () => {
+    return OIMEffectService.INSTANCE.subscribeEffect(channelMap, () => {
       this.version++;
       onStoreChange();
-    });
+    }, sourceSlots, sourceComputeds);
   }
 };
 
@@ -56,9 +56,9 @@ function useOIMValue(binding) {
       snapshotVersion,
       subscribe: (onStoreChange) => snapshotVersion.subscribeEffect(
         db,
+        onStoreChange,
         binding.sourceSlots ?? OIM_FROZEN_EMPTY_SLOTS,
-        sourceComputeds,
-        onStoreChange
+        sourceComputeds
       )
     };
   }, [db, binding, sourceComputeds]);
@@ -83,17 +83,28 @@ 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;
+  if (slot.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.`
   );
 }
 
+// src/oimSubscribeHeldSlot.ts
+function oimSubscribeHeldSlot(channelMap, hookName, snapshotVersion, holdingSlot, sourcesOfSlot, onStoreChange) {
+  try {
+    oimAssertOneChannel(channelMap, holdingSlot, hookName);
+    const [sourceSlots, sourceComputeds] = sourcesOfSlot(holdingSlot);
+    return snapshotVersion.subscribeEffect(channelMap, onStoreChange, sourceSlots, sourceComputeds);
+  } finally {
+    holdingSlot.owner.unholdSlot(holdingSlot);
+  }
+}
+
 // src/useOIMSlotByKey.ts
 var sourcesOfRootSlot = (rootSlot) => [[rootSlot], OIM_FROZEN_EMPTY_SLOTS2];
-function useOIMSlotByKey(hookName, slotCollectionService, storeSlot, key, sourcesOfSlot = sourcesOfRootSlot) {
+function useOIMSlotByKey(hookName, storeSlot, key, sourcesOfSlot = sourcesOfRootSlot) {
   const db = useOIMDB();
+  const slotCollectionService = storeSlot.slotService;
   const lastSeenKeyRef = useRef(key);
   const settledKeyRef = useRef(key);
   if (key !== lastSeenKeyRef.current) {
@@ -110,18 +121,12 @@ function useOIMSlotByKey(hookName, slotCollectionService, storeSlot, key, source
       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);
-        }
+        const effectDisposer = oimSubscribeHeldSlot(db, hookName, snapshotVersion, holdingSlot, sourcesOfSlot, onStoreChange);
+        subscribedSlot = holdingSlot;
+        return () => {
+          subscribedSlot = void 0;
+          effectDisposer();
+        };
       },
       getSlot: () => subscribedSlot ?? slotCollectionService.getSlotByKey(storeSlot, settledKey)
     };
@@ -131,14 +136,17 @@ function useOIMSlotByKey(hookName, slotCollectionService, storeSlot, key, source
 }
 
 // src/useOIMEntity.ts
-function useOIMEntity(entityCollectionService, entityStoreSlot, key) {
-  return useOIMSlotByKey("useOIMEntity", entityCollectionService, entityStoreSlot, key).entity;
+function useOIMEntity(entityStoreSlot, key) {
+  return useOIMSlotByKey("useOIMEntity", entityStoreSlot, key).entity;
 }
 
 // src/useOIMSingleSlot.ts
 import { useMemo as useMemo4 } from "react";
-function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot) {
+import { OIM_FROZEN_EMPTY_SLOTS as OIM_FROZEN_EMPTY_SLOTS3 } from "@oimdb/core";
+var sourcesOfRootSlot2 = (rootSlot) => [[rootSlot], OIM_FROZEN_EMPTY_SLOTS3];
+function useOIMSingleSlot(hookName, singleSlotStoreSlot, sourcesOfSlot = sourcesOfRootSlot2) {
   const db = useOIMDB();
+  const singleSlotService = singleSlotStoreSlot.slotService;
   const store = useMemo4(() => {
     const snapshotVersion = new OIMSnapshotVersion();
     let subscribedSlot = void 0;
@@ -146,34 +154,29 @@ function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot) {
       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);
-        }
+        const effectDisposer = oimSubscribeHeldSlot(db, hookName, snapshotVersion, holdingSlot, sourcesOfSlot, onStoreChange);
+        subscribedSlot = holdingSlot;
+        return () => {
+          subscribedSlot = void 0;
+          effectDisposer();
+        };
       },
       getSlot: () => subscribedSlot ?? singleSlotService.getSingleSlot(singleSlotStoreSlot)
     };
-  }, [hookName, db, singleSlotService, singleSlotStoreSlot]);
+  }, [hookName, db, singleSlotService, singleSlotStoreSlot, sourcesOfSlot]);
   useOIMSnapshotVersion(store.snapshotVersion, store.subscribe);
   return store.getSlot();
 }
 
 // src/useOIMSingleEntity.ts
-function useOIMSingleEntity(singleSlotService, singleSlotStoreSlot) {
-  return useOIMSingleSlot("useOIMSingleEntity", singleSlotService, singleSlotStoreSlot).entity;
+function useOIMSingleEntity(singleSlotStoreSlot) {
+  return useOIMSingleSlot("useOIMSingleEntity", singleSlotStoreSlot).entity;
 }
 
 // src/useOIMSingleBucketSlots.ts
-function useOIMSingleBucketSlots(singleSlotService, singleSlotStoreSlot) {
-  const bucketSlot = useOIMSingleSlot("useOIMSingleBucketSlots", singleSlotService, singleSlotStoreSlot);
-  return Array.from(singleSlotService.slotContentService.getBucketMemberSlots(bucketSlot));
+function useOIMSingleBucketSlots(singleSlotStoreSlot) {
+  const bucketSlot = useOIMSingleSlot("useOIMSingleBucketSlots", singleSlotStoreSlot);
+  return Array.from(singleSlotStoreSlot.slotService.slotContentService.getBucketMemberSlots(bucketSlot));
 }
 
 // src/useOIMField.ts
@@ -213,9 +216,8 @@ function useOIMField(entityCollectionService, slot, name) {
       snapshotVersion,
       subscribe: (onStoreChange) => holdWhileSubscribed(holds, () => snapshotVersion.subscribeEffect(
         db,
-        [entityCollectionService.getColumn(slot, name)],
-        [],
-        onStoreChange
+        onStoreChange,
+        [entityCollectionService.columnSlotService.getColumn(slot, name)]
       ))
     };
   }, [db, entityCollectionService, slot, name]);
@@ -240,15 +242,15 @@ function useOIMBucketSlots(bucketCollectionService, bucketSlot) {
 }
 
 // src/useOIMBucketSlotsByKey.ts
-function useOIMBucketSlotsByKey(bucketCollectionService, bucketStoreSlot, key) {
-  const bucketSlot = useOIMSlotByKey("useOIMBucketSlotsByKey", bucketCollectionService, bucketStoreSlot, key);
-  return Array.from(bucketCollectionService.slotContentService.getBucketMemberSlots(bucketSlot));
+function useOIMBucketSlotsByKey(bucketStoreSlot, key) {
+  const bucketSlot = useOIMSlotByKey("useOIMBucketSlotsByKey", bucketStoreSlot, key);
+  return Array.from(bucketStoreSlot.slotService.slotContentService.getBucketMemberSlots(bucketSlot));
 }
 
 // src/useOIMSlotsByKeys.ts
 import { useEffect, useRef as useRef2, useState } from "react";
 import { oimSameKeySequence } from "@oimdb/core";
-function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
+function useOIMSlotsByKeys(storeSlot, keys) {
   const settledKeys = useRef2(keys);
   const previousKeys = settledKeys.current;
   if (!oimSameKeySequence(previousKeys, keys)) settledKeys.current = keys;
@@ -256,16 +258,14 @@ function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
   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) {
+  if (resolvedSlots.current === void 0 || resolvedKeys.current !== keysToHold || resolvedStoreSlot.current !== storeSlot) {
     const slots2 = [];
     for (let i = 0; i < keysToHold.length; i++) {
-      slots2.push(slotCollectionService.getSlotByKey(storeSlot, keysToHold[i]));
+      slots2.push(storeSlot.slotService.getSlotByKey(storeSlot, keysToHold[i]));
     }
     resolvedSlots.current = slots2;
     resolvedKeys.current = keysToHold;
-    resolvedSlotCollectionService.current = slotCollectionService;
     resolvedStoreSlot.current = storeSlot;
   }
   const slots = resolvedSlots.current;
@@ -274,7 +274,7 @@ function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
     const heldSlots = [];
     let someKeyNamesAnotherIdentityNow = false;
     for (let i = 0; i < keysToHold.length; i++) {
-      const slot = slotCollectionService.holdSlotByKey(storeSlot, keysToHold[i]);
+      const slot = storeSlot.slotService.holdSlotByKey(storeSlot, keysToHold[i]);
       heldSlots.push(slot);
       if (slot !== renderedSlots?.[i]) someKeyNamesAnotherIdentityNow = true;
     }
@@ -288,26 +288,22 @@ function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
         heldSlot.owner.unholdSlot(heldSlot);
       }
     };
-  }, [slotCollectionService, storeSlot, keysToHold]);
+  }, [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
-  );
+import { OIM_FROZEN_EMPTY_SLOTS as OIM_FROZEN_EMPTY_SLOTS4 } from "@oimdb/core";
+var sourcesOfComputedSlot = (computedSlot) => [OIM_FROZEN_EMPTY_SLOTS4, [computedSlot]];
+function useOIMComputedValueByKey(computedStoreSlot, key) {
+  const computedSlot = useOIMSlotByKey("useOIMComputedValueByKey", computedStoreSlot, key, sourcesOfComputedSlot);
   return computedSlot.computedValueService.getValueForSlot(computedSlot);
 }
 
 // src/useOIMSingleComputedValue.ts
 import { useMemo as useMemo7 } from "react";
+import { OIM_FROZEN_EMPTY_SLOTS as OIM_FROZEN_EMPTY_SLOTS5 } from "@oimdb/core";
+var sourcesOfComputedSlot2 = (computedSlot) => [OIM_FROZEN_EMPTY_SLOTS5, [computedSlot]];
 function useOIMSingleComputedValue(computedService, derive, createSources, dependencyList) {
   const db = useOIMDB();
   const computedStoreSlot = useMemo7(
@@ -315,11 +311,8 @@ function useOIMSingleComputedValue(computedService, derive, createSources, depen
     // 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
-  );
+  const computedSlot = useOIMSingleSlot("useOIMSingleComputedValue", computedStoreSlot, sourcesOfComputedSlot2);
+  return computedSlot.computedValueService.getValueForSlot(computedSlot);
 }
 
 // src/useOIMComputedCollection.ts