@elaraai/east-ui 1.0.39 → 1.0.41

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

@@ -0,0 +1,324 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * ValueTree types — the editable value-driven tree (#360).
+ *
+ * A ValueTree materializes ANY East value into a fixed recursive node IR
+ * at factory time (the renderer never sees the host type): structs,
+ * arrays, string-keyed dicts, options and variants become branch nodes;
+ * primitive leaves carry their typed value for leaf-type-aware editing;
+ * everything else (sets, blobs, vectors, matrices, refs, functions,
+ * beyond-depth recursion) renders as a printed read-only `opaque` node.
+ *
+ * Edits report through typed callbacks over {@link ValueTreePathType}
+ * paths — the host owns the data and reconciles (the Reactive
+ * re-materialization pattern every collection uses).
+ */
+import { ArrayType, AsyncFunctionType, BooleanType, DateTimeType, FloatType, IntegerType, NullType, OptionType, RecursiveType, StringType, StructType, VariantType } from "@elaraai/east";
+/**
+ * One step of a node path.
+ *
+ * @property append - Append a new element to the array at the path so far
+ *   (terminal step of array `onInsert` paths; disambiguates an array
+ *   append inside a dict from a dict key insert)
+ * @property field - Struct field name
+ * @property index - Array element index
+ * @property key - Dict entry key (an existing entry mid-path; the NEW key
+ *   as the terminal step of dict `onInsert` paths)
+ * @property some - Descend into an option's `some` payload
+ * @property tag - Descend into a variant's active payload
+ */
+export declare const ValueTreeStepType: VariantType<{
+    /** Append to the array at the path so far (terminal `onInsert` step) */
+    readonly append: NullType;
+    /** Struct field name */
+    readonly field: StringType;
+    /** Array element index */
+    readonly index: IntegerType;
+    /** Dict entry key */
+    readonly key: StringType;
+    /** Descend into an option's `some` payload */
+    readonly some: NullType;
+    /** Descend into a variant's active payload */
+    readonly tag: NullType;
+}>;
+/**
+ * Type representing one path step.
+ */
+export type ValueTreeStepType = typeof ValueTreeStepType;
+/**
+ * A node path — root-to-node steps.
+ */
+export declare const ValueTreePathType: ArrayType<VariantType<{
+    /** Append to the array at the path so far (terminal `onInsert` step) */
+    readonly append: NullType;
+    /** Struct field name */
+    readonly field: StringType;
+    /** Array element index */
+    readonly index: IntegerType;
+    /** Dict entry key */
+    readonly key: StringType;
+    /** Descend into an option's `some` payload */
+    readonly some: NullType;
+    /** Descend into a variant's active payload */
+    readonly tag: NullType;
+}>>;
+/**
+ * Type representing a node path.
+ */
+export type ValueTreePathType = typeof ValueTreePathType;
+/**
+ * A primitive leaf value — both the node payload (current value) and the
+ * `onEdit` payload (new value), so editors and edits share one shape.
+ *
+ * @property string - String leaf
+ * @property integer - Integer leaf
+ * @property float - Float leaf
+ * @property boolean - Boolean leaf
+ * @property datetime - DateTime leaf
+ * @property null - Null leaf (display-only)
+ */
+export declare const ValueTreeLeafType: VariantType<{
+    /** String leaf */
+    readonly string: StringType;
+    /** Integer leaf */
+    readonly integer: IntegerType;
+    /** Float leaf */
+    readonly float: FloatType;
+    /** Boolean leaf */
+    readonly boolean: BooleanType;
+    /** DateTime leaf */
+    readonly datetime: DateTimeType;
+    /** Null leaf (display-only) */
+    readonly null: NullType;
+}>;
+/**
+ * Type representing a primitive leaf value.
+ */
+export type ValueTreeLeafType = typeof ValueTreeLeafType;
+/**
+ * The materialized value tree.
+ *
+ * @property struct - Named fields
+ * @property array - Ordered elements (insert/remove targets)
+ * @property dict - Keyed entries; `editable` is true only for
+ *   string-keyed dicts (other key types are browsable read-only — their
+ *   printed keys cannot round-trip through path steps)
+ * @property option - `some` payload or empty (toggled via `onTag` "some"/"none")
+ * @property variant - Active tag + all tags (switched via `onTag`) + payload
+ * @property leaf - Primitive value (edited via `onEdit`)
+ * @property opaque - Summarized read-only value (sets, blobs, vectors,
+ *   matrices, refs, functions, beyond-depth recursion)
+ */
+export declare const ValueTreeNodeType: RecursiveType<VariantType<{
+    /** Named fields */
+    readonly struct: StructType<{
+        readonly fields: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly node: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+    }>;
+    /** Ordered elements */
+    readonly array: StructType<{
+        readonly items: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+    }>;
+    /** Keyed entries (editable only when string-keyed) */
+    readonly dict: StructType<{
+        readonly entries: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly node: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly editable: BooleanType;
+    }>;
+    /** `some` payload or empty */
+    readonly option: StructType<{
+        readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+    }>;
+    /** Active tag + all tags + payload */
+    readonly variant: StructType<{
+        readonly tag: StringType;
+        readonly tags: ArrayType<StringType>;
+        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+    }>;
+    /** Primitive value */
+    readonly leaf: VariantType<{
+        /** String leaf */
+        readonly string: StringType;
+        /** Integer leaf */
+        readonly integer: IntegerType;
+        /** Float leaf */
+        readonly float: FloatType;
+        /** Boolean leaf */
+        readonly boolean: BooleanType;
+        /** DateTime leaf */
+        readonly datetime: DateTimeType;
+        /** Null leaf (display-only) */
+        readonly null: NullType;
+    }>;
+    /** Printed read-only value */
+    readonly opaque: StringType;
+}>>;
+/**
+ * Type representing a materialized value-tree node.
+ */
+export type ValueTreeNodeType = typeof ValueTreeNodeType;
+/**
+ * Style configuration for the ValueTree container.
+ *
+ * @property height - Pinned height (CSS length; rows virtualize within)
+ * @property maxHeight - Height cap (content-sized up to it, then scrolls)
+ */
+export declare const ValueTreeStyleType: StructType<{
+    readonly height: OptionType<StringType>;
+    readonly maxHeight: OptionType<StringType>;
+}>;
+/**
+ * Type representing the ValueTree style structure.
+ */
+export type ValueTreeStyleType = typeof ValueTreeStyleType;
+/**
+ * The full ValueTree payload — the `component.ts` variant's struct; use
+ * for `ValueTypeOf<typeof ValueTree.Types.Root>` in renderers and
+ * assertions.
+ *
+ * Callback slots are ASYNC function types: handlers routinely write
+ * State (an async platform effect), and a synchronous function is a
+ * subtype of its async counterpart — so both fit.
+ *
+ * @property root - The materialized node tree
+ * @property onEdit - Leaf edit callback (path + new leaf value)
+ * @property onInsert - Append/insert callback (array/dict node path)
+ * @property onRemove - Remove callback (element/entry path)
+ * @property onTag - Variant tag switch / option toggle callback
+ * @property style - Layout style
+ */
+export declare const ValueTreeRootType: StructType<{
+    readonly root: RecursiveType<VariantType<{
+        /** Named fields */
+        readonly struct: StructType<{
+            readonly fields: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly node: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>;
+        /** Ordered elements */
+        readonly array: StructType<{
+            readonly items: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+        }>;
+        /** Keyed entries (editable only when string-keyed) */
+        readonly dict: StructType<{
+            readonly entries: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly node: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly editable: BooleanType;
+        }>;
+        /** `some` payload or empty */
+        readonly option: StructType<{
+            readonly value: OptionType<import("@elaraai/east").RecursiveTypeMarker>;
+        }>;
+        /** Active tag + all tags + payload */
+        readonly variant: StructType<{
+            readonly tag: StringType;
+            readonly tags: ArrayType<StringType>;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        /** Primitive value */
+        readonly leaf: VariantType<{
+            /** String leaf */
+            readonly string: StringType;
+            /** Integer leaf */
+            readonly integer: IntegerType;
+            /** Float leaf */
+            readonly float: FloatType;
+            /** Boolean leaf */
+            readonly boolean: BooleanType;
+            /** DateTime leaf */
+            readonly datetime: DateTimeType;
+            /** Null leaf (display-only) */
+            readonly null: NullType;
+        }>;
+        /** Printed read-only value */
+        readonly opaque: StringType;
+    }>>;
+    readonly onEdit: OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+        /** Append to the array at the path so far (terminal `onInsert` step) */
+        readonly append: NullType;
+        /** Struct field name */
+        readonly field: StringType;
+        /** Array element index */
+        readonly index: IntegerType;
+        /** Dict entry key */
+        readonly key: StringType;
+        /** Descend into an option's `some` payload */
+        readonly some: NullType;
+        /** Descend into a variant's active payload */
+        readonly tag: NullType;
+    }>>, VariantType<{
+        /** String leaf */
+        readonly string: StringType;
+        /** Integer leaf */
+        readonly integer: IntegerType;
+        /** Float leaf */
+        readonly float: FloatType;
+        /** Boolean leaf */
+        readonly boolean: BooleanType;
+        /** DateTime leaf */
+        readonly datetime: DateTimeType;
+        /** Null leaf (display-only) */
+        readonly null: NullType;
+    }>], NullType>>;
+    readonly onInsert: OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+        /** Append to the array at the path so far (terminal `onInsert` step) */
+        readonly append: NullType;
+        /** Struct field name */
+        readonly field: StringType;
+        /** Array element index */
+        readonly index: IntegerType;
+        /** Dict entry key */
+        readonly key: StringType;
+        /** Descend into an option's `some` payload */
+        readonly some: NullType;
+        /** Descend into a variant's active payload */
+        readonly tag: NullType;
+    }>>], NullType>>;
+    readonly onRemove: OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+        /** Append to the array at the path so far (terminal `onInsert` step) */
+        readonly append: NullType;
+        /** Struct field name */
+        readonly field: StringType;
+        /** Array element index */
+        readonly index: IntegerType;
+        /** Dict entry key */
+        readonly key: StringType;
+        /** Descend into an option's `some` payload */
+        readonly some: NullType;
+        /** Descend into a variant's active payload */
+        readonly tag: NullType;
+    }>>], NullType>>;
+    readonly onTag: OptionType<AsyncFunctionType<[ArrayType<VariantType<{
+        /** Append to the array at the path so far (terminal `onInsert` step) */
+        readonly append: NullType;
+        /** Struct field name */
+        readonly field: StringType;
+        /** Array element index */
+        readonly index: IntegerType;
+        /** Dict entry key */
+        readonly key: StringType;
+        /** Descend into an option's `some` payload */
+        readonly some: NullType;
+        /** Descend into a variant's active payload */
+        readonly tag: NullType;
+    }>>, StringType], NullType>>;
+    readonly style: OptionType<StructType<{
+        readonly height: OptionType<StringType>;
+        readonly maxHeight: OptionType<StringType>;
+    }>>;
+}>;
+/**
+ * Type representing the full ValueTree payload.
+ */
+export type ValueTreeRootType = typeof ValueTreeRootType;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/collections/value-tree/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACH,SAAS,EACT,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,SAAS,EACT,WAAW,EACX,QAAQ,EACR,UAAU,EACV,aAAa,EACb,UAAU,EACV,UAAU,EACV,WAAW,EACd,MAAM,eAAe,CAAC;AAMvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB;IAC1B,wEAAwE;;IAExE,wBAAwB;;IAExB,0BAA0B;;IAE1B,qBAAqB;;IAErB,8CAA8C;;IAE9C,8CAA8C;;EAEhD,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAtB1B,wEAAwE;;IAExE,wBAAwB;;IAExB,0BAA0B;;IAE1B,qBAAqB;;IAErB,8CAA8C;;IAE9C,8CAA8C;;GAYW,CAAC;AAE9D;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAMzD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;IAC1B,kBAAkB;;IAElB,mBAAmB;;IAEnB,iBAAiB;;IAEjB,mBAAmB;;IAEnB,oBAAoB;;IAEpB,+BAA+B;;EAEjC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAMzD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB;IAC1B,mBAAmB;;;;;;;IAInB,uBAAuB;;;;IAIvB,sDAAsD;;;;;;;;IAKtD,8BAA8B;;;;IAI9B,sCAAsC;;;;;;IAMtC,sBAAsB;;QA7DtB,kBAAkB;;QAElB,mBAAmB;;QAEnB,iBAAiB;;QAEjB,mBAAmB;;QAEnB,oBAAoB;;QAEpB,+BAA+B;;;IAqD/B,8BAA8B;;GAE/B,CAAC;AAEJ;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAMzD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;EAG7B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC;AAM3D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB;;QA1E1B,mBAAmB;;;;;;;QAInB,uBAAuB;;;;QAIvB,sDAAsD;;;;;;;;QAKtD,8BAA8B;;;;QAI9B,sCAAsC;;;;;;QAMtC,sBAAsB;;YA7DtB,kBAAkB;;YAElB,mBAAmB;;YAEnB,iBAAiB;;YAEjB,mBAAmB;;YAEnB,oBAAoB;;YAEpB,+BAA+B;;;QAqD/B,8BAA8B;;;;QA5G9B,wEAAwE;;QAExE,wBAAwB;;QAExB,0BAA0B;;QAE1B,qBAAqB;;QAErB,8CAA8C;;QAE9C,8CAA8C;;;QAmC9C,kBAAkB;;QAElB,mBAAmB;;QAEnB,iBAAiB;;QAEjB,mBAAmB;;QAEnB,oBAAoB;;QAEpB,+BAA+B;;;;QAvD/B,wEAAwE;;QAExE,wBAAwB;;QAExB,0BAA0B;;QAE1B,qBAAqB;;QAErB,8CAA8C;;QAE9C,8CAA8C;;;;QAV9C,wEAAwE;;QAExE,wBAAwB;;QAExB,0BAA0B;;QAE1B,qBAAqB;;QAErB,8CAA8C;;QAE9C,8CAA8C;;;;QAV9C,wEAAwE;;QAExE,wBAAwB;;QAExB,0BAA0B;;QAE1B,qBAAqB;;QAErB,8CAA8C;;QAE9C,8CAA8C;;;;;;;EA0JhD,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC"}

package/dist/src/collections/value-tree/types.js

@@ -0,0 +1,168 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * ValueTree types — the editable value-driven tree (#360).
+ *
+ * A ValueTree materializes ANY East value into a fixed recursive node IR
+ * at factory time (the renderer never sees the host type): structs,
+ * arrays, string-keyed dicts, options and variants become branch nodes;
+ * primitive leaves carry their typed value for leaf-type-aware editing;
+ * everything else (sets, blobs, vectors, matrices, refs, functions,
+ * beyond-depth recursion) renders as a printed read-only `opaque` node.
+ *
+ * Edits report through typed callbacks over {@link ValueTreePathType}
+ * paths — the host owns the data and reconciles (the Reactive
+ * re-materialization pattern every collection uses).
+ */
+import { ArrayType, AsyncFunctionType, BooleanType, DateTimeType, FloatType, IntegerType, NullType, OptionType, RecursiveType, StringType, StructType, VariantType, } from "@elaraai/east";
+// ============================================================================
+// Paths
+// ============================================================================
+/**
+ * One step of a node path.
+ *
+ * @property append - Append a new element to the array at the path so far
+ *   (terminal step of array `onInsert` paths; disambiguates an array
+ *   append inside a dict from a dict key insert)
+ * @property field - Struct field name
+ * @property index - Array element index
+ * @property key - Dict entry key (an existing entry mid-path; the NEW key
+ *   as the terminal step of dict `onInsert` paths)
+ * @property some - Descend into an option's `some` payload
+ * @property tag - Descend into a variant's active payload
+ */
+export const ValueTreeStepType = VariantType({
+    /** Append to the array at the path so far (terminal `onInsert` step) */
+    append: NullType,
+    /** Struct field name */
+    field: StringType,
+    /** Array element index */
+    index: IntegerType,
+    /** Dict entry key */
+    key: StringType,
+    /** Descend into an option's `some` payload */
+    some: NullType,
+    /** Descend into a variant's active payload */
+    tag: NullType,
+});
+/**
+ * A node path — root-to-node steps.
+ */
+export const ValueTreePathType = ArrayType(ValueTreeStepType);
+// ============================================================================
+// Leaves
+// ============================================================================
+/**
+ * A primitive leaf value — both the node payload (current value) and the
+ * `onEdit` payload (new value), so editors and edits share one shape.
+ *
+ * @property string - String leaf
+ * @property integer - Integer leaf
+ * @property float - Float leaf
+ * @property boolean - Boolean leaf
+ * @property datetime - DateTime leaf
+ * @property null - Null leaf (display-only)
+ */
+export const ValueTreeLeafType = VariantType({
+    /** String leaf */
+    string: StringType,
+    /** Integer leaf */
+    integer: IntegerType,
+    /** Float leaf */
+    float: FloatType,
+    /** Boolean leaf */
+    boolean: BooleanType,
+    /** DateTime leaf */
+    datetime: DateTimeType,
+    /** Null leaf (display-only) */
+    null: NullType,
+});
+// ============================================================================
+// Nodes
+// ============================================================================
+/**
+ * The materialized value tree.
+ *
+ * @property struct - Named fields
+ * @property array - Ordered elements (insert/remove targets)
+ * @property dict - Keyed entries; `editable` is true only for
+ *   string-keyed dicts (other key types are browsable read-only — their
+ *   printed keys cannot round-trip through path steps)
+ * @property option - `some` payload or empty (toggled via `onTag` "some"/"none")
+ * @property variant - Active tag + all tags (switched via `onTag`) + payload
+ * @property leaf - Primitive value (edited via `onEdit`)
+ * @property opaque - Summarized read-only value (sets, blobs, vectors,
+ *   matrices, refs, functions, beyond-depth recursion)
+ */
+export const ValueTreeNodeType = RecursiveType(node => VariantType({
+    /** Named fields */
+    struct: StructType({
+        fields: ArrayType(StructType({ name: StringType, node })),
+    }),
+    /** Ordered elements */
+    array: StructType({
+        items: ArrayType(node),
+    }),
+    /** Keyed entries (editable only when string-keyed) */
+    dict: StructType({
+        entries: ArrayType(StructType({ key: StringType, node })),
+        editable: BooleanType,
+    }),
+    /** `some` payload or empty */
+    option: StructType({
+        value: OptionType(node),
+    }),
+    /** Active tag + all tags + payload */
+    variant: StructType({
+        tag: StringType,
+        tags: ArrayType(StringType),
+        value: node,
+    }),
+    /** Primitive value */
+    leaf: ValueTreeLeafType,
+    /** Printed read-only value */
+    opaque: StringType,
+}));
+// ============================================================================
+// Style
+// ============================================================================
+/**
+ * Style configuration for the ValueTree container.
+ *
+ * @property height - Pinned height (CSS length; rows virtualize within)
+ * @property maxHeight - Height cap (content-sized up to it, then scrolls)
+ */
+export const ValueTreeStyleType = StructType({
+    height: OptionType(StringType),
+    maxHeight: OptionType(StringType),
+});
+// ============================================================================
+// Root payload
+// ============================================================================
+/**
+ * The full ValueTree payload — the `component.ts` variant's struct; use
+ * for `ValueTypeOf<typeof ValueTree.Types.Root>` in renderers and
+ * assertions.
+ *
+ * Callback slots are ASYNC function types: handlers routinely write
+ * State (an async platform effect), and a synchronous function is a
+ * subtype of its async counterpart — so both fit.
+ *
+ * @property root - The materialized node tree
+ * @property onEdit - Leaf edit callback (path + new leaf value)
+ * @property onInsert - Append/insert callback (array/dict node path)
+ * @property onRemove - Remove callback (element/entry path)
+ * @property onTag - Variant tag switch / option toggle callback
+ * @property style - Layout style
+ */
+export const ValueTreeRootType = StructType({
+    root: ValueTreeNodeType,
+    onEdit: OptionType(AsyncFunctionType([ValueTreePathType, ValueTreeLeafType], NullType)),
+    onInsert: OptionType(AsyncFunctionType([ValueTreePathType], NullType)),
+    onRemove: OptionType(AsyncFunctionType([ValueTreePathType], NullType)),
+    onTag: OptionType(AsyncFunctionType([ValueTreePathType, StringType], NullType)),
+    style: OptionType(ValueTreeStyleType),
+});
+//# sourceMappingURL=types.js.map

package/dist/src/collections/value-tree/types.js.map

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