@oimdb/react 3.0.0 → 3.1.0

package/README.md

@@ -11,7 +11,7 @@ npm install @oimdb/react @oimdb/core
 
 ## Why one binding
 
-Subscribing in this engine is one call: `OIMEffectService.INSTANCE.subscribeEffect(db, sourceSlots, sourceComputeds, body)`.
+Subscribing in this engine is one call: `OIMEffectService.INSTANCE.subscribeEffect(db, body, sourceSlots?, sourceComputeds?, sourceTrackingComputeds?)`.
 It carries no value; what changed is read off the slots afterwards. So a component needs
 exactly three things: the roots a write can reach, the derivations to ask before reading,
 and the derive function. Together they make up `TOIMBinding`, and `useOIMValue` is the hook that applies it through
@@ -35,18 +35,18 @@ instance, a store slot, and every store door of the service takes that store slo
 Whatever a read mints is swept at the end of the frame unless something took a real reference to it.
 
 ```ts setup
-import { OIMDB, createOIMBucketService, createOIMEntityService, type TOIMEntitySlot } from '@oimdb/core';
+import { OIMDB, type TOIMEntitySlot, createOIMSlotCollectionService, createOIMSlotContentEntityService, OIMSlotContentPositionalArrayBucketService, OIMBucketCommands, createOIMSingleComputedService, OIMSingleSlotStoreService, createOIMSingleSlotService, createOIMComputedService, oimSameValueZeroGuard, type TOIMComputedSlot } from '@oimdb/core';
 
 type TCard = { id: string; deckId: string; title: string; rank: number };
 
 export const db = new OIMDB();
 
-export const cardService = createOIMEntityService<TCard>(db, { keyOf: (card) => card.id });
+export const cardService = createOIMSlotCollectionService({ slotContentService: createOIMSlotContentEntityService<TCard>() });
 export const cards = cardService.createStoreSlot(db);
 
 // A bucket keeps the order the caller writes; a sorted list is
-// `createOIMComputedServiceSorted` over an index.
-export const byDeckService = createOIMBucketService<TOIMEntitySlot<TCard>>(db);
+// `createOIMSortedComputedService` over an index.
+export const byDeckService = createOIMSlotCollectionService({ slotContentService: new OIMSlotContentPositionalArrayBucketService<TOIMEntitySlot<TCard>>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
 export const byDeck = byDeckService.createStoreSlot(db);
 
 // A BUCKET'S SLOTS ARE YOURS. A write moves the card's value and files nothing, so the
@@ -54,9 +54,9 @@ export const byDeck = byDeckService.createStoreSlot(db);
 // bucket by key: it mints one if there is none and hands back the bucket itself,
 // counted. `owner.unholdSlot` gives that count back, once the bucket's own slots keep it.
 export function setDeck(deckId: string, cardsInDeck: readonly TCard[]): void {
-    cardService.slotContentService.upsertEntities(cards, cardsInDeck);
+    cardService.writeInBatch(cards, () => (cardsInDeck).map(entity => cardService.writeSlotContentByKey(cards, entity.id, entity)));
     const bucket = byDeckService.holdSlotByKey(byDeck, deckId);
-    byDeckService.slotContentService.writeBucketMemberSlots(
+    byDeckService.slotContentService.writeSlotContent(
         bucket, cardsInDeck.map((card) => cardService.getSlotByKey(cards, card.id)),
     );
     bucket.owner.unholdSlot(bucket);
@@ -131,7 +131,7 @@ The parameter is typed as a `Pick` of `OIMSlotCollectionService` with only the m
   entity slots. It resolves the bucket on commit, holds it for as long as the component is mounted, and gives the
   hold back on unmount or when the key changes. It copies the members on every render: the bucket it reads during a
   render may be held by nothing yet, and an unheld bucket's stamp does not move. **The key may be built inline**,
-  including the array that keys an `OIMSlotStoreServiceTreeDriven`; the hook settles it by asking the store which
+  including the array that keys an `OIMSlotTreeStoreService`; the hook settles it by asking the store which
   bucket each key names.
 - **`useOIMSlotsByKeys(slotCollectionService, storeSlot, keys)`**: several identities of one store slot,
   resolved by key and held for as long as the component is mounted. It returns the slots and takes no subscription,
@@ -146,26 +146,21 @@ The parameter is typed as a `Pick` of `OIMSlotCollectionService` with only the m
   only calls `computedService.createComputedStoreSlot(db, derive, createSources)` in a `useMemo` keyed on `deps`, and
   returns that store slot. `derive` and `createSources` may be `undefined` when the service already has them.
   Read it by key with `useOIMComputedValueByKey(computedService.computedCollectionService, computedStoreSlot, key)`.
-- **`useOIMSingleComputedValue(computedService, derive, createSources, deps)`**: a single computed the component
-  owns, read under the key `undefined`. The service is a void-keyed `createOIMComputedService` with
-  `computedSlotStoreService: OIMSlotStoreServiceSingleSlotDriven.INSTANCE`, built once at module scope. Per mount
-  the hook builds a store slot through `useOIMComputedCollection` and reads it through `useOIMComputedValueByKey`,
-  so a flush between render and subscribe, which releases the slot the render minted, is safe.
+- **`useOIMSingleComputedValue(computedService, derive, createSources, deps)`**: a single computed the
+  component owns. The service is `createOIMSingleComputedService<V>()`, built once at module scope; `derive` and
+  `createSources` receive the computed slot. Per mount the hook builds one store slot and reads its slot through
+  `computedSingleSlotService`, so a flush between render and subscribe, which releases the slot the render minted,
+  is safe.
 - **`useOIMSingleEntity(singleSlotService, singleSlotStoreSlot)`** and
   **`useOIMSingleBucketSlots(singleSlotService, singleSlotStoreSlot)`**: the single entity and the single bucket.
   See [Singles](#singles).
 - **`useOIMDB()`**: the `OIMDB` from `OIMDBContext`. It throws if used outside `<OIMDBProvider>`.
 
 ```tsx
-import { OIMSlotStoreServiceSingleSlotDriven, createOIMComputedService } from '@oimdb/core';
-import type { TOIMComputedSlot, TOIMSingleSlotStore } from '@oimdb/core';
 import { useOIMSingleComputedValue } from '@oimdb/react';
 
 // Module scope: one service per kind of computed, shared by every component.
-const totalRankService = createOIMComputedService<void, number, TOIMSingleSlotStore<TOIMComputedSlot<number, void>>>({
-    computedSlotStoreService:
-        OIMSlotStoreServiceSingleSlotDriven.INSTANCE as OIMSlotStoreServiceSingleSlotDriven<TOIMComputedSlot<number, void>>,
-});
+const totalRankService = createOIMSingleComputedService<number>();
 
 function TotalRank({ ids }: { ids: readonly string[] }) {
     // Per mount: one store slot with its own derive and sources.
@@ -181,23 +176,22 @@ function TotalRank({ ids }: { ids: readonly string[] }) {
 
 ## Singles
 
-A single is a store slot that holds ONE identity and has no key: `createOIMSingleEntityService(db)` and
-`createOIMSingleBucketService(db)` hand back an `OIMSingleSlotService`, read through `getSingleSlot(storeSlot)` and
+A single is a store slot that holds ONE identity and has no key: `createOIMSingleSlotService()` and
+`createOIMSingleSlotService()` hand back an `OIMSingleSlotService`, read through `getSingleSlot(storeSlot)` and
 `holdSingleSlot(storeSlot)`. The two single hooks take that service (typed as a `Pick` of `OIMSingleSlotService`)
 and its store slot, and have the by-key hooks' mechanics without the key: the render reads `getSingleSlot`, whose
 mint the next `flush()` takes back if no commit follows; the commit resolves with `holdSingleSlot`, subscribes over
 that slot and gives the resolve-hold straight back, so a single released while nothing watched it is minted afresh.
 
 ```tsx
-import { createOIMSingleBucketService, createOIMSingleEntityService } from '@oimdb/core';
 import { useOIMSingleBucketSlots, useOIMSingleEntity } from '@oimdb/react';
 
 type TSettings = { theme: string };
 
-const settingsService = createOIMSingleEntityService<TSettings>(db);
+const settingsService = createOIMSingleSlotService({ slotContentService: createOIMSlotContentEntityService<TSettings>() });
 const settings = settingsService.createStoreSlot(db);
 
-const pickedService = createOIMSingleBucketService<TOIMEntitySlot<TCard>>(db);
+const pickedService = createOIMSingleSlotService({ slotContentService: new OIMSlotContentPositionalArrayBucketService<TOIMEntitySlot<TCard>>({ bucketCommands: new OIMBucketCommands({ maxCommandsPerSlot: undefined }) }) });
 const picked = pickedService.createStoreSlot(db);
 
 function Toolbar() {
@@ -212,7 +206,7 @@ A single computed is `useOIMSingleComputedValue`.
 
 ## Binding a derivation
 
-`createOIMComputedService` and `createOIMComputedServiceBucketMemo` both hand back a service of computed slots,
+`createOIMComputedService` and `createOIMBucketMemoComputedService` both hand back a service of computed slots,
 whose store slot holds them. You can either hold the key where the lifetime is (a module, your own store) and bind
 it with `useOIMValue`, or let the component own the lifetime with `useOIMSlotsByKeys`.
 
@@ -222,7 +216,7 @@ asked and never woken. Only a computed slot's `computedValueService.getValueForS
 
 **No wake is owed for what happened before the subscription.** An effect is stamped with the channel clock at
 birth (`ranAtRevision` / `ranAtEpoch`), so a frame runs the body only when a source moved *after* the subscription.
-Every hook here subscribes with `subscribeEffect`; `OIMEffectService.INSTANCE.createEffectImmediate` is the door
+Every hook here subscribes with `subscribeEffect`; `OIMEffectService.INSTANCE.createAndRunEffect` is the door
 that delivers a value at once.
 
 ## Holds per component
@@ -232,11 +226,10 @@ resolves each key through `holdSlotByKey(storeSlot, key)` and keeps that hold, a
 moves) it gives back exactly the holds that commit took.
 
 ```tsx
-import { createOIMComputedService, oimSameValueZeroGuard } from '@oimdb/core';
 import { useOIMSlotsByKeys } from '@oimdb/react';
 
 const rankService = createOIMComputedService<string, number>({
-    createSources: (id) => ({ sourceSlots: [cardService.getSlotByKey(cards, id)] }),
+    createSources: ({ key: id }) => ({ sourceSlots: [cardService.getSlotByKey(cards, id)] }),
     derive: (computedSlot) => cardService.getSlotByKey(cards, computedSlot.key).entity?.rank ?? -1,
     sameValueGuard: oimSameValueZeroGuard,
 });
@@ -298,7 +291,7 @@ identity are one key.
 
 ## Things worth knowing
 
-- **The snapshot `useOIMValue` compares is a local counter, not the value.** `createOIMEntityWriterInPlace` keeps
+- **The snapshot `useOIMValue` compares is a local counter, not the value.** `createOIMInPlaceEntityWriter` keeps
   an entity's object reference stable, a bucket hands its slots back as the same live container, and a column
   subscription fires only for its own column; a value-comparing binding would fire on none of the three. The counter
   is bumped ON SUBSCRIBING too, so a write that lands between the render and the subscription is still shown. The
@@ -310,9 +303,9 @@ identity are one key.
   is one per kind of computed; a component that owns a computed gets only a store slot from
   `useOIMComputedCollection` / `useOIMSingleComputedValue`.
 - **Nothing re-files an entity when it is written into a bucket you maintain.** Write the buckets in the same code
-  that writes the entity, or use an index service (`createOIMIndexService`), which files entities by the key it
+  that writes the entity, or use an index service (`createOIMSlotCollectionIndexService`), which files entities by the key it
   derives from each one.
-- **A bucket never sorts.** A list sorted by a column is `createOIMComputedServiceSorted({ indexService, sortColumns })`
+- **A bucket never sorts.** A list sorted by a column is `createOIMSortedComputedService({ indexService, sortColumns })`
   over an index service, with `createSortedStoreSlot(indexStoreSlot)`.
 
 ## Reference

package/dist/index.cjs

@@ -71,12 +71,12 @@ var OIMSnapshotVersion = class {
     this.version = 0;
     this.getVersion = () => this.version;
   }
-  subscribeEffect(channelMap, sourceSlots, sourceComputeds, onStoreChange) {
+  subscribeEffect(channelMap, onStoreChange, sourceSlots, sourceComputeds) {
     this.version++;
-    return import_core.OIMEffectService.INSTANCE.subscribeEffect(channelMap, sourceSlots, sourceComputeds, () => {
+    return import_core.OIMEffectService.INSTANCE.subscribeEffect(channelMap, () => {
       this.version++;
       onStoreChange();
-    });
+    }, sourceSlots, sourceComputeds);
   }
 };
 
@@ -96,9 +96,9 @@ function useOIMValue(binding) {
       snapshotVersion,
       subscribe: (onStoreChange) => snapshotVersion.subscribeEffect(
         db,
+        onStoreChange,
         binding.sourceSlots ?? import_core2.OIM_FROZEN_EMPTY_SLOTS,
-        sourceComputeds,
-        onStoreChange
+        sourceComputeds
       )
     };
   }, [db, binding, sourceComputeds]);
@@ -123,13 +123,23 @@ 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;
+  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], import_core3.OIM_FROZEN_EMPTY_SLOTS];
 function useOIMSlotByKey(hookName, slotCollectionService, storeSlot, key, sourcesOfSlot = sourcesOfRootSlot) {
@@ -150,18 +160,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)
     };
@@ -177,7 +181,9 @@ function useOIMEntity(entityCollectionService, entityStoreSlot, key) {
 
 // src/useOIMSingleSlot.ts
 var import_react7 = require("react");
-function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot) {
+var import_core4 = require("@oimdb/core");
+var sourcesOfRootSlot2 = (rootSlot) => [[rootSlot], import_core4.OIM_FROZEN_EMPTY_SLOTS];
+function useOIMSingleSlot(hookName, singleSlotService, singleSlotStoreSlot, sourcesOfSlot = sourcesOfRootSlot2) {
   const db = useOIMDB();
   const store = (0, import_react7.useMemo)(() => {
     const snapshotVersion = new OIMSnapshotVersion();
@@ -186,21 +192,16 @@ 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();
 }
@@ -220,11 +221,11 @@ function useOIMSingleBucketSlots(singleSlotService, singleSlotStoreSlot) {
 var import_react8 = require("react");
 
 // src/holdWhileSubscribed.ts
-var import_core4 = require("@oimdb/core");
+var import_core5 = require("@oimdb/core");
 function holdWhileSubscribed(slots, subscribe) {
-  (0, import_core4.oimHoldSlots)(slots);
+  (0, import_core5.oimHoldSlots)(slots);
   const giveEveryHoldBack = () => {
-    (0, import_core4.oimUnholdSlotsIfAlive)(slots);
+    (0, import_core5.oimUnholdSlotsIfAlive)(slots);
   };
   let disposer;
   try {
@@ -253,9 +254,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]);
@@ -287,11 +287,11 @@ function useOIMBucketSlotsByKey(bucketCollectionService, bucketStoreSlot, key) {
 
 // src/useOIMSlotsByKeys.ts
 var import_react10 = require("react");
-var import_core5 = require("@oimdb/core");
+var import_core6 = 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;
+  if (!(0, import_core6.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);
@@ -333,8 +333,8 @@ function useOIMSlotsByKeys(slotCollectionService, storeSlot, keys) {
 }
 
 // src/useOIMComputedValueByKey.ts
-var import_core6 = require("@oimdb/core");
-var sourcesOfComputedSlot = (computedSlot) => [import_core6.OIM_FROZEN_EMPTY_SLOTS, [computedSlot]];
+var import_core7 = require("@oimdb/core");
+var sourcesOfComputedSlot = (computedSlot) => [import_core7.OIM_FROZEN_EMPTY_SLOTS, [computedSlot]];
 function useOIMComputedValueByKey(computedCollectionService, computedStoreSlot, key) {
   const computedSlot = useOIMSlotByKey(
     "useOIMComputedValueByKey",
@@ -348,6 +348,8 @@ function useOIMComputedValueByKey(computedCollectionService, computedStoreSlot,
 
 // src/useOIMSingleComputedValue.ts
 var import_react11 = require("react");
+var import_core8 = require("@oimdb/core");
+var sourcesOfComputedSlot2 = (computedSlot) => [import_core8.OIM_FROZEN_EMPTY_SLOTS, [computedSlot]];
 function useOIMSingleComputedValue(computedService, derive, createSources, dependencyList) {
   const db = useOIMDB();
   const computedStoreSlot = (0, import_react11.useMemo)(
@@ -355,11 +357,13 @@ 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,
+  const computedSlot = useOIMSingleSlot(
+    "useOIMSingleComputedValue",
+    computedService.computedSingleSlotService,
     computedStoreSlot,
-    void 0
+    sourcesOfComputedSlot2
   );
+  return computedSlot.computedValueService.getValueForSlot(computedSlot);
 }
 
 // src/useOIMComputedCollection.ts

package/dist/index.d.cts

@@ -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, OIMSlotCollectionService, TOIMEntitySlot, TOIMStoreSlot, OIMSingleSlotService, TOIMEntityContentSlot, TOIMSingleSlotStore, 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>(entityCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, entityStoreSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, 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>(singleSlotService: Pick<OIMSingleSlotService<TOIMEntityContentSlot<TEntity>, unknown>, 'getSingleSlot' | 'holdSingleSlot'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMEntityContentSlot<TEntity>>, TOIMEntityContentSlot<TEntity>>): 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>(singleSlotService: Pick<OIMSingleSlotService<TOIMBucketContentSlot<TSlots>, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSingleSlot' | 'holdSingleSlot' | 'slotContentService'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMBucketContentSlot<TSlots>>, TOIMBucketContentSlot<TSlots>>): 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>(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 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>(slotCollectionService: Pick<OIMSlotCollectionService<TKey, TSlot, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, storeSlot: TOIMStoreSlot<TStore, TSlot>, 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>(computedCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMComputedSlot<TValue, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, computedStoreSlot: TOIMStoreSlot<TStore, TOIMComputedSlot<TValue, TKey>>, 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>>;
 
 export { OIMDBContext, OIMDBProvider, type TOIMBinding, useOIMBucketSlots, useOIMBucketSlotsByKey, useOIMComputedCollection, useOIMComputedValue, useOIMComputedValueByKey, useOIMDB, useOIMEntity, useOIMField, useOIMSingleBucketSlots, useOIMSingleComputedValue, useOIMSingleEntity, useOIMSlotsByKeys, useOIMValue };

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, OIMSlotCollectionService, TOIMEntitySlot, TOIMStoreSlot, OIMSingleSlotService, TOIMEntityContentSlot, TOIMSingleSlotStore, 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>(entityCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMEntitySlot<TEntity, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, entityStoreSlot: TOIMStoreSlot<TStore, TOIMEntitySlot<TEntity, TKey>>, 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>(singleSlotService: Pick<OIMSingleSlotService<TOIMEntityContentSlot<TEntity>, unknown>, 'getSingleSlot' | 'holdSingleSlot'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMEntityContentSlot<TEntity>>, TOIMEntityContentSlot<TEntity>>): 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>(singleSlotService: Pick<OIMSingleSlotService<TOIMBucketContentSlot<TSlots>, Pick<OIMSlotContentBucketService<TOIMEntitySlot<TEntity>, TSlots>, 'getBucketMemberSlots'>>, 'getSingleSlot' | 'holdSingleSlot' | 'slotContentService'>, singleSlotStoreSlot: TOIMStoreSlot<TOIMSingleSlotStore<TOIMBucketContentSlot<TSlots>>, TOIMBucketContentSlot<TSlots>>): 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>(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 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>(slotCollectionService: Pick<OIMSlotCollectionService<TKey, TSlot, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, storeSlot: TOIMStoreSlot<TStore, TSlot>, 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>(computedCollectionService: Pick<OIMSlotCollectionService<TKey, TOIMComputedSlot<TValue, TKey>, TStore, unknown>, 'getSlotByKey' | 'holdSlotByKey'>, computedStoreSlot: TOIMStoreSlot<TStore, TOIMComputedSlot<TValue, TKey>>, 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>>;
 
 export { OIMDBContext, OIMDBProvider, type TOIMBinding, useOIMBucketSlots, useOIMBucketSlotsByKey, useOIMComputedCollection, useOIMComputedValue, useOIMComputedValueByKey, useOIMDB, useOIMEntity, useOIMField, useOIMSingleBucketSlots, useOIMSingleComputedValue, useOIMSingleEntity, useOIMSlotsByKeys, useOIMValue };