vultus-core 0.5.0 → 0.5.2

package/src/parseApiError.ts

@@ -1,11 +1,17 @@
 import type { ParsedApiError } from './types.js';
 
+/**
+ * What a thrown error says, for an action's or a field commit's error message: an API error's
+ * status, reason and message (ts-rest's reject shape, `{ status, body: { message, reason } }`);
+ * without a body message, a thrown `Error`'s own message (`new Error('Printer offline')`, a
+ * failed fetch's TypeError), unless empty. `status` is 0 when the error carries none.
+ */
 export function parseApiError(err: unknown): ParsedApiError {
   if (typeof err !== 'object' || err === null) return { status: 0 };
   const e = err as { status?: number; body?: { message?: string; reason?: string } };
   return {
     status: e.status ?? 0,
     reason: e.body?.reason,
-    message: e.body?.message,
+    message: e.body?.message ?? ((err instanceof Error && err.message) || undefined),
   };
 }

package/src/tree.ts

@@ -1,4 +1,5 @@
 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. */
@@ -16,12 +17,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 +67,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 +101,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 +148,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 +174,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);
 }

package/src/types.ts

@@ -73,8 +73,8 @@ export interface ActionOptions<TArgs = void, TResult = void, RouteId extends str
   onSuccess?: (result: TResult) => void;
 }
 
-/** Compiles only when `A` is assignable to `B`. */
-type Fits<A extends B, B> = A;
+/** Compiles only when `A` is assignable to `B`. Not part of the package's public API: kept here as the one definition, imported directly by the files that use it (kinds.ts), and left out of index.ts's re-export of this module. */
+export type Fits<A extends B, B> = A;
 
 /**
  * A compile-time check: an action calls its options' functions with nothing, so one that takes

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/useNumericField.ts

@@ -1,7 +1,7 @@
 import { useFieldCore, type FieldControls, type FieldOptions } from './field.js';
 import { useFieldContext, type FieldCtx } from './FieldContext.js';
 import { resolveIn } from './resolve.js';
-import { clamp, resolveNumeric, type NumericBounds, type ResolvedNumeric } from './numeric.js';
+import { clamp, fit as fitNumber, resolveNumeric, type NumericBounds, type ResolvedNumeric } from './numeric.js';
 import type { ErrorRoutesRegistry } from './types.js';
 
 export type NumericOwnOptions<Ctx = any> = NumericBounds<Ctx>;
@@ -45,10 +45,7 @@ export function useNumericField<RouteId extends string = string, Ctx = any>(
   const field = useFieldCore<number, number, RouteId, Ctx>('numeric', inside ? { ...opts, initialValue } : opts, registry);
 
   /** A number clamped into the bounds, then rounded when `integer`. */
-  const fit = (n: number) => {
-    const clamped = clamp(n, resolved.min, resolved.max);
-    return resolved.integer ? Math.round(clamped) : clamped;
-  };
+  const fit = (n: number) => fitNumber(n, resolved.min, resolved.max, resolved.integer);
   const value = fit(field.value);
 
   const setValue = (next: number) => {

package/src/useRangeField.ts

@@ -1,7 +1,7 @@
 import { useFieldCore, type FieldControls, type FieldOptions } from './field.js';
 import { useFieldContext, type FieldCtx } from './FieldContext.js';
 import { resolveIn } from './resolve.js';
-import { clamp, resolveNumeric, type NumericBounds, type ResolvedNumeric } from './numeric.js';
+import { fit as fitNumber, resolveNumeric, type NumericBounds, type ResolvedNumeric } from './numeric.js';
 import type { ErrorRoutesRegistry, ValueOrFn } from './types.js';
 
 /** A `[from, to]` pair, `from <= to`. Not named `Range`, which would shadow the DOM's global type. */
@@ -59,10 +59,7 @@ export function useRangeField<RouteId extends string = string, Ctx = any>(
   const field = useFieldCore<NumberRange, NumberRange, RouteId, Ctx>('range', inside ? { ...opts, initialValue } : opts, registry);
 
   /** An end clamped into the bounds, then rounded when `integer`. */
-  const fit = (n: number) => {
-    const clamped = clamp(n, min, max);
-    return resolved.integer ? Math.round(clamped) : clamped;
-  };
+  const fit = (n: number) => fitNumber(n, min, max, resolved.integer);
   const value = order([fit(field.value[0]), fit(field.value[1])]);
 
   const setValue = (next: NumberRange) => {

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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"}