jsonisch 0.1.0

package/dist/plugin/index.d.ts

@@ -0,0 +1,188 @@
+import { A as EnvelopeState, B as EnvelopeSlot, E as DerivationState, I as AmountOrPercentSlot, O as DerivationSlot, P as validateFormInput, T as visibilityKey, U as EstimateSlot, a as ChecksState, g as BaggerState, k as derivationKey, o as checksKey, v as baggerKey } from "../plugin-BCsAE8RK.js";
+import { B as createSignal, D as InternalFieldStore, E as InternalBaseStore, F as ReadonlySignal, H as getListener, I as Signal, K as Path, L as Tracker, O as InternalObjectStore, P as Listener, R as batch, S as FieldElement, T as InternalArrayStore, U as untrack, V as createTracker, W as withListener, _ as WireContract, a as InternalFormStore, b as PluginKey, c as PluginDriver, d as hasPluginDirtyField, f as pluginsDirty, h as PluginCtx, k as InternalValueStore, l as encodeFieldValue, m as JsonischPlugin, n as internalOf, p as unwrapLeafInput, u as fieldPluginDirty, v as WireEnvelope, x as ContainerInput, y as FieldSlotKey, z as computed } from "../form-ref-D_xHSaqL.js";
+
+//#region src/core/field/focus-field-element.d.ts
+
+/**
+ * Focuses the first focusable element of a field store. The elements are
+ * tried in order and the first one that actually receives focus wins, so
+ * detached, disabled or hidden elements are skipped. The browser decides
+ * focusability, which is read back via the element's root `activeElement`
+ * so elements in a shadow root or another document are handled correctly.
+ *
+ * Hint: a `display: none` or `hidden` element is correctly skipped in real
+ * browsers, but jsdom has no layout and focuses it anyway, so that case
+ * cannot be covered by unit tests.
+ *
+ * @param internalFieldStore The field store to focus.
+ *
+ * @returns Whether an element was focused.
+ */
+declare function focusFieldElement(internalFieldStore: InternalFieldStore): boolean;
+//#endregion
+//#region src/core/field/get-field-bool.d.ts
+/**
+ * Returns whether the specified boolean property is true for the field
+ * store or any of its nested children.
+ *
+ * @param internalFieldStore The field store to check.
+ * @param type The boolean property type to check.
+ *
+ * @returns Whether the property is true.
+ */
+declare function getFieldBool(internalFieldStore: InternalFieldStore, type: "errors" | "validationErrors" | "isTouched" | "isEdited" | "isDirty"): boolean;
+//#endregion
+//#region src/core/field/get-field-input.d.ts
+/**
+ * Returns the current input of the field store. For arrays and objects,
+ * recursively collects input from all children (the tree is the allow-list:
+ * only declared fields can ever appear in the result). Returns `null` or
+ * `undefined` for nullish container inputs, or the leaf value for value
+ * fields.
+ *
+ * @param internalFieldStore The field store to get input from.
+ *
+ * @returns The field input.
+ */
+declare function getFieldInput(internalFieldStore: InternalFieldStore): unknown;
+//#endregion
+//#region src/core/field/get-field-store.d.ts
+/**
+ * Returns the field store at the specified path. See `getFieldStoreChain`
+ * for the resolution and throw semantics.
+ *
+ * @param internalFormStore The form store to traverse.
+ * @param path The path to the field store.
+ *
+ * @returns The field store.
+ */
+declare function getFieldStore(internalFormStore: InternalFormStore, path: Path): InternalFieldStore;
+//#endregion
+//#region src/core/field/walk-field-store.d.ts
+/**
+ * Walks through the field store and all nested children, calling the
+ * callback for each field store in depth-first order. The callback may
+ * return `true` to stop the walk early, in which case `walkFieldStore`
+ * returns `true` as well.
+ *
+ * The walk reads array `items` reactively, so a reactive caller subscribes
+ * to structural changes naturally. Imperative callers that must not
+ * subscribe should wrap the call in `untrack`.
+ *
+ * @param internalFieldStore The field store to walk.
+ * @param callback The callback to invoke for each field store. Return `true` to stop the walk early.
+ *
+ * @returns Whether the walk was stopped early by the callback.
+ */
+declare function walkFieldStore(internalFieldStore: InternalFieldStore, callback: (internalFieldStore: InternalFieldStore) => boolean | void): boolean;
+//#endregion
+//#region src/core/field/get-dirty-field-input.d.ts
+/**
+ * Returns only the dirty input of the field store. Arrays are treated as
+ * atomic and returned in full if any item is dirty, while object keys
+ * without a dirty descendant are omitted. Returns `undefined` if no
+ * descendant is dirty.
+ *
+ * Plugin state serializes THROUGH the field's own entry (the LOS-573
+ * envelope): a dirty estimate/amount-or-percent leaf emits
+ * kind envelope in place of its bare value — a mode flip
+ * with an unchanged value still produces a payload. Inside an emitted
+ * array every envelope leaf is wrapped COMPLETE, dirty or not: rows
+ * persist wholesale, and a bare value would clobber the persisted meta
+ * half of its envelope.
+ *
+ * @param internalFormStore The form store (plugin state lives here).
+ * @param internalFieldStore The field store to get dirty input from.
+ *
+ * @returns The dirty input, or `undefined` if no descendant is dirty.
+ */
+declare function getDirtyFieldInput(internalFormStore: InternalFormStore, internalFieldStore: InternalFieldStore): unknown;
+/**
+ * Wraps the envelope leaves of an emitted subtree value: rows and nested
+ * objects keep their shape, but every value leaf claimed by a plugin's
+ * `encodeValue` (estimate/amount-or-percent) is replaced with its COMPLETE
+ * envelope — the whole-array emission convention. The supplied value is
+ * never mutated.
+ */
+declare function encodeScopeValues(internalFormStore: InternalFormStore, internalFieldStore: InternalFieldStore | undefined, value: unknown): unknown;
+//#endregion
+//#region src/plugins/envelopes/key.d.ts
+/**
+ * The envelopes plugin's slot key. Other plugins read envelope state
+ * through this identity (the derivation plugin pins on `mode`), never
+ * through the envelopes implementation.
+ */
+declare const envelopesKey: FieldSlotKey<EnvelopeSlot>;
+//#endregion
+//#region src/plugins/derivation/row-scope.d.ts
+/**
+ * Returns the INNERMOST array-item object store containing the field at the
+ * given path, or `undefined` when the path is not inside an array row (a
+ * root-level field, or a field under a plain nested object).
+ *
+ * Tolerant on purpose: an unresolvable segment stops the walk and returns
+ * whatever row was found so far, so a stale path (a row removed mid-render)
+ * degrades to a scope lookup instead of throwing.
+ *
+ * @param internalFormStore The form store.
+ * @param path The path to the field.
+ *
+ * @returns The row store, or `undefined`.
+ */
+declare function findRowStore(internalFormStore: InternalFormStore, path: Path): InternalObjectStore | undefined;
+/**
+ * Resolves a row's CANONICAL record: the server row from `offFormValues`
+ * that carries the full column set (core columns the write model never
+ * holds, plus the server's pre-evaluated derived values). The row's
+ * collection is read by walking the row's own path into `offFormValues`
+ * (`["assets", 0]` → `offFormValues.assets`), and the row is matched by
+ * `id` — index is not identity, rows reorder.
+ *
+ * Reads signals (`offFormValues`, the row's `id` input), so callers get
+ * re-resolution for free inside a computed.
+ *
+ * @param internalFormStore The form store.
+ * @param rowStore The array-item object store.
+ *
+ * @returns The canonical row, or `undefined`.
+ */
+declare function canonicalRowOf(internalFormStore: InternalFormStore, rowStore: InternalObjectStore): Record<string, unknown> | undefined;
+/**
+ * Resolves a row-scope dependency once the LIVE row value is already in
+ * hand — the precedence a per-row formula evaluates in:
+ *
+ *   1. the root-record alias (`form.rootRecordAlias`) from `offFormValues` (it
+ *      wins outright: a row column named like the alias is never the
+ *      root record),
+ *   2. the live sibling value in the SAME row (an explicit `null` counts —
+ *      only `undefined` means "the row does not hold this"),
+ *   3. the canonical row's column.
+ *
+ * A row scope deliberately does NOT see root-level form fields or other
+ * `offFormValues` keys: a row's formula is evaluated against its own record
+ * plus the root record, exactly as the server evaluates it.
+ *
+ * @param internalFormStore The form store.
+ * @param rowStore The array-item object store the formula lives in.
+ * @param key The dependency identifier.
+ * @param formValue The live value the row holds for `key`, or `undefined`.
+ *
+ * @returns The resolved value, or `undefined`.
+ */
+declare function resolveRowFallback(internalFormStore: InternalFormStore, rowStore: InternalObjectStore, key: string, formValue: unknown): unknown;
+/**
+ * Resolves a single identifier in the scope of a row: the same precedence
+ * `buildDerivation` evaluates a row formula's dependencies in, with the
+ * live sibling read derived-aware (a sibling formula resolves through its
+ * own derived signal, so the read is always fresh; an erroring sibling
+ * resolves `undefined`, never a stale number).
+ *
+ * @param internalFormStore The form store.
+ * @param rowStore The array-item object store.
+ * @param key The identifier to resolve.
+ *
+ * @returns The resolved value, or `undefined`.
+ */
+declare function resolveRowScopeValue(internalFormStore: InternalFormStore, rowStore: InternalObjectStore, key: string): unknown;
+//#endregion
+export { type AmountOrPercentSlot, type BaggerState, type ChecksState, type ContainerInput, type DerivationSlot, type DerivationState, type EnvelopeSlot, type EnvelopeState, type EstimateSlot, type FieldElement, FieldSlotKey, type InternalArrayStore, type InternalBaseStore, type InternalFieldStore, type InternalFormStore, type InternalObjectStore, type InternalValueStore, type JsonischPlugin, type Listener, type PluginCtx, type PluginDriver, PluginKey, type ReadonlySignal, type Signal, type Tracker, type WireContract, type WireEnvelope, baggerKey, batch, canonicalRowOf, checksKey, computed, createSignal, createTracker, derivationKey, encodeFieldValue, encodeScopeValues, envelopesKey, fieldPluginDirty, findRowStore, focusFieldElement, getDirtyFieldInput, getFieldBool, getFieldInput, getFieldStore, getListener, hasPluginDirtyField, internalOf, pluginsDirty, resolveRowFallback, resolveRowScopeValue, untrack, unwrapLeafInput, validateFormInput, visibilityKey, walkFieldStore, withListener };

package/dist/plugin/index.js

@@ -0,0 +1,4 @@
+import { A as unwrapLeafInput, B as getFieldBool, D as fieldPluginDirty, E as encodeFieldValue, F as createTracker, I as getListener, L as untrack, M as batch, N as computed, O as hasPluginDirtyField, P as createSignal, R as withListener, V as walkFieldStore, a as getFieldStore, i as focusFieldElement, k as pluginsDirty, n as validateFormInput, r as getFieldInput, t as internalOf } from "../form-ref-BEri3JKv.js";
+import { D as FieldSlotKey, E as envelopesKey, H as getDirtyFieldInput, O as PluginKey, T as derivationKey, V as encodeScopeValues, _ as resolveRowFallback, a as checksKey, f as visibilityKey, g as findRowStore, h as canonicalRowOf, s as baggerKey, v as resolveRowScopeValue } from "../plugin-Qka-vaO1.js";
+
+export { FieldSlotKey, PluginKey, baggerKey, batch, canonicalRowOf, checksKey, computed, createSignal, createTracker, derivationKey, encodeFieldValue, encodeScopeValues, envelopesKey, fieldPluginDirty, findRowStore, focusFieldElement, getDirtyFieldInput, getFieldBool, getFieldInput, getFieldStore, getListener, hasPluginDirtyField, internalOf, pluginsDirty, resolveRowFallback, resolveRowScopeValue, untrack, unwrapLeafInput, validateFormInput, visibilityKey, walkFieldStore, withListener };