vultus-core 0.5.1 → 0.5.3

package/src/tree.ts

@@ -1,9 +1,12 @@
 import type { OneOfChoice, OneOfChoiceControls } from './choices.js';
+import { getVerdict } from './decision.js';
 import { normalizeText } from './normalizeText.js';
 
 /** A node of a tree field (Praeceptor's categories): a choice with children. */
 export interface TreeNode<T extends string = string> extends OneOfChoice<T> {
   children?: TreeNode<T>[];
+  /** Whether the one-of tree may choose this node (default true); a folder when false. Ignored by the many-of tree. */
+  choosable?: boolean;
 }
 
 /** A node as the widgets get it: the resolved choice, its children likewise, and whether it shows checked. */
@@ -16,12 +19,20 @@ export interface TreeNodeControls<T extends string = string> extends OneOfChoice
 /**
  * What a tree field's value lists, as antd TreeSelect's `showCheckedStrategy` and
  * `checkStrictly` do. In the three cascading selections a node stands for its subtree, and
- * a node all of whose children are covered is covered too; they differ only in which of the
- * covered nodes the value names:
+ * a node all of whose children are covered is covered too — disabled nodes aside, as antd
+ * conducts its checks (see `cascade`); they differ only in which of the covered nodes the
+ * value names:
  * - `'topmost'` (`SHOW_PARENT`, the default): the covered nodes whose parent is not covered;
  * - `'all'` (`SHOW_ALL`): every covered node;
  * - `'leaves'` (`SHOW_CHILD`): the covered leaves.
  *
+ * Where a disabled node breaks the cascade, the value also names what the others would not
+ * cover: `'topmost'` a covered disabled node under a covered parent, and a covered node under
+ * a covered disabled parent (as antd TreeSelect's SHOW_PARENT does); `'leaves'` a covered node
+ * with children that is disabled or has no enabled child (stricter than antd's SHOW_CHILD,
+ * which drops a checked disabled parent whose enabled children are all checked, and a parent
+ * whose only children are disabled and checked — so the value would no longer cover them).
+ *
  * `'independent'` (`checkStrictly`, moxb's `strictSelect`): each node is chosen on its own.
  */
 export type TreeSelection = 'topmost' | 'all' | 'leaves' | 'independent';
@@ -58,14 +69,33 @@ function unknownValues<T extends string>(order: TreeNode<T>[], value: T[]): T[]
   return [...new Set(value.filter((v) => !known.has(v)))];
 }
 
-/** The nodes a value covers in the cascading selections: the value's nodes, their descendants, and every node all of whose children are covered. */
+/**
+ * Whether a node can be checked: its `enabled` / `disabled` resolved as resolveChoice does (a
+ * Decision takes no context, so this needs none). Works on a definition's nodes (TreeNode,
+ * Decisions) and on the widgets' node controls (TreeNodeControls, `enabled: boolean`) alike.
+ */
+function nodeEnabled(node: Pick<TreeNode, 'enabled' | 'disabled'>): boolean {
+  if (node.enabled !== undefined) return getVerdict(node.enabled, true);
+  return !getVerdict(node.disabled, false);
+}
+
+/**
+ * The nodes a value covers in the cascading selections, by antd's check conduction (rc-tree's
+ * conductCheck), so the hook and the widgets agree: the value's nodes; the enabled children of
+ * a covered enabled node, and so on down (a disabled node is never covered through a checked
+ * ancestor, nor is its subtree through it); and an enabled node all of whose enabled children
+ * are covered, if it has any (a parent whose children are all disabled, or a disabled parent,
+ * is never covered through its children). A disabled node in the value covers itself only.
+ */
 function cascade<T extends string>(nodes: TreeNode<T>[], value: T[]): Set<T> {
   const listed = new Set(value);
   const covered = new Set<T>();
   const walk = (node: TreeNode<T>, inherited: boolean): boolean => {
-    const self = inherited || listed.has(node.value);
-    const children = (node.children ?? []).map((child) => walk(child, self));
-    const isCovered = self || (children.length > 0 && children.every(Boolean));
+    const enabled = nodeEnabled(node);
+    const self = listed.has(node.value) || (inherited && enabled);
+    const children = (node.children ?? []).map((child) => ({ enabled: nodeEnabled(child), covered: walk(child, self && enabled) }));
+    const counted = children.filter((child) => child.enabled);
+    const isCovered = self || (enabled && counted.length > 0 && counted.every((child) => child.covered));
     if (isCovered) covered.add(node.value);
     return isCovered;
   };
@@ -73,14 +103,29 @@ function cascade<T extends string>(nodes: TreeNode<T>[], value: T[]): Set<T> {
   return covered;
 }
 
-/** The covered nodes the value names under `selection` (see TreeSelection), in pre-order. */
+/**
+ * The covered nodes the value names under `selection` (see TreeSelection), in pre-order, by
+ * rc-tree-select's formatStrategyValues (for `'leaves'`, a stricter form of it), so that the
+ * named nodes cover exactly what `covered` does (`cascade` of them gives it back) also where
+ * disabled nodes break the cascade:
+ * - `'topmost'`: a covered node unless its parent is covered and neither of the two is
+ *   disabled (only then does the parent cover it);
+ * - `'leaves'`: the covered leaves, and a covered node with children that is disabled, has
+ *   no enabled child, or has an enabled child not covered (its children would not cover it);
+ * - `'all'`: every covered node.
+ */
 function namedNodes<T extends string>(order: TreeNode<T>[], parent: Map<T, T>, covered: Set<T>, selection: TreeSelection): T[] {
+  const enabled = new Map(order.map((node) => [node.value, nodeEnabled(node)]));
   const named = order.filter((node) => {
     if (!covered.has(node.value)) return false;
-    if (selection === 'leaves') return !hasChildren(node);
     if (selection === 'topmost') {
       const up = parent.get(node.value);
-      return up === undefined || !covered.has(up);
+      return up === undefined || !covered.has(up) || !enabled.get(node.value) || !enabled.get(up);
+    }
+    if (selection === 'leaves') {
+      if (!hasChildren(node) || !enabled.get(node.value)) return true;
+      const counted = node.children!.filter((child) => enabled.get(child.value));
+      return counted.length === 0 || !counted.every((child) => covered.has(child.value));
     }
     return true;
   });
@@ -105,19 +150,23 @@ export function normalizeTreeValue<T extends string>(nodes: TreeNode<T>[], value
 /**
  * Every node a tree field's value stands for, in pre-order (what an item filed under some
  * node matches against): in the cascading selections the covered nodes (the value's nodes,
- * their descendants, and every node all of whose children are covered); with
- * `'independent'` the value's nodes themselves. Values that name no node follow, as in
- * normalizeTreeValue.
+ * their enabled descendants, and every enabled node all of whose enabled children are
+ * covered; see `cascade`); with `'independent'` the value's nodes themselves. Values that
+ * name no node follow, as in normalizeTreeValue. A node disabled when the value was stored
+ * and enabled now is covered from then on (with `'topmost'`, a stored parent covers it).
  */
 export function coveredNodes<T extends string>(nodes: TreeNode<T>[], value: T[], selection: TreeSelection = 'topmost'): T[] {
   return normalizeTreeValue(nodes, value, selection === 'independent' ? 'independent' : 'all');
 }
 
 /**
- * The value after flipping `node`, normalized. In the cascading selections a covered node
- * is removed with its descendants and its ancestors (they no longer have all their
- * children), and an uncovered one is added with its descendants; with `'independent'` the
- * node alone is added or removed. A `node` that is not one of the nodes changes nothing.
+ * The value after flipping `node`, normalized, as antd's Tree flips a checkbox. In the
+ * cascading selections a covered node is removed with the descendants it covers through
+ * enabled nodes and with its enabled ancestors up to the first disabled one (they no longer
+ * have all their enabled children); an uncovered one is added, covering its subtree as
+ * `cascade` says. With `'independent'` the node alone is added or removed. A `node` that is
+ * not one of the nodes changes nothing. Whether `node` itself may be flipped is the caller's
+ * to decide (useManyOfTreeField refuses a disabled one).
  */
 export function toggleTreeValue<T extends string>(nodes: TreeNode<T>[], value: T[], node: T, selection: TreeSelection): T[] {
   const { order, parent } = indexTree(nodes);
@@ -127,12 +176,16 @@ export function toggleTreeValue<T extends string>(nodes: TreeNode<T>[], value: T
     return normalizeTreeValue(nodes, value.includes(node) ? value.filter((v) => v !== node) : [...value, node], selection);
   }
   const covered = cascade(nodes, value);
-  const subtree = indexTree([target]).order.map((n) => n.value);
   if (covered.has(node)) {
-    for (const v of subtree) covered.delete(v);
-    for (let up = parent.get(node); up !== undefined; up = parent.get(up)) covered.delete(up);
+    const uncover = (n: TreeNode<T>) => {
+      covered.delete(n.value);
+      for (const child of n.children ?? []) if (nodeEnabled(child)) uncover(child);
+    };
+    uncover(target);
+    const byValue = new Map(order.map((n) => [n.value, n]));
+    for (let up = parent.get(node); up !== undefined && nodeEnabled(byValue.get(up)!); up = parent.get(up)) covered.delete(up);
   } else {
-    for (const v of subtree) covered.add(v);
+    covered.add(node);
   }
   return normalizeTreeValue(nodes, [...covered, ...unknownValues(order, value)], selection);
 }
@@ -173,3 +226,35 @@ export function filterTree<N extends { label?: string; value: string; children?:
   });
   return keep(nodes, false);
 }
+
+/**
+ * Which nodes the one-of tree field may choose: `'any'` node, or only `'leaves'` (a node with
+ * no children).
+ */
+export type TreeChoose = 'any' | 'leaves';
+
+/**
+ * Whether the one-of tree field may choose `node` under `choose` (see TreeChoose): choosable
+ * (its `choosable` is not `false`), enabled (as nodeEnabled resolves it), and, under `'leaves'`,
+ * has no children.
+ */
+export function canChooseNode(node: TreeNode, choose: TreeChoose): boolean {
+  if (node.choosable === false) return false;
+  if (!nodeEnabled(node)) return false;
+  return choose !== 'leaves' || !hasChildren(node);
+}
+
+/** The values canChooseNode accepts, in tree pre-order. */
+export function choosableValues<T extends string>(nodes: TreeNode<T>[], choose: TreeChoose): T[] {
+  const { order } = indexTree(nodes);
+  return order.filter((node) => canChooseNode(node, choose)).map((node) => node.value);
+}
+
+/** The values from the root down to `value` inclusive, in tree order; `[]` when no node has it. */
+export function treePath<T extends string>(nodes: TreeNode<T>[], value: T): T[] {
+  const { order, parent } = indexTree(nodes);
+  if (!order.some((node) => node.value === value)) return [];
+  const path: T[] = [value];
+  for (let up = parent.get(value); up !== undefined; up = parent.get(up)) path.unshift(up);
+  return path;
+}

package/src/{useTreeField.ts → useManyOfTreeField.ts}

@@ -8,7 +8,7 @@ import {
 } from './tree.js';
 import type { ErrorRoutesRegistry, ValueOrFn } from './types.js';
 
-export type TreeOwnOptions<T extends string = string, Ctx = any> = {
+export type ManyOfTreeOwnOptions<T extends string = string, Ctx = any> = {
   /** The roots, each with its children; static or derived (a function, of the field context if it declares a parameter). */
   nodes: ValueOrFn<TreeNode<T>[], Ctx>;
   /** What the value lists; default `'topmost'` (see TreeSelection). */
@@ -17,10 +17,10 @@ export type TreeOwnOptions<T extends string = string, Ctx = any> = {
   expand?: TreeExpand;
 };
 
-export type TreeFieldOptions<T extends string = string, RouteId extends string = string, Ctx = any> =
-  FieldOptions<T[], T[], RouteId, Ctx> & TreeOwnOptions<T, Ctx>;
+export type ManyOfTreeFieldOptions<T extends string = string, RouteId extends string = string, Ctx = any> =
+  FieldOptions<T[], T[], RouteId, Ctx> & ManyOfTreeOwnOptions<T, Ctx>;
 
-export interface TreeFieldControls<T extends string = string> extends FieldControls<T[], T[]> {
+export interface ManyOfTreeFieldControls<T extends string = string> extends FieldControls<T[], T[]> {
   /** The roots as the widgets get them, each with its children. */
   nodes: TreeNodeControls<T>[];
   selection: TreeSelection;
@@ -32,8 +32,8 @@ export interface TreeFieldControls<T extends string = string> extends FieldContr
   toggle(value: T): void;
 }
 
-/** The implicit initial value for a tree field: `initialValue` resolved, else the empty list. */
-export function treeInitialValue<T extends string>(
+/** The implicit initial value for a many-of tree field: `initialValue` resolved, else the empty list. */
+export function manyOfTreeInitialValue<T extends string>(
   opts: { initialValue?: ValueOrFn<T[]> },
   ctx: FieldCtx,
   id: string,
@@ -47,24 +47,25 @@ function sameList<T>(a: T[], b: T[]): boolean {
 
 /**
  * A field whose value is a set of tree nodes (Praeceptor's category filter), with antd
- * TreeSelect's semantics: in the cascading selections a checked node stands for its subtree,
- * and `selection` says which nodes the value lists (see TreeSelection). The value is shown
+ * TreeSelect's semantics: in the cascading selections a checked node stands for its subtree
+ * (its enabled part: disabled nodes follow antd's check conduction, so the widgets show what
+ * the value covers), and `selection` says which nodes the value lists (see TreeSelection). The value is shown
  * and requested normalized (normalizeTreeValue): in tree pre-order, values that name no
  * node (a stored value naming a removed node) kept at the end. `setValue` does not police
  * disabled nodes (the widgets disable them); `toggle` refuses a disabled or unknown node with
  * a warning, as useManyOfField does.
  */
-export function useTreeField<T extends string = string, RouteId extends string = string, Ctx = any>(
-  opts: TreeFieldOptions<T, RouteId, Ctx>,
+export function useManyOfTreeField<T extends string = string, RouteId extends string = string, Ctx = any>(
+  opts: ManyOfTreeFieldOptions<T, RouteId, Ctx>,
   registry?: ErrorRoutesRegistry<RouteId>,
-): TreeFieldControls<T> {
+): ManyOfTreeFieldControls<T> {
   const ctx = useFieldContext();
   const nodes = resolveIn<TreeNode<T>[]>(opts.nodes, [], ctx, `Field '${opts.id}': option 'nodes'`);
   const selection = opts.selection ?? 'topmost';
 
   const inside = !opts.onChange && !opts.commit;
-  const initialValue = () => treeInitialValue<T>(opts, ctx, opts.id);
-  const field = useFieldCore<T[], T[], RouteId, Ctx>('tree', inside ? { ...opts, initialValue } : opts, registry);
+  const initialValue = () => manyOfTreeInitialValue<T>(opts, ctx, opts.id);
+  const field = useFieldCore<T[], T[], RouteId, Ctx>('manyOfTree', inside ? { ...opts, initialValue } : opts, registry);
 
   // The same list object while it is already normalized, so the value is stable across renders.
   const normalized = normalizeTreeValue(nodes, field.value, selection);

package/src/useOneOfTreeField.ts

@@ -0,0 +1,182 @@
+import { useFieldCore, type FieldControls, type FieldOptions } from './field.js';
+import { resolveChoice, type OneOfChoiceControls } from './choices.js';
+import { useFieldContext, type FieldCtx } from './FieldContext.js';
+import { resolveIn } from './resolve.js';
+import {
+  canChooseNode, choosableValues, expandedTreeKeys, treePath,
+  type TreeChoose, type TreeExpand, type TreeNode,
+} from './tree.js';
+import type { ErrorRoutesRegistry, ValueOrFn } from './types.js';
+
+export type OneOfTreeOwnOptions<T extends string = string, Ctx = any> = {
+  /** The roots, each with its children; static or derived (a function, of the field context if it declares a parameter). */
+  nodes: ValueOrFn<TreeNode<T>[], Ctx>;
+  /** Which nodes may be chosen; default 'any' (see TreeChoose). */
+  choose?: TreeChoose;
+  /** Whether the value may be empty (''), nothing chosen; default false (as oneOf, never empty). */
+  optional?: boolean;
+  /** Which nodes a widget opens at first; default 'selected' (the value's ancestors; see TreeExpand). */
+  expand?: TreeExpand;
+};
+
+export type OneOfTreeFieldOptions<T extends string = string, RouteId extends string = string, Ctx = any> =
+  FieldOptions<T | '', T | '', RouteId, Ctx> & OneOfTreeOwnOptions<T, Ctx>;
+
+/** A tree node as the one-of tree's widgets get it: the resolved choice, its children likewise, and whether it may be chosen, is the value, or an ancestor of it. */
+export interface OneOfTreeNodeControls<T extends string = string> extends OneOfChoiceControls<T> {
+  children: OneOfTreeNodeControls<T>[] | undefined;
+  /** Whether the field may choose this node under `choose` (see canChooseNode). */
+  choosable: boolean;
+  /** It is the value. */
+  current: boolean;
+  /** An ancestor of the value (not the value itself). */
+  onPath: boolean;
+}
+
+export interface OneOfTreeFieldControls<T extends string = string> extends FieldControls<T | '', T | ''> {
+  /** The roots as the widgets get them, each with its children. */
+  nodes: OneOfTreeNodeControls<T>[];
+  /** Every node, by its value. */
+  byValue: Map<T, OneOfTreeNodeControls<T>>;
+  /** The chosen node, or undefined (the value is empty, or names no node). */
+  current: OneOfTreeNodeControls<T> | undefined;
+  /** The nodes from the root down to `current`, inclusive; empty when there is none. */
+  path: OneOfTreeNodeControls<T>[];
+  /**
+   * The choosable node just before `current` in tree pre-order — by `current`'s own position,
+   * not its position among the choosable nodes, so a `current` that cannot itself be chosen
+   * (a value naming a folder, or a node a context change disabled) still gets its true
+   * neighbours. Undefined at the start, and with no `current`.
+   */
+  previous: OneOfTreeNodeControls<T> | undefined;
+  /** The choosable node just after `current` in tree pre-order, by the same rule; with no `current`, the first choosable node. */
+  next: OneOfTreeNodeControls<T> | undefined;
+  optional: boolean;
+  choose: TreeChoose;
+  /** The nodes a widget opens at first (from `expand`). */
+  expandedKeys: T[];
+  /** Requests ''; refused (with a warning) unless `optional`, as `setValue('')` would be. */
+  clear(): void;
+}
+
+/**
+ * The implicit initial value for a one-of tree field: `initialValue` resolved through the field
+ * context, else '' when `optional`, else the first node `canChooseNode` accepts in tree
+ * pre-order, else '' (no node can be chosen; as oneOf's undefined choice).
+ */
+export function oneOfTreeInitialValue<T extends string>(
+  opts: { initialValue?: ValueOrFn<T | ''>; choose?: TreeChoose; optional?: boolean },
+  ctx: FieldCtx,
+  id: string,
+  nodes: TreeNode<T>[],
+): T | '' {
+  const resolved = resolveIn<T | '' | undefined>(opts.initialValue, undefined, ctx, `Field '${id}': option 'initialValue'`);
+  if (resolved !== undefined) return resolved;
+  if (opts.optional) return '';
+  return choosableValues(nodes, opts.choose ?? 'any')[0] ?? '';
+}
+
+/**
+ * A field whose value is a single tree node, or nothing (Praeceptor's category picker, a
+ * table of contents): `choosable` (a per-node flag, default true; a folder) and the field's
+ * `choose: 'any' | 'leaves'` together say which nodes `setValue` accepts (canChooseNode);
+ * `optional` says whether '' (nothing chosen) is one of them too. `setValue` refuses, with a
+ * warning (as useOneOfField refuses a disabled choice): a value naming no node, a node
+ * `canChooseNode` rejects, and '' unless `optional`. `clear()` requests ''. The field's current
+ * state is the chosen node's description, unless `valueDescriptions` words it differently (as
+ * oneOf). `previous` / `next` are the choosable nodes just before and after `current`'s own
+ * position in tree pre-order (so a `current` that cannot itself be chosen still gets its true
+ * neighbours, skipping only the nodes between them that cannot be chosen); with no `current`,
+ * `previous` is undefined and `next` is the first choosable node. `expandedKeys` (from `expand`,
+ * default `'selected'`) are the value's ancestors,
+ * so a table of contents opens where the reader is. Inside the field the value starts at
+ * `oneOfTreeInitialValue`.
+ */
+export function useOneOfTreeField<T extends string = string, RouteId extends string = string, Ctx = any>(
+  opts: OneOfTreeFieldOptions<T, RouteId, Ctx>,
+  registry?: ErrorRoutesRegistry<RouteId>,
+): OneOfTreeFieldControls<T> {
+  const ctx = useFieldContext();
+  const nodes = resolveIn<TreeNode<T>[]>(opts.nodes, [], ctx, `Field '${opts.id}': option 'nodes'`);
+  const choose = opts.choose ?? 'any';
+  const optional = opts.optional ?? false;
+
+  const inside = !opts.onChange && !opts.commit;
+  const initialValue = () => oneOfTreeInitialValue<T>(opts, ctx, opts.id, nodes);
+  const field = useFieldCore<T | '', T | '', RouteId, Ctx>('oneOfTree', inside ? { ...opts, initialValue } : opts, registry);
+
+  const valuePath = field.value ? treePath(nodes, field.value) : [];
+  const ancestors = new Set(valuePath);
+  const byValue = new Map<T, OneOfTreeNodeControls<T>>();
+  const control = (node: TreeNode<T>): OneOfTreeNodeControls<T> => {
+    const controls: OneOfTreeNodeControls<T> = {
+      ...resolveChoice(opts.id, node),
+      children: undefined,
+      choosable: canChooseNode(node, choose),
+      current: node.value === field.value,
+      onPath: ancestors.has(node.value) && node.value !== field.value,
+    };
+    byValue.set(node.value, controls);
+    if (node.children) controls.children = node.children.map(control);
+    return controls;
+  };
+  const nodeControls = nodes.map(control);
+
+  const current = field.value ? byValue.get(field.value) : undefined;
+  const pathControls = valuePath.map((v) => byValue.get(v)!);
+
+  // byValue's insertion order is the full tree's pre-order (control() visits a node before its
+  // children), so it doubles as "every node, choosable or not" for finding current's neighbours.
+  const fullOrder = [...byValue.keys()];
+  const nearestChoosable = (from: number, step: 1 | -1): OneOfTreeNodeControls<T> | undefined => {
+    for (let i = from; i >= 0 && i < fullOrder.length; i += step) {
+      const node = byValue.get(fullOrder[i])!;
+      if (node.choosable) return node;
+    }
+    return undefined;
+  };
+  const index = current ? fullOrder.indexOf(current.value) : -1;
+  const previous = nearestChoosable(index - 1, -1);
+  const next = nearestChoosable(index + 1, 1);
+
+  const setValue = (requested: T | '') => {
+    if (requested === '') {
+      if (!optional) {
+        console.warn(`Field '${opts.id}': '' is refused — the field is not optional`);
+        return;
+      }
+      field.setValue('');
+      return;
+    }
+    const node = byValue.get(requested);
+    if (!node) {
+      console.warn(`Field '${opts.id}': '${requested}' is not one of its nodes`);
+      return;
+    }
+    if (!node.choosable) {
+      if (!node.enabled) {
+        console.warn(`Field '${opts.id}': node '${requested}' is disabled — ${node.whyDisabled ?? '(no reason)'}`);
+      } else {
+        console.warn(`Field '${opts.id}': node '${requested}' cannot be chosen`);
+      }
+      return;
+    }
+    field.setValue(requested);
+  };
+
+  return {
+    ...field,
+    valueDescription: field.valueDescription ?? current?.description,
+    setValue,
+    nodes: nodeControls,
+    byValue,
+    current,
+    path: pathControls,
+    previous,
+    next,
+    optional,
+    choose,
+    expandedKeys: expandedTreeKeys(nodes, field.value ? [field.value] : [], opts.expand ?? 'selected'),
+    clear: () => setValue(''),
+  };
+}

package/src/useStoredField.ts

@@ -56,7 +56,9 @@ function showsDefault(arg: ArgDefinition<any>, stored: unknown, shown: () => unk
  */
 export interface StoredField<D extends FieldDefinition = FieldDefinition> {
   /** The definition in its outside form, for the kind's hook (`useManyOfField(stored.options)`). */
-  options: D extends any ? Omit<D, 'initialValue'> & { value: any; onChange(value: any): void } : never;
+  options: D extends any
+    ? Omit<D, 'initialValue'> & { value: any; onChange(value: any): void; hrefFor(value: any): string | undefined }
+    : never;
   isDefault: boolean;
   /** Removes the field's key from the store, so it shows its default again. */
   reset(method?: UpdateMethod): void;
@@ -96,7 +98,7 @@ export function useStoredField<D extends FieldDefinition>(definition: D): Stored
     : fresh;
   argRef.current = arg;
 
-  const { value: stored, set, reset } = useArg(arg);
+  const { value: stored, set, reset, hrefFor } = useArg(arg);
   // Called on the store, not passed detached: a store written as a class uses `this`.
   const subscribe = useCallback((listener: () => void) => store.subscribe(listener), [store]);
   const read = useCallback(() => store.read(definition.id), [store, definition.id]);
@@ -119,8 +121,8 @@ export function useStoredField<D extends FieldDefinition>(definition: D): Stored
   const onChange = useCallback((next: unknown) => set(next, 'replace'), [set]);
   const options = useMemo(() => {
     const { initialValue: _inside, ...rest } = definition;
-    return { ...rest, value, onChange } as StoredField<D>['options'];
-  }, [definition, value, onChange]);
+    return { ...rest, value, onChange, hrefFor } as StoredField<D>['options'];
+  }, [definition, value, onChange, hrefFor]);
 
   return { options, isDefault: showsDefault(arg, stored, () => value), reset };
 }

package/dist/useTreeField.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useTreeField.d.ts","sourceRoot":"","sources":["../src/useTreeField.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAEjF,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EAEL,KAAK,UAAU,EAAE,KAAK,QAAQ,EAAE,KAAK,gBAAgB,EAAE,KAAK,aAAa,EAC1E,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,GAAG,GAAG,GAAG,IAAI;IACjE,0HAA0H;IAC1H,KAAK,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IACrC,qEAAqE;IACrE,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,6EAA6E;IAC7E,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,OAAO,SAAS,MAAM,GAAG,MAAM,EAAE,GAAG,GAAG,GAAG,IAChG,YAAY,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,cAAc,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAEhE,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,aAAa,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;IAC3F,iEAAiE;IACjE,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7B,SAAS,EAAE,aAAa,CAAC;IACzB,yDAAyD;IACzD,YAAY,EAAE,CAAC,EAAE,CAAC;IAClB,gCAAgC;IAChC,OAAO,EAAE,GAAG,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;IACrC,2IAA2I;IAC3I,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACxB;AAED,iGAAiG;AACjG,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAC/C,IAAI,EAAE;IAAE,YAAY,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAA;CAAE,EACvC,GAAG,EAAE,QAAQ,EACb,EAAE,EAAE,MAAM,GACT,CAAC,EAAE,CAEL;AAMD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,OAAO,SAAS,MAAM,GAAG,MAAM,EAAE,GAAG,GAAG,GAAG,EAChG,IAAI,EAAE,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,EACvC,QAAQ,CAAC,EAAE,mBAAmB,CAAC,OAAO,CAAC,GACtC,iBAAiB,CAAC,CAAC,CAAC,CAgDtB"}

package/dist/useTreeField.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useTreeField.js","sourceRoot":"","sources":["../src/useTreeField.ts"],"names":[],"mappings":"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"}