@danxbot/ui 7.5.0 → 7.6.0

package/dist/types/lib/reads/optimistic.d.ts

@@ -7,6 +7,19 @@ export type OptimisticWriteSpec<T> = {
     readonly id: string | number;
     /** Only the fields that change. A present `null` clears; an `undefined` value is ignored. */
     readonly patch: Partial<T>;
+    readonly at?: undefined;
+} | {
+    readonly kind: "update";
+    readonly type: RecordTypeToken<T>;
+    readonly id: string | number;
+    /**
+     * A field holding a keyed map (`data_points`, `attributes`): `patch` then names KEYS OF
+     * THAT MAP, merged over whatever it holds. Use it whenever a write changes one entry of a
+     * map — patching the whole field instead would pin every other entry at its value as of
+     * the click, and undoing one of two concurrent writes would undo both.
+     */
+    readonly at: Extract<keyof T, string>;
+    readonly patch: Readonly<Record<string, unknown>>;
 } | {
     readonly kind: "create";
     readonly type: RecordTypeToken<T>;
@@ -38,6 +51,12 @@ export interface OptimisticWriteOptions<A = unknown> {
      * record itself. Default: the result, if it carries `__type` and `id`.
      */
     readonly answer?: (result: A) => unknown;
+    /**
+     * The request stores its own answer — an API layer that writes every response into the store,
+     * or a caller that normalizes the answer before storing it. Commit then only retires the belief:
+     * nothing is written, so the stored answer is exactly what shows.
+     */
+    readonly answerStored?: boolean;
 }
 /** An applied write whose request the caller runs itself — `beginOptimisticWrite`'s handle. */
 export interface OptimisticHandle {
@@ -63,6 +82,6 @@ export declare function optimisticWrite<T, A>(spec: OptimisticWriteSpec<T>, requ
  * The same write, for a caller that owns its request lifecycle — apply now, and call `commit`
  * or `rollback` on the handle when the request settles.
  */
-export declare function beginOptimisticWrite<T>(spec: OptimisticWriteSpec<T>, options?: Pick<OptimisticWriteOptions, "tag" | "tenant">): OptimisticHandle;
+export declare function beginOptimisticWrite<T>(spec: OptimisticWriteSpec<T>, options?: Pick<OptimisticWriteOptions, "tag" | "tenant" | "answerStored">): OptimisticHandle;
 /** Test seam. Nothing in the library calls this. */
 export declare function resetOptimisticWrites(): void;

package/dist/types/lib/records/store.d.ts

@@ -57,6 +57,14 @@ export interface OptimisticLayer {
     readonly id: number;
     /** Data fields, stored as given — never normalized, so a patch cannot mint records. */
     fields: Record<string, unknown>;
+    /**
+     * When set, `fields` are KEYS OF THE MAP held in this one field (a record's `data_points`,
+     * say), merged over whatever that map holds beneath — never a replacement of the whole field.
+     * Two beliefs about two different keys of one map then stay independent: undoing one leaves the
+     * other standing, and a read that rewrites the map underneath still shows through every key no
+     * belief is about.
+     */
+    readonly at: string | undefined;
     /** An ISO time when this layer is a delete. */
     readonly tombstone: string | undefined;
     /** True when this layer IS the record — an optimistic create with no server row yet. */
@@ -73,6 +81,7 @@ export interface OptimisticLayer {
  */
 export declare function pushOptimisticLayer(type: string, id: string | number, layer: {
     fields?: Record<string, unknown>;
+    at?: string;
     tombstone?: string;
     created?: boolean;
 }): number;
@@ -86,14 +95,23 @@ export declare function removeOptimisticLayer(key: string, layerId: number): voi
  * superseded, whether or not that older request has answered yet. A layer left with nothing to
  * say is dropped. Without this, a set whose answer is still out would keep overlaying a field
  * the server has already confirmed was cleared after it.
+ *
+ * `at` scopes the trim to beliefs about keys of that one map field — the same granularity the
+ * committing write had.
  */
-export declare function trimOptimisticLayers(key: string, beforeLayerId: number, fields: readonly string[]): void;
+export declare function trimOptimisticLayers(key: string, beforeLayerId: number, fields: readonly string[], at?: string): void;
 /**
  * Whether the BASE is tombstoned — what a list slot prunes on. An optimistic delete hides the
  * row from every read but must not cost the slot its key, or a rollback would bring the record
  * back with no list left holding it.
  */
 export declare function isBaseTombstoned(key: string): boolean;
+/**
+ * One field of the BASE, as stored (normalized: a nested record is a `{__ref}`). What a keyed
+ * belief is folded into when its write succeeds without an answer to replace it — writing it back
+ * through `write()` round-trips the refs untouched.
+ */
+export declare function readBaseField(key: string, field: string): unknown;
 /** Does `key` carry any optimistic layer right now? */
 export declare function hasOptimisticLayers(key: string): boolean;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danxbot/ui",
-  "version": "7.5.0",
+  "version": "7.6.0",
   "type": "module",
   "description": "Danxbot — a domain-agnostic React design system with motion as a first-class primitive.",
   "license": "MIT",