@elaraai/east-ui 1.0.39 → 1.0.41

package/dist/src/collections/value-tree/index.d.ts

@@ -0,0 +1,380 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * ValueTree — the editable value-driven tree (#360).
+ *
+ * `ValueTree.Root(value, opts)` walks the STATIC East type of `value` at
+ * authoring time and materializes it into the fixed recursive
+ * {@link ValueTreeNodeType} IR — automatic tree formation from ANY East
+ * type, leaf-type-aware editing, and compound/collection editing
+ * (add/remove array rows and dict entries, variant tag switching,
+ * option toggling).
+ *
+ * Two edit surfaces, one contract:
+ *
+ * - **Value handlers** (the default): `onUpdate` receives the whole
+ *   value with the edit applied; `at: [ValueTree.at(Type, p => …, fn)]`
+ *   scopes receive just the rebuilt SUBTREE at their path. Every edit
+ *   dispatches to the deepest scope whose path prefixes the edit path
+ *   and bubbles up to `onUpdate` when no scope matches. The rebuild is
+ *   an authoring-time macro over the static type — hosts never
+ *   hand-apply paths.
+ * - **Path callbacks** (the escape hatch): `onEdit` / `onInsert` /
+ *   `onRemove` / `onTag` receive the raw typed path and payload for
+ *   hosts that own a finer-grained store. A raw callback overrides the
+ *   generated handler for its event.
+ *
+ * The host owns the data either way: write the new value and let the
+ * Reactive re-materialization refresh the tree (the same contract as
+ * every collection surface).
+ */
+import { type EastType, type ExprType, type SubtypeExprOrValue, type ValueTypeOf, ArrayType, type AsyncFunctionType, type DictType, Expr, FunctionType, NullType, type RecursiveType, StringType, StructType, type VariantType } from "@elaraai/east";
+import { UIComponentType } from "../../component.js";
+import { ValueTreePathType, ValueTreeLeafType } from "./types.js";
+export { ValueTreeStepType, ValueTreePathType, ValueTreeLeafType, ValueTreeNodeType, ValueTreeStyleType, ValueTreeRootType, } from "./types.js";
+import { materialize, applyEdit } from "./materialize.js";
+export { materialize, applyEdit, type ValueTreeNodeValue, type ValueTreeLeafValue, type ValueTreeStepValue, type ValueTreeEditOp, } from "./materialize.js";
+/** One recorded step of a scope path (host-side; mirrors the editable
+ *  subset of {@link ValueTreeStepType}). */
+export type ValueTreeScopeStep = {
+    readonly kind: "field";
+    readonly name: string;
+} | {
+    readonly kind: "index";
+    readonly index: bigint;
+} | {
+    readonly kind: "key";
+    readonly key: string;
+} | {
+    readonly kind: "some";
+};
+/**
+ * A scoped subtree handler built by {@link ValueTree.at} — dispatched
+ * when an edit lands at or below its path (deepest scope wins;
+ * unmatched edits bubble to the root `onUpdate`).
+ */
+export interface ValueTreeScope {
+    /** @internal Recorded path steps from the root. */
+    readonly steps: readonly ValueTreeScopeStep[];
+    /** @internal The subtree's East type at the recorded path. */
+    readonly subtype: EastType;
+    /** @internal The user's subtree handler (`FunctionType([S], Null)`). */
+    readonly handler: unknown;
+}
+/**
+ * The typed path probe passed to {@link ValueTree.at} accessors.
+ * Navigation is structural over the value's static type: struct fields
+ * are properties, `item(i)` addresses an array element, `entry(k)` a
+ * dict entry, and `some()` an option's payload. RecursiveType wrappers
+ * are transparent.
+ *
+ * @typeParam T - The East type at this probe position
+ */
+export type ValueTreeProbe<T> = T extends RecursiveType<infer U> ? ValueTreeProbe<U> : {
+    readonly __vt?: T;
+} & (T extends StructType<infer F> ? {
+    readonly [K in keyof F]: ValueTreeProbe<F[K]>;
+} : unknown) & (T extends ArrayType<infer U> ? {
+    item(index: number | bigint): ValueTreeProbe<U>;
+} : unknown) & (T extends DictType<StringType, infer V> ? {
+    entry(key: string): ValueTreeProbe<V>;
+} : unknown) & (T extends VariantType<{
+    none: NullType;
+    some: infer U;
+}> ? {
+    some(): ValueTreeProbe<U>;
+} : unknown);
+/**
+ * Builds a scoped subtree handler for {@link ValueTree.Root}'s `at`
+ * option: navigate the root type with the typed probe, and receive the
+ * rebuilt SUBTREE at that path whenever an edit lands inside it.
+ *
+ * @typeParam T - The root value's East type
+ * @typeParam S - The subtree type at the accessor's path (inferred)
+ * @param root - The root value's East type (drives probe navigation)
+ * @param path - Accessor over the typed probe selecting the subtree
+ * @param onUpdate - Handler receiving the rebuilt subtree value
+ * @returns An opaque scope for the `at` option
+ *
+ * @example
+ * ```ts
+ * import { East, DictType, StringType, FloatType, NullType } from "@elaraai/east";
+ * import { ValueTree } from "@elaraai/east-ui";
+ *
+ * const RatesType = DictType(StringType, FloatType);
+ * const scope = ValueTree.at(RatesType, p => p.entry("base"),
+ *     East.function([FloatType], NullType, (_$, _next) => null));
+ * ```
+ */
+declare function scopeAt<T extends EastType, S extends EastType>(root: T, path: (probe: ValueTreeProbe<T>) => {
+    readonly __vt?: S;
+}, onUpdate: SubtypeExprOrValue<FunctionType<[S], NullType>> | SubtypeExprOrValue<AsyncFunctionType<[S], NullType>>): ValueTreeScope;
+/**
+ * Options for {@link ValueTree.Root}.
+ *
+ * @typeParam T - The value's East type (drives the handler signatures)
+ *
+ * @property onUpdate - Whole-value handler: every edit arrives as the
+ *   fully rebuilt value (the default sink when no `at` scope matches)
+ * @property at - Scoped subtree handlers ({@link ValueTree.at}); the
+ *   deepest scope whose path prefixes the edit path receives the rebuilt
+ *   subtree, unmatched edits bubble to `onUpdate`
+ * @property onEdit - RAW leaf edit callback: the node path + the new leaf
+ *   value (overrides the generated handler for leaf edits)
+ * @property onInsert - RAW append/insert callback: array paths end with an
+ *   `append` step, dict paths with the new `key` step
+ * @property onRemove - RAW remove callback with the element/entry path
+ * @property onTag - RAW variant tag switch (and option toggle:
+ *   "some"/"none") with the node path and the new tag
+ * @property style - Layout style (height / maxHeight)
+ */
+export interface ValueTreeOptions<T extends EastType = EastType> {
+    /** Whole-value handler — receives the rebuilt value after every edit */
+    onUpdate?: SubtypeExprOrValue<FunctionType<[T], NullType>> | SubtypeExprOrValue<AsyncFunctionType<[T], NullType>>;
+    /** Scoped subtree handlers (deepest match wins, else `onUpdate`) */
+    at?: readonly ValueTreeScope[];
+    /** RAW leaf edit callback: node path + new leaf value */
+    onEdit?: SubtypeExprOrValue<FunctionType<[ValueTreePathType, ValueTreeLeafType], NullType>> | SubtypeExprOrValue<AsyncFunctionType<[ValueTreePathType, ValueTreeLeafType], NullType>>;
+    /** RAW append/insert callback (array `append` / dict new-`key` paths) */
+    onInsert?: SubtypeExprOrValue<FunctionType<[ValueTreePathType], NullType>> | SubtypeExprOrValue<AsyncFunctionType<[ValueTreePathType], NullType>>;
+    /** RAW remove callback with the element/entry path */
+    onRemove?: SubtypeExprOrValue<FunctionType<[ValueTreePathType], NullType>> | SubtypeExprOrValue<AsyncFunctionType<[ValueTreePathType], NullType>>;
+    /** RAW variant tag switch / option toggle callback */
+    onTag?: SubtypeExprOrValue<FunctionType<[ValueTreePathType, StringType], NullType>> | SubtypeExprOrValue<AsyncFunctionType<[ValueTreePathType, StringType], NullType>>;
+    /** Layout style (height / maxHeight) */
+    style?: {
+        /** Pinned height (CSS length; rows virtualize within) */
+        height?: SubtypeExprOrValue<StringType>;
+        /** Height cap (content-sized up to it, then scrolls) */
+        maxHeight?: SubtypeExprOrValue<StringType>;
+    };
+}
+/**
+ * Creates a ValueTree — the editable tree of any East value.
+ *
+ * @typeParam T - The value's East type (captured statically)
+ * @param value - The value to materialize (any East type)
+ * @param options - Value handlers, raw path callbacks + style
+ *   ({@link ValueTreeOptions})
+ * @returns An East expression of `UIComponentType`
+ *
+ * @example
+ * ```ts
+ * import { East, DictType, StringType, StructType, FloatType } from "@elaraai/east";
+ * import { ValueTree, UIComponentType } from "@elaraai/east-ui";
+ *
+ * const ConfigType = DictType(StringType, StructType({ rate: FloatType, label: StringType }));
+ * const view = East.function([ConfigType], UIComponentType, (_$, config) =>
+ *     ValueTree.Root(config),
+ * );
+ * ```
+ */
+declare function createValueTree<T extends EastType>(value: SubtypeExprOrValue<T> | Expr, options?: ValueTreeOptions<T>): ExprType<UIComponentType>;
+/**
+ * A host-side zero value for any East data type — the default payload
+ * for inserted elements, toggled options and switched variant cases.
+ *
+ * @param t - The East type to zero
+ * @returns The TypeScript `ValueTypeOf` zero value
+ * @throws When the type has no default (functions; recursion below the
+ *   top level)
+ *
+ * @remarks
+ * Delegates to east's {@link defaultValue} (option variants default to
+ * `none` — their sorted first case), unrolling a top-level
+ * RecursiveType wrapper first.
+ */
+declare function zeroValue<T extends EastType>(t: T): ValueTypeOf<T>;
+/**
+ * ValueTree component namespace.
+ *
+ * @remarks
+ * `ValueTree.Root(value, options)` materializes any East value into the
+ * editable tree; `ValueTree.at(Type, p => …, handler)` builds a scoped
+ * subtree handler for the `at` option; `ValueTree.zero(Type)` builds
+ * the host-side default element for raw `onInsert` handlers.
+ */
+export declare const ValueTree: {
+    /**
+     * Creates a ValueTree — the editable tree of any East value.
+     *
+     * @param value - The value to materialize (any East type)
+     * @param options - Value handlers, raw callbacks + style
+     *   ({@link ValueTreeOptions})
+     * @returns An East expression of `UIComponentType`
+     */
+    readonly Root: typeof createValueTree;
+    /**
+     * Builds a scoped subtree handler for the `at` option — the deepest
+     * scope whose path prefixes an edit's path receives the rebuilt
+     * subtree; unmatched edits bubble to `onUpdate`.
+     */
+    readonly at: typeof scopeAt;
+    /** Host-side zero value for any East type (for raw `onInsert` handlers). */
+    readonly zero: typeof zeroValue;
+    /**
+     * Host-side materializer — a DECODED value + its type into the node tree
+     * the renderer consumes (for callers holding a value, not an `Expr`; the
+     * East-side {@link ValueTree.Root} materializes an expression instead).
+     */
+    readonly materialize: typeof materialize;
+    /**
+     * Host-side edit application — apply one reported ValueTree edit (leaf /
+     * insert / remove / tag) to a decoded value, returning the new value.
+     */
+    readonly applyEdit: typeof applyEdit;
+    readonly Types: {
+        /** The full ValueTree payload. */
+        readonly Root: StructType<{
+            readonly root: RecursiveType<VariantType<{
+                readonly struct: StructType<{
+                    readonly fields: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly node: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                }>;
+                readonly array: StructType<{
+                    readonly items: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly dict: StructType<{
+                    readonly entries: ArrayType<StructType<{
+                        readonly key: StringType;
+                        readonly node: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly editable: import("@elaraai/east").BooleanType;
+                }>;
+                readonly option: StructType<{
+                    readonly value: import("@elaraai/east").OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+                }>;
+                readonly variant: StructType<{
+                    readonly tag: StringType;
+                    readonly tags: ArrayType<StringType>;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly leaf: VariantType<{
+                    readonly string: StringType;
+                    readonly integer: import("@elaraai/east").IntegerType;
+                    readonly float: import("@elaraai/east").FloatType;
+                    readonly boolean: import("@elaraai/east").BooleanType;
+                    readonly datetime: import("@elaraai/east").DateTimeType;
+                    readonly null: NullType;
+                }>;
+                readonly opaque: StringType;
+            }>>;
+            readonly onEdit: import("@elaraai/east").OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+                readonly append: NullType;
+                readonly field: StringType;
+                readonly index: import("@elaraai/east").IntegerType;
+                readonly key: StringType;
+                readonly some: NullType;
+                readonly tag: NullType;
+            }>>, VariantType<{
+                readonly string: StringType;
+                readonly integer: import("@elaraai/east").IntegerType;
+                readonly float: import("@elaraai/east").FloatType;
+                readonly boolean: import("@elaraai/east").BooleanType;
+                readonly datetime: import("@elaraai/east").DateTimeType;
+                readonly null: NullType;
+            }>], NullType>>;
+            readonly onInsert: import("@elaraai/east").OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+                readonly append: NullType;
+                readonly field: StringType;
+                readonly index: import("@elaraai/east").IntegerType;
+                readonly key: StringType;
+                readonly some: NullType;
+                readonly tag: NullType;
+            }>>], NullType>>;
+            readonly onRemove: import("@elaraai/east").OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+                readonly append: NullType;
+                readonly field: StringType;
+                readonly index: import("@elaraai/east").IntegerType;
+                readonly key: StringType;
+                readonly some: NullType;
+                readonly tag: NullType;
+            }>>], NullType>>;
+            readonly onTag: import("@elaraai/east").OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+                readonly append: NullType;
+                readonly field: StringType;
+                readonly index: import("@elaraai/east").IntegerType;
+                readonly key: StringType;
+                readonly some: NullType;
+                readonly tag: NullType;
+            }>>, StringType], NullType>>;
+            readonly style: import("@elaraai/east").OptionType<StructType<{
+                readonly height: import("@elaraai/east").OptionType<StringType>;
+                readonly maxHeight: import("@elaraai/east").OptionType<StringType>;
+            }>>;
+        }>;
+        /** The materialized node tree. */
+        readonly Node: RecursiveType<VariantType<{
+            readonly struct: StructType<{
+                readonly fields: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly node: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+            }>;
+            readonly array: StructType<{
+                readonly items: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            }>;
+            readonly dict: StructType<{
+                readonly entries: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly node: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly editable: import("@elaraai/east").BooleanType;
+            }>;
+            readonly option: StructType<{
+                readonly value: import("@elaraai/east").OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+            }>;
+            readonly variant: StructType<{
+                readonly tag: StringType;
+                readonly tags: ArrayType<StringType>;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly leaf: VariantType<{
+                readonly string: StringType;
+                readonly integer: import("@elaraai/east").IntegerType;
+                readonly float: import("@elaraai/east").FloatType;
+                readonly boolean: import("@elaraai/east").BooleanType;
+                readonly datetime: import("@elaraai/east").DateTimeType;
+                readonly null: NullType;
+            }>;
+            readonly opaque: StringType;
+        }>>;
+        /** A node path. */
+        readonly Path: ArrayType<VariantType<{
+            readonly append: NullType;
+            readonly field: StringType;
+            readonly index: import("@elaraai/east").IntegerType;
+            readonly key: StringType;
+            readonly some: NullType;
+            readonly tag: NullType;
+        }>>;
+        /** One path step. */
+        readonly Step: VariantType<{
+            readonly append: NullType;
+            readonly field: StringType;
+            readonly index: import("@elaraai/east").IntegerType;
+            readonly key: StringType;
+            readonly some: NullType;
+            readonly tag: NullType;
+        }>;
+        /** A primitive leaf value / leaf edit. */
+        readonly Leaf: VariantType<{
+            readonly string: StringType;
+            readonly integer: import("@elaraai/east").IntegerType;
+            readonly float: import("@elaraai/east").FloatType;
+            readonly boolean: import("@elaraai/east").BooleanType;
+            readonly datetime: import("@elaraai/east").DateTimeType;
+            readonly null: NullType;
+        }>;
+        /** Container style. */
+        readonly Style: StructType<{
+            readonly height: import("@elaraai/east").OptionType<StringType>;
+            readonly maxHeight: import("@elaraai/east").OptionType<StringType>;
+        }>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/collections/value-tree/index.d.ts.map

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