@weasel-js/prefs 1.9.4 → 1.10.0

package/dist/{store-CNFnA_3c.d.ts → open-BEY-aOGe.d.ts}

@@ -1,4 +1,81 @@
-import { Display, UnitEntry, InfinityText, UnitSystem, Unit } from '@weasel-js/quantity';
+import { StorageAdapter, SyncStorageAdapter } from '@weasel-js/storage';
+import { UnitEntry, UnitSystem, Unit, Display, InfinityText } from '@weasel-js/quantity';
+
+/** What a condition can compare a leaf's value against. `null` stands for
+ *  nothing held: a missing value as well as a stored `null`. */
+type PrefConditionValue = string | number | boolean | null;
+/**
+ * One leaf's value, tested. `path` is the full path the value is read and
+ * written at (`'windows.paging'`), a field of an `object` or `union` leaf
+ * included (`'stroke.width'`, `'fill.type'`). With `from: 'item'` the path is
+ * read from the entry the test's node is drawn in instead: the entry of the
+ * nearest list or map the node is the `item` of, or sits inside the item of.
+ * `{ from: 'item', path: 'mode' }` on a field of a list's item reads `mode`
+ * of the same entry, and an empty path is the entry itself. The value compared is the one
+ * the leaf's control shows, where an `encoding` stores another. With
+ * several operators it holds while all of them do, so
+ * `{ path: 'count', atLeast: 1, below: 10 }` is a range.
+ *
+ * With no operator it holds while the value is set, which by kind is:
+ * a `boolean` that is on; a `number` other than 0; a `string`, a `color`, a
+ * `field`, or an `enum`'s option that is not the empty string; a `paint`
+ * that is not `null`; a `list` with an entry; a `map` with a key; an
+ * `object` or a `union` holding a field. Nothing held is never set, and the
+ * value of an app-defined kind is set by whichever of those its shape is,
+ * else while it is truthy.
+ */
+interface PrefTest {
+    path: string;
+    /** Where `path` is read from: the entry the node is drawn in. Unset: the schema root. */
+    from?: 'item';
+    is?: PrefConditionValue;
+    isNot?: PrefConditionValue;
+    /** Holds while the value is any of these. */
+    in?: readonly PrefConditionValue[];
+    /** The ordering operators hold only for a number. */
+    above?: number;
+    below?: number;
+    atLeast?: number;
+    atMost?: number;
+}
+/** A condition a schema node holds in `showIf` or `enableIf`. An empty `all`
+ *  holds and an empty `any` does not. */
+type PrefCondition = PrefTest | {
+    all: readonly PrefCondition[];
+} | {
+    any: readonly PrefCondition[];
+} | {
+    not: PrefCondition;
+};
+/** Reads the value a test compares: at `path` from the schema root, or with `from`, from the entry being drawn. */
+type PrefConditionReader = (path: string, from?: 'item') => unknown;
+/** Whether `value` is a well-formed condition, all the way down. */
+declare function isPrefCondition(value: unknown): value is PrefCondition;
+/** Whether `condition` holds, given the value `read` finds at each path it names. */
+declare function prefConditionHolds(condition: PrefCondition, read: PrefConditionReader): boolean;
+/** Whether a node is drawn: its `showIf` holds, or it has none. A node
+ *  answers for itself only; one inside a group that is not shown is not
+ *  drawn either. */
+declare function prefIsShown(node: {
+    showIf?: PrefCondition;
+}, read: PrefConditionReader): boolean;
+/** Whether a node's controls take input: its `enableIf` holds, or it has
+ *  none. As {@link prefIsShown}, a node answers for itself only. */
+declare function prefIsEnabled(node: {
+    enableIf?: PrefCondition;
+}, read: PrefConditionReader): boolean;
+/** Every path `condition` reads from the schema root, or with `from`, from the entry, once each, in the order met. */
+declare function prefConditionPaths(condition: PrefCondition, from?: 'item'): string[];
+/** Whether any test of `condition` reads from the entry, so that it has no answer until an entry is drawn. */
+declare function prefConditionReadsItem(condition: PrefCondition): boolean;
+/**
+ * `condition` with every path it reads put through `move`, for following a
+ * key that was renamed or a leaf that moved. `move` is told where a path is
+ * read from, and what it hands back is read from there too. A condition none
+ * of whose paths change comes back as the object it was given, and so does
+ * each part of one.
+ */
+declare function mapPrefConditionPaths(condition: PrefCondition, move: (path: string, from?: 'item') => string): PrefCondition;
 
 /** What a {@link PrefAction}'s `run` is told. */
 interface PrefActionContext {
@@ -52,6 +129,12 @@ declare function prefAliasTarget(alias: PrefAlias, leafAt: (path: string) => Pre
     path: string;
     leaf: PrefLeaf;
 } | undefined;
+/**
+ * What an alias is called wherever one is drawn or named: its own name, else
+ * that of `target`, the leaf it shows, else `Alias` for one that shows
+ * nothing.
+ */
+declare function prefAliasName(alias: PrefAlias, target?: PrefLeaf): string;
 /** A leaf drawn through an alias: the target, under the alias's own name and description where it gives them. */
 declare function prefAliasedLeaf(alias: PrefAlias, target: PrefLeaf): PrefLeaf;
 
@@ -110,13 +193,66 @@ declare function prefVariantOf(leaf: PrefUnion, value: unknown): [key: string, v
 /** The value a union takes on switching to the variant at `key`: that variant's default, tagged. */
 declare function prefVariantDefault(leaf: PrefUnion, key: string): Record<string, unknown>;
 
-/** The value types a built-in pref leaf can hold. */
-type PrefKind = 'number' | 'boolean' | 'string' | 'enum' | 'color' | 'paint' | 'object' | 'list' | 'map' | 'union' | 'field' | 'action' | 'alias' | 'label' | 'separator';
+/** What both forms of a unit say about the text around the number. */
+interface PrefUnitText {
+    /** Shown after the input, e.g. `'°'`. */
+    suffix?: string;
+    /** Suffixes a person may type, each mapped to the scale that turns a
+     *  number in that unit into a display number: `{ mm: 0.1, cm: 1 }` for a
+     *  field showing centimeters. A unit that disagrees with the display unit
+     *  about zero carries an `offset` as well. */
+    accepts?: Readonly<Record<string, UnitEntry>>;
+}
 /**
- * Leaves that share one row in a compact property UI (weasel-ui
- * `SelectionPanel`, labkit's `ControlPanel`), declared on the first of them.
- * Purely presentational.
+ * A display unit as data, for a conversion that is linear: `stored = display * scale + offset`, the direction a
+ * `UnitEntry` runs toward its base, so `scale` is what one display unit is worth in stored units. Degrees shown
+ * over radians stored is `{ suffix: '°', scale: Math.PI / 180 }`, and `{ scale: 1 }` changes nothing. Being data,
+ * it is written to JSON, printed in a schema literal, and edited in `PrefSchemaEditor` like any other attribute.
+ */
+interface PrefLinearUnit extends PrefUnitText {
+    /** Stored units per display unit. Never 0. */
+    scale: number;
+    /** The stored value a display of 0 stands for. Absent is 0. */
+    offset?: number;
+    /** Decimal places the shown value is rounded to. Absent, the value shows unrounded and formats to two places.
+     *  What is typed is stored unrounded either way. */
+    precision?: number;
+}
+/** A display unit as code, for a conversion that is not linear. It cannot be written to JSON or edited as data. */
+interface PrefFunctionUnit extends PrefUnitText {
+    toDisplay: (stored: number) => number;
+    fromDisplay: (display: number) => number;
+    /** The stored value as display text, suffix included. */
+    format?: (stored: number) => string;
+}
+/** Display-unit conversion for number leaves whose stored value uses a
+ *  canonical unit the user shouldn't see (e.g. radians stored, degrees
+ *  shown). Read one through {@link resolvePrefUnit}, which answers for both forms. */
+type PrefNumberUnit = PrefLinearUnit | PrefFunctionUnit;
+/** A unit of either form as the functions that convert and format with it. */
+interface ResolvedPrefUnit extends PrefFunctionUnit {
+    format: (stored: number) => string;
+}
+/** Whether `unit` is the data form, and so can be written out and edited. */
+declare function isPrefLinearUnit(unit: PrefNumberUnit): unit is PrefLinearUnit;
+/** How to convert and format with `unit`, whichever form it was written in. */
+declare function resolvePrefUnit(unit: PrefNumberUnit): ResolvedPrefUnit;
+/**
+ * A display unit built from a {@link UnitSystem}: values are stored in the
+ * system's base and shown in `display`, rounded to `precision` places when
+ * given, and every unit in the system is accepted as typed text. `suffix`
+ * defaults to the unit's name and is accepted too. Every unit of a system is
+ * linear, so what comes back is data.
  */
+declare function prefUnit(system: UnitSystem, display: Unit, opts?: {
+    precision?: number;
+    suffix?: string;
+}): PrefLinearUnit;
+
+/** The value types a built-in pref leaf can hold. */
+type PrefKind = 'number' | 'boolean' | 'string' | 'enum' | 'color' | 'paint' | 'object' | 'list' | 'map' | 'union' | 'field' | 'action' | 'alias' | 'label' | 'separator';
+/** Leaves that share one row in a compact property UI, declared on the first
+ *  of them. Purely presentational. */
 interface PrefPair {
     /** The other leaves on the row, by the full path their values are read and
      *  written at (`'pose.y'`, `'camera.type'`), in order. Each must follow the
@@ -136,6 +272,11 @@ interface PrefBase<K extends string, Value> {
     default: Value;
     /** Hide from a host app's settings UI by default. */
     hidden?: boolean;
+    /** Drawn only while this holds. Presentational: the value stays stored
+     *  and readable while the leaf is not drawn. */
+    showIf?: PrefCondition;
+    /** Drawn, and disabled while this does not hold. */
+    enableIf?: PrefCondition;
     /** Nothing held where this leaf's value is read means `default`, because
      *  whoever reads the value takes it that way (`pose.rotation ?? 0`). A
      *  surface over sparse settings reads every leaf so already. One over a
@@ -182,32 +323,6 @@ type PrefBooleanControl = 'checkbox' | 'switch' | 'toggle';
 type PrefStringControl = 'input' | 'textarea';
 /** How a schema-driven UI should present an enum pref. */
 type PrefEnumControl = 'select' | 'radio' | 'toggle' | 'menu';
-/** Display-unit conversion for number leaves whose stored value uses a
- *  canonical unit the user shouldn't see (e.g. radians stored, degrees
- *  shown). The stored value stays canonical; UIs convert at the edge. */
-interface PrefNumberUnit {
-    toDisplay: (stored: number) => number;
-    fromDisplay: (display: number) => number;
-    /** Shown after the input, e.g. `'°'`. */
-    suffix?: string;
-    /** Suffixes a person may type, each mapped to the scale that turns a
-     *  number in that unit into a display number: `{ mm: 0.1, cm: 1 }` for a
-     *  field showing centimeters. A unit that disagrees with the display unit
-     *  about zero carries an `offset` as well. */
-    accepts?: Readonly<Record<string, UnitEntry>>;
-    /** The stored value as display text, suffix included. */
-    format?: (stored: number) => string;
-}
-/**
- * A display unit built from a {@link UnitSystem}: values are stored in the
- * system's base and shown in `display`, rounded to `precision` places when
- * given, and every unit in the system is accepted as typed text. `suffix`
- * defaults to the unit's name and is accepted too.
- */
-declare function prefUnit(system: UnitSystem, display: Unit, opts?: {
-    precision?: number;
-    suffix?: string;
-}): PrefNumberUnit;
 /** A numeric pref, optionally bounded and stepped, and optionally stored in a
  *  different unit from the one shown. */
 interface PrefNumber extends PrefBase<'number', number> {
@@ -251,8 +366,7 @@ interface PrefString extends PrefBase<'string', string> {
  *
  * A dash array is the case that needs it: `Stroke.dash` stores lengths, and
  * the thing a person chooses is a style. The presets scale by the stroke's
- * width, so both directions are given the object's other fields — a style is
- * meaningless without the width it is a multiple of.
+ * width, so both directions are given the object's other fields.
  */
 interface PrefEnumEncoding<T extends string = string> {
     /**
@@ -315,13 +429,12 @@ interface PrefColor extends PrefBase<'color', string> {
 }
 /**
  * Open leaf: any node with a `kind` outside the built-ins. Schema-driven
- * UIs (weasel-ui `PrefsForm` / `SelectionPanel`) dispatch it to an
- * app-supplied renderer. Deliberately NOT index-signatured so concrete
- * app interfaces stay assignable. Mirrors weasel-ui's `PrefCustom`.
+ * UIs dispatch it to an app-supplied renderer. Deliberately NOT
+ * index-signatured so concrete app interfaces stay assignable.
  */
 type PrefCustom = PrefBase<string, unknown>;
 /**
- * A whole `FillStyle`, not a color inside one. Use it wherever the value is
+ * A whole `Paint`, not a color inside one. Use it wherever the value is
  * the tagged paint union — a solid color, a pattern, a gradient — rather
  * than a hex string.
  *
@@ -336,21 +449,16 @@ interface PrefPaint extends PrefBase<'paint', unknown> {
     alpha?: boolean;
 }
 /**
- * A leaf whose value is one object, with its own fields hanging off it.
- *
- * A compound value — a stroke, a shadow, a pattern spec — could be described
- * as several sibling leaves addressing into it (`data.stroke.width`,
- * `data.stroke.cap`). It shouldn't be: each control would then write one field
- * of a value it can only half see, and writing into something that is not an
- * object yet corrupts it. Here the fields are `children` of one leaf, and
- * every edit commits the parent object whole.
+ * A leaf whose value is one object, with its own fields hanging off it as
+ * `children`; every edit commits the parent object whole. Sibling leaves
+ * addressing into the value (`data.stroke.width`, `data.stroke.cap`) would
+ * each write one field of a value they can only half see, and writing into
+ * something that is not an object yet corrupts it.
  *
  * `children` paths are relative to the object. They are ordinary leaves, so a
  * field that is itself a union (a stroke's `paint`) declares the kind that
  * edits that union. A child may also be a {@link PrefSection}, which
- * organizes the fields under a heading without contributing to the path. A
- * `TextStyle` needs it: its character and paragraph fields belong to one
- * value but read as two lists.
+ * organizes the fields under a heading without contributing to the path.
  */
 interface PrefObject extends PrefBase<'object', unknown> {
     children: Record<string, PrefLeaf | PrefSection>;
@@ -377,8 +485,7 @@ type BuiltinPref = PrefNumber | PrefBoolean | PrefString | PrefEnum | PrefColor
 /**
  * The built-in kinds, as a table. A kind added to {@link PrefKind} is a
  * compile error here, and from here it is one in every renderer's `never`
- * guard — the only thing standing between a new kind and rendering as
- * nothing in four places at once.
+ * guard.
  */
 declare const PREF_KINDS: Record<PrefKind, true>;
 /** Which row each pairing among `leaves` puts a path on: a `key` the row's
@@ -427,6 +534,10 @@ interface PrefGroup {
     /** How the group is drawn. Unset, its depth decides: a top-level group is a
      *  `page`, and one inside another is a `section`. */
     as?: PrefGroupAs;
+    /** Drawn, with everything under it, only while this holds. */
+    showIf?: PrefCondition;
+    /** Everything under it is disabled while this does not hold. */
+    enableIf?: PrefCondition;
     children: Record<string, PrefLeaf | PrefGroup>;
 }
 /**
@@ -445,6 +556,10 @@ interface PrefSection {
      *  `page`, since nothing that draws sections has a rail. Unset: a heading
      *  over its rows. */
     as?: PrefSectionAs;
+    /** As a {@link PrefGroup}'s. */
+    showIf?: PrefCondition;
+    /** As a {@link PrefGroup}'s. */
+    enableIf?: PrefCondition;
     members: Record<string, PrefLeaf | PrefSection>;
 }
 /** Whether a top-level group gets a page of its own, and not a place on the page of the root's own leaves. */
@@ -528,6 +643,18 @@ type PrefValueOf<L> = L extends {
 /** What the leaf at `P` holds. */
 type PrefValueAt<G, P extends string> = PrefValueOf<PrefAtPath<G, P>>;
 
+/** Takes stored values from one version to the next: rename, transform or
+ *  delete entries in `records`, keyed by leaf path. It sees the values, not
+ *  the stamps they are stored under, and only those at its own version. */
+type PrefsMigration = (records: Map<string, unknown>) => void;
+
+/** Decides what a stored value reads as for one kind of leaf: the value to
+ *  read, or `undefined` for "invalid, read the default". */
+type PrefValidator = (stored: unknown, leaf: PrefLeaf) => unknown;
+/** What `stored` reads as for `leaf`. Never writes anything back: a schema
+ *  rolled back finds the original still in storage. */
+declare function repairPrefValue(leaf: PrefLeaf, stored: unknown, validators?: Readonly<Record<string, PrefValidator>>): unknown;
+
 /** One leaf changing, as a store subscriber hears it: the value readers now
  *  see, and whether this store or another writer made the change. */
 interface PrefChange {
@@ -556,8 +683,13 @@ interface PrefsStore<S extends PrefGroup> {
     subscribe(listener: (changes: PrefChange[]) => void): () => void;
     /** False while the store cannot persist: storage has not been read yet, or
      *  was written by a newer schema. Changes still apply for this session, and
-     *  ones made before a late read lands are persisted when it does. */
+     *  ones made before a late read lands are persisted when it does. False for
+     *  good once the store is closed. */
     readonly writable: boolean;
+    /** True once `close` was called. A write after that changes what this store
+     *  reads and reaches neither storage nor its subscribers, and the first one
+     *  warns. */
+    readonly closed: boolean;
     /** Try again now to read storage that could not be read at open, ahead of
      *  the store's own retries. Resolves whether storage has been read. */
     read(): Promise<boolean>;
@@ -569,4 +701,24 @@ interface PrefsStore<S extends PrefGroup> {
     close(): Promise<void>;
 }
 
-export { type PrefList as A, type BuiltinPref as B, type PrefMap as C, type PrefNumberControl as D, type PrefNumberUnit as E, type PrefPaint as F, type PrefPair as G, type PrefPath as H, type PrefSectionAs as I, type PrefSeparator as J, type PrefString as K, type PrefStringControl as L, type PrefUnion as M, type PrefValueAt as N, type PrefValueOf as O, type PrefLeaf as P, isBuiltinPref as Q, pairRowsOf as R, prefAliasTarget as S, prefAliasedLeaf as T, prefGroupIsPage as U, prefUnit as V, prefVariantDefault as W, prefVariantOf as X, type PrefGroup as a, type PrefSection as b, type PrefNumber as c, type PrefObject as d, type PrefsStore as e, type PrefKind as f, PREF_KINDS as g, type PrefAction as h, type PrefActionContext as i, type PrefActionControl as j, type PrefAlias as k, type PrefAtPath as l, type PrefBase as m, type PrefBoolean as n, type PrefBooleanControl as o, type PrefBooleanEncoding as p, type PrefChange as q, type PrefColor as r, type PrefCustom as s, type PrefEnum as t, type PrefEnumBase as u, type PrefEnumControl as v, type PrefEnumEncoding as w, type PrefField as x, type PrefGroupAs as y, type PrefLabel as z };
+/** Options for `openPrefs` and `openPrefsSync`. */
+interface PrefsOptions {
+    storage: StorageAdapter;
+    /** Prepended to every record's key: `'myapp.prefs.'`. */
+    prefix: string;
+    /** `migrations[i]` takes stored records from version `i` to `i + 1`. The
+     *  current version is `migrations.length`. */
+    migrations?: readonly PrefsMigration[];
+    /** Validators for app-defined kinds, keyed by `kind`. One given for a
+     *  built-in kind replaces that kind's own rule. */
+    validators?: Readonly<Record<string, PrefValidator>>;
+}
+/** Load every stored value for `schema`, migrate it, and return the store. */
+declare function openPrefs<S extends PrefGroup>(schema: S, options: PrefsOptions): Promise<PrefsStore<S>>;
+/** `openPrefs` for an adapter that reads synchronously: the store is ready
+ *  on return, so values can be read before anything renders. */
+declare function openPrefsSync<S extends PrefGroup>(schema: S, options: PrefsOptions & {
+    storage: SyncStorageAdapter;
+}): PrefsStore<S>;
+
+export { isPrefCondition as $, type PrefEnumEncoding as A, type BuiltinPref as B, type PrefField as C, type PrefFunctionUnit as D, type PrefGroupAs as E, type PrefLabel as F, type PrefLinearUnit as G, type PrefNumberControl as H, type PrefNumberUnit as I, type PrefPaint as J, type PrefPair as K, type PrefPath as L, type PrefSectionAs as M, type PrefSeparator as N, type PrefString as O, type PrefLeaf as P, type PrefStringControl as Q, type PrefTest as R, type PrefUnion as S, type PrefValidator as T, type PrefValueAt as U, type PrefValueOf as V, type PrefsMigration as W, type PrefsOptions as X, type PrefsStore as Y, type ResolvedPrefUnit as Z, isBuiltinPref as _, type PrefGroup as a, isPrefLinearUnit as a0, mapPrefConditionPaths as a1, openPrefs as a2, openPrefsSync as a3, pairRowsOf as a4, prefAliasName as a5, prefAliasTarget as a6, prefAliasedLeaf as a7, prefConditionHolds as a8, prefConditionPaths as a9, prefConditionReadsItem as aa, prefGroupIsPage as ab, prefIsEnabled as ac, prefIsShown as ad, prefUnit as ae, prefVariantDefault as af, prefVariantOf as ag, repairPrefValue as ah, resolvePrefUnit as ai, type PrefSection as b, type PrefNumber as c, type PrefList as d, type PrefMap as e, type PrefCondition as f, type PrefConditionReader as g, type PrefAlias as h, type PrefObject as i, type PrefKind as j, PREF_KINDS as k, type PrefAction as l, type PrefActionContext as m, type PrefActionControl as n, type PrefAtPath as o, type PrefBase as p, type PrefBoolean as q, type PrefBooleanControl as r, type PrefBooleanEncoding as s, type PrefChange as t, type PrefColor as u, type PrefConditionValue as v, type PrefCustom as w, type PrefEnum as x, type PrefEnumBase as y, type PrefEnumControl as z };

package/dist/react.d.ts

@@ -1,4 +1,5 @@
-import { a as PrefGroup, H as PrefPath, e as PrefsStore, N as PrefValueAt } from './store-CNFnA_3c.js';
+import { a as PrefGroup, L as PrefPath, Y as PrefsStore, U as PrefValueAt, X as PrefsOptions } from './open-BEY-aOGe.js';
+import { SyncStorageAdapter } from '@weasel-js/storage';
 import '@weasel-js/quantity';
 
 /** One leaf of `store`, as React state. */
@@ -17,4 +18,27 @@ declare function usePrefsValues<S extends PrefGroup>(store: PrefsStore<S>): {
     reset: (path?: string) => void;
 };
 
-export { usePref, usePrefsValues };
+type SyncOptions = PrefsOptions & {
+    storage: SyncStorageAdapter;
+};
+/**
+ * A store for `schema`, open while the component is mounted: opened during
+ * the first render, so that render has values, and closed, with its queued
+ * writes sent, when the component unmounts.
+ *
+ * Components naming the same `storage`, `prefix`, and `schema` share one
+ * store, which closes when the last of them unmounts. Components naming the
+ * same `storage` and `prefix` with different schemas each get a store of
+ * their own over the same records, so a write through one is read by the
+ * others at once, and each hears it as a `local` change. They must pass the
+ * same `migrations`: the records are migrated once, when the first opens.
+ *
+ * `storage` and `schema` are compared by identity and `prefix` by value, so
+ * keep the first two out of the render body. A change to any of the three
+ * closes the store and returns the one for the new three. The `options`
+ * object itself may be new every render: `migrations` and `validators` are
+ * read when a store opens, and a change to either alone opens nothing.
+ */
+declare function usePrefsStore<S extends PrefGroup>(schema: S, options: SyncOptions): PrefsStore<S>;
+
+export { usePref, usePrefsStore, usePrefsValues };

package/dist/react.js

@@ -1,6 +1,6 @@
+import { openPrefsCacheSync, createPrefsStore } from './chunk-5KB3WBJZ.js';
 import { useCallback, useSyncExternalStore } from 'react';
 
-// src/hooks.ts
 function usePref(store, path) {
   const subscribe = useCallback((onChange) => store.subscribe(onChange), [store]);
   const getSnapshot = () => store.get(path);
@@ -28,7 +28,71 @@ function usePrefsValues(store) {
   const reset = useCallback((path) => store.reset(path), [store]);
   return { values, set, unset, stored, reset };
 }
+var shared = /* @__PURE__ */ new WeakMap();
+function sharedAt(storage, prefix) {
+  let byPrefix = shared.get(storage);
+  if (!byPrefix) shared.set(storage, byPrefix = /* @__PURE__ */ new Map());
+  let entry = byPrefix.get(prefix);
+  if (!entry) byPrefix.set(prefix, entry = { open: null, bySchema: /* @__PURE__ */ new Map() });
+  return entry;
+}
+function heldAt(at, schema) {
+  let entry = at.bySchema.get(schema);
+  if (!entry) at.bySchema.set(schema, entry = { store: null, holders: 0 });
+  return entry;
+}
+var lent = (cache) => Object.create(cache, {
+  close: {
+    value: async () => {
+      await cache.flush();
+    }
+  }
+});
+function closeUnheldSoon(storage, prefix, schema, entry) {
+  queueMicrotask(() => {
+    if (entry.holders > 0) return;
+    void entry.store?.close();
+    entry.store = null;
+    const byPrefix = shared.get(storage);
+    const at = byPrefix?.get(prefix);
+    if (!at || !byPrefix) return;
+    if (at.bySchema.get(schema) === entry) at.bySchema.delete(schema);
+    if (at.bySchema.size > 0) return;
+    at.open?.stop();
+    void at.open?.cache.close();
+    byPrefix.delete(prefix);
+  });
+}
+function acquire(schema, options) {
+  const { storage, prefix } = options;
+  const at = sharedAt(storage, prefix);
+  const entry = heldAt(at, schema);
+  if (!entry.store) {
+    at.open ??= openPrefsCacheSync(options);
+    entry.store = createPrefsStore(
+      schema,
+      lent(at.open.cache),
+      options.validators,
+      void 0,
+      options.migrations?.length ?? 0
+    );
+    if (entry.holders === 0) closeUnheldSoon(storage, prefix, schema, entry);
+  }
+  return entry.store;
+}
+function usePrefsStore(schema, options) {
+  const { storage, prefix } = options;
+  const hold = useCallback(() => {
+    const entry = heldAt(sharedAt(storage, prefix), schema);
+    entry.holders++;
+    return () => {
+      if (--entry.holders === 0) closeUnheldSoon(storage, prefix, schema, entry);
+    };
+  }, [storage, prefix, schema]);
+  const current = () => acquire(schema, options);
+  return useSyncExternalStore(hold, current, current);
+}
 
-export { usePref, usePrefsValues };
+export { usePref, usePrefsStore, usePrefsValues };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/hooks.ts"],"names":[],"mappings":";;;AAMO,SAAS,OAAA,CACd,OACA,IAAA,EAIA;AACA,EAAA,MAAM,SAAA,GAAY,WAAA,CAAY,CAAC,QAAA,KAAyB,KAAA,CAAM,UAAU,QAAQ,CAAA,EAAG,CAAC,KAAK,CAAC,CAAA;AAC1F,EAAA,MAAM,WAAA,GAAc,MAAM,KAAA,CAAM,GAAA,CAAI,IAAI,CAAA;AACxC,EAAA,MAAM,KAAA,GAAQ,oBAAA,CAAqB,SAAA,EAAW,WAAA,EAAa,WAAW,CAAA;AACtE,EAAA,MAAM,GAAA,GAAM,WAAA;AAAA,IACV,CAAC,IAAA,KAA+E;AAC9E,MAAA,KAAA,CAAM,GAAA;AAAA,QACJ,IAAA;AAAA,QACA,OAAO,SAAS,UAAA,GACX,IAAA,CAAwD,MAAM,GAAA,CAAI,IAAI,CAAC,CAAA,GACxE;AAAA,OACN;AAAA,IACF,CAAA;AAAA,IACA,CAAC,OAAO,IAAI;AAAA,GACd;AACA,EAAA,OAAO,CAAC,OAAO,GAAG,CAAA;AACpB;AAKO,SAAS,eAAoC,KAAA,EAMlD;AACA,EAAA,MAAM,SAAA,GAAY,WAAA,CAAY,CAAC,QAAA,KAAyB,KAAA,CAAM,UAAU,QAAQ,CAAA,EAAG,CAAC,KAAK,CAAC,CAAA;AAC1F,EAAA,MAAM,SAAS,oBAAA,CAAqB,SAAA,EAAW,KAAA,CAAM,MAAA,EAAQ,MAAM,MAAM,CAAA;AACzE,EAAA,MAAM,QAAQ,oBAAA,CAAqB,SAAA,EAAW,KAAA,CAAM,KAAA,EAAO,MAAM,KAAK,CAAA;AACtE,EAAA,MAAM,SAAS,oBAAA,CAAqB,SAAA,EAAW,KAAA,CAAM,MAAA,EAAQ,MAAM,MAAM,CAAA;AACzE,EAAA,MAAM,GAAA,GAAM,WAAA;AAAA,IACV,CAAC,IAAA,EAAc,KAAA,KAAmB,KAAA,CAAM,GAAA,CAAI,MAAqB,KAAc,CAAA;AAAA,IAC/E,CAAC,KAAK;AAAA,GACR;AACA,EAAA,MAAM,KAAA,GAAQ,WAAA,CAAY,CAAC,IAAA,KAAkB,KAAA,CAAM,MAAM,IAAI,CAAA,EAAG,CAAC,KAAK,CAAC,CAAA;AACvE,EAAA,OAAO,EAAE,MAAA,EAAQ,GAAA,EAAK,KAAA,EAAO,QAAQ,KAAA,EAAM;AAC7C","file":"react.js","sourcesContent":["import { useCallback, useSyncExternalStore } from 'react';\nimport type { PrefPath, PrefValueAt } from './paths';\nimport type { PrefGroup } from './groups';\nimport type { PrefsStore } from './store';\n\n/** One leaf of `store`, as React state. */\nexport function usePref<S extends PrefGroup, P extends PrefPath<S>>(\n  store: PrefsStore<S>,\n  path: P,\n): [\n  PrefValueAt<S, P>,\n  (next: PrefValueAt<S, P> | ((prev: PrefValueAt<S, P>) => PrefValueAt<S, P>)) => void,\n] {\n  const subscribe = useCallback((onChange: () => void) => store.subscribe(onChange), [store]);\n  const getSnapshot = () => store.get(path);\n  const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n  const set = useCallback(\n    (next: PrefValueAt<S, P> | ((prev: PrefValueAt<S, P>) => PrefValueAt<S, P>)) => {\n      store.set(\n        path,\n        typeof next === 'function'\n          ? (next as (prev: PrefValueAt<S, P>) => PrefValueAt<S, P>)(store.get(path))\n          : next,\n      );\n    },\n    [store, path],\n  );\n  return [value, set];\n}\n\n/** The whole of `store` as React state, shaped for `PrefsForm`: `values`,\n *  `onChange={set}`, `auto={unset}`, and `reset` for `onAutoChange`. `stored`\n *  is `store.stored()`. */\nexport function usePrefsValues<S extends PrefGroup>(store: PrefsStore<S>): {\n  values: Record<string, unknown>;\n  set: (path: string, value: unknown) => void;\n  unset: ReadonlySet<string>;\n  stored: Record<string, unknown>;\n  reset: (path?: string) => void;\n} {\n  const subscribe = useCallback((onChange: () => void) => store.subscribe(onChange), [store]);\n  const values = useSyncExternalStore(subscribe, store.values, store.values);\n  const unset = useSyncExternalStore(subscribe, store.unset, store.unset);\n  const stored = useSyncExternalStore(subscribe, store.stored, store.stored);\n  const set = useCallback(\n    (path: string, value: unknown) => store.set(path as PrefPath<S>, value as never),\n    [store],\n  );\n  const reset = useCallback((path?: string) => store.reset(path), [store]);\n  return { values, set, unset, stored, reset };\n}\n"]}
+{"version":3,"sources":["../src/hooks.ts","../src/usePrefsStore.ts"],"names":["useCallback","useSyncExternalStore"],"mappings":"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","file":"react.js","sourcesContent":["import { useCallback, useSyncExternalStore } from 'react';\nimport type { PrefPath, PrefValueAt } from './paths';\nimport type { PrefGroup } from './groups';\nimport type { PrefsStore } from './store';\n\n/** One leaf of `store`, as React state. */\nexport function usePref<S extends PrefGroup, P extends PrefPath<S>>(\n  store: PrefsStore<S>,\n  path: P,\n): [\n  PrefValueAt<S, P>,\n  (next: PrefValueAt<S, P> | ((prev: PrefValueAt<S, P>) => PrefValueAt<S, P>)) => void,\n] {\n  const subscribe = useCallback((onChange: () => void) => store.subscribe(onChange), [store]);\n  const getSnapshot = () => store.get(path);\n  const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n  const set = useCallback(\n    (next: PrefValueAt<S, P> | ((prev: PrefValueAt<S, P>) => PrefValueAt<S, P>)) => {\n      store.set(\n        path,\n        typeof next === 'function'\n          ? (next as (prev: PrefValueAt<S, P>) => PrefValueAt<S, P>)(store.get(path))\n          : next,\n      );\n    },\n    [store, path],\n  );\n  return [value, set];\n}\n\n/** The whole of `store` as React state, shaped for `PrefsForm`: `values`,\n *  `onChange={set}`, `auto={unset}`, and `reset` for `onAutoChange`. `stored`\n *  is `store.stored()`. */\nexport function usePrefsValues<S extends PrefGroup>(store: PrefsStore<S>): {\n  values: Record<string, unknown>;\n  set: (path: string, value: unknown) => void;\n  unset: ReadonlySet<string>;\n  stored: Record<string, unknown>;\n  reset: (path?: string) => void;\n} {\n  const subscribe = useCallback((onChange: () => void) => store.subscribe(onChange), [store]);\n  const values = useSyncExternalStore(subscribe, store.values, store.values);\n  const unset = useSyncExternalStore(subscribe, store.unset, store.unset);\n  const stored = useSyncExternalStore(subscribe, store.stored, store.stored);\n  const set = useCallback(\n    (path: string, value: unknown) => store.set(path as PrefPath<S>, value as never),\n    [store],\n  );\n  const reset = useCallback((path?: string) => store.reset(path), [store]);\n  return { values, set, unset, stored, reset };\n}\n","import type { OwnedRecordCache, StorageAdapter, SyncStorageAdapter } from '@weasel-js/storage';\nimport { useCallback, useSyncExternalStore } from 'react';\nimport type { PrefGroup } from './groups';\nimport { openPrefsCacheSync, type PrefsOptions } from './open';\nimport { createPrefsStore, type PrefsStore } from './store';\n\n/** The store open for one schema, and how many mounted components hold it. */\ninterface Held {\n  store: PrefsStore<PrefGroup> | null;\n  holders: number;\n}\n\n/** The one cache open on a prefix, and a store over it for each schema in use. */\ninterface Shared {\n  open: { cache: OwnedRecordCache; stop: () => void } | null;\n  bySchema: Map<PrefGroup, Held>;\n}\n\ntype SyncOptions = PrefsOptions & { storage: SyncStorageAdapter };\n\nconst shared = new WeakMap<StorageAdapter, Map<string, Shared>>();\n\nfunction sharedAt(storage: StorageAdapter, prefix: string): Shared {\n  let byPrefix = shared.get(storage);\n  if (!byPrefix) shared.set(storage, (byPrefix = new Map()));\n  let entry = byPrefix.get(prefix);\n  if (!entry) byPrefix.set(prefix, (entry = { open: null, bySchema: new Map() }));\n  return entry;\n}\n\nfunction heldAt(at: Shared, schema: PrefGroup): Held {\n  let entry = at.bySchema.get(schema);\n  if (!entry) at.bySchema.set(schema, (entry = { store: null, holders: 0 }));\n  return entry;\n}\n\n/** `cache` for one store among several: closing it sends queued writes and\n *  leaves the cache open for the others. */\nconst lent = (cache: OwnedRecordCache): OwnedRecordCache =>\n  Object.create(cache, {\n    close: {\n      value: async (): Promise<void> => {\n        await cache.flush();\n      },\n    },\n  }) as OwnedRecordCache;\n\n/** Close a store nothing holds, and the cache once no store is over it, a\n *  microtask on: after the remount StrictMode and fast refresh make in the\n *  same tick, which holds it again. */\nfunction closeUnheldSoon(storage: StorageAdapter, prefix: string, schema: PrefGroup, entry: Held): void {\n  queueMicrotask(() => {\n    if (entry.holders > 0) return;\n    void entry.store?.close();\n    entry.store = null;\n    const byPrefix = shared.get(storage);\n    const at = byPrefix?.get(prefix);\n    if (!at || !byPrefix) return;\n    if (at.bySchema.get(schema) === entry) at.bySchema.delete(schema);\n    if (at.bySchema.size > 0) return;\n    at.open?.stop();\n    // `close` sends queued writes before its first await, and a sync adapter's\n    // write lands in that call, so a cache opened next reads them.\n    void at.open?.cache.close();\n    byPrefix.delete(prefix);\n  });\n}\n\nfunction acquire<S extends PrefGroup>(schema: S, options: SyncOptions): PrefsStore<S> {\n  const { storage, prefix } = options;\n  const at = sharedAt(storage, prefix);\n  const entry = heldAt(at, schema);\n  if (!entry.store) {\n    at.open ??= openPrefsCacheSync(options);\n    entry.store = createPrefsStore(\n      schema,\n      lent(at.open.cache),\n      options.validators,\n      undefined,\n      options.migrations?.length ?? 0,\n    ) as unknown as PrefsStore<PrefGroup>;\n    // Opened by a render that may never mount.\n    if (entry.holders === 0) closeUnheldSoon(storage, prefix, schema, entry);\n  }\n  return entry.store as unknown as PrefsStore<S>;\n}\n\n/**\n * A store for `schema`, open while the component is mounted: opened during\n * the first render, so that render has values, and closed, with its queued\n * writes sent, when the component unmounts.\n *\n * Components naming the same `storage`, `prefix`, and `schema` share one\n * store, which closes when the last of them unmounts. Components naming the\n * same `storage` and `prefix` with different schemas each get a store of\n * their own over the same records, so a write through one is read by the\n * others at once, and each hears it as a `local` change. They must pass the\n * same `migrations`: the records are migrated once, when the first opens.\n *\n * `storage` and `schema` are compared by identity and `prefix` by value, so\n * keep the first two out of the render body. A change to any of the three\n * closes the store and returns the one for the new three. The `options`\n * object itself may be new every render: `migrations` and `validators` are\n * read when a store opens, and a change to either alone opens nothing.\n */\nexport function usePrefsStore<S extends PrefGroup>(schema: S, options: SyncOptions): PrefsStore<S> {\n  const { storage, prefix } = options;\n  const hold = useCallback(() => {\n    const entry = heldAt(sharedAt(storage, prefix), schema);\n    entry.holders++;\n    return () => {\n      if (--entry.holders === 0) closeUnheldSoon(storage, prefix, schema, entry);\n    };\n  }, [storage, prefix, schema]);\n  // Read again once held, so a store closed between render and mount is\n  // replaced before anything uses it.\n  const current = () => acquire(schema, options);\n  return useSyncExternalStore(hold, current, current);\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/prefs",
-  "version": "1.9.4",
+  "version": "1.10.0",
   "description": "A preferences schema, a store that loads, validates, migrates and persists values against it, and React hooks over the store.",
   "license": "MIT",
   "type": "module",
@@ -41,9 +41,9 @@
     "build": "tsup"
   },
   "dependencies": {
-    "@weasel-js/quantity": "1.9.4",
-    "@weasel-js/registry": "1.9.4",
-    "@weasel-js/storage": "1.9.4"
+    "@weasel-js/quantity": "1.10.0",
+    "@weasel-js/registry": "1.10.0",
+    "@weasel-js/storage": "1.10.0"
   },
   "peerDependencies": {
     "react": ">=18"