@elaraai/e3-ui 1.0.0

package/CLA.md

@@ -0,0 +1,26 @@
+# Contributor License Agreement
+
+This Contributor License Agreement ("Agreement") is entered into between Elara AI Pty Ltd ("Company") and you (the "Contributor").
+
+## Grant of Copyright License
+
+You hereby grant to the Company and to recipients of software distributed by the Company a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, distribute, and use Your Contributions and such derivative works.
+
+## Grant of Patent License
+
+You hereby grant to the Company and to recipients of software distributed by the Company a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer Your Contributions.
+
+## Relicensing Rights
+
+You grant the Company the right to license Your Contributions under any license terms, including but not limited to commercial licenses, in addition to the open source license under which the project is distributed.
+
+## Your Representations
+
+You represent that:
+- You are legally entitled to grant the above licenses
+- Each of Your Contributions is Your original creation
+- Your Contribution submissions include complete details of any third-party license or other restriction of which you are aware
+
+## Agreement
+
+By signing this Agreement through CLA Assistant or by submitting a Contribution, you accept and agree to the terms of this Agreement.

package/CONTRIBUTING.md

@@ -0,0 +1,28 @@
+# Contributing to e3-ui
+
+Thank you for your interest in contributing! We welcome contributions from the community.
+
+## Contributor License Agreement (CLA)
+
+Before we can accept your contribution, you must sign our Contributor License Agreement (CLA). This agreement gives Elara AI Pty Ltd the right to use and relicense your contributions, including under commercial licenses, while you retain ownership of your contribution.
+
+**Why do we require a CLA?**
+This project is dual-licensed under AGPL-3.0 and commercial licenses. The CLA allows us to offer commercial licenses to users who wish to use this software in proprietary applications.
+
+### Signing the CLA
+
+When you submit your first pull request, the CLA Assistant bot will automatically comment on your PR with a link to sign the CLA electronically. It only takes a minute, and you'll only need to sign it once.
+
+## Contributing Process
+
+1. Fork the [east-workspace monorepo](https://github.com/elaraai/east-workspace)
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Commit your changes (`git commit -m 'Add amazing feature'`)
+5. Push to the branch (`git push origin feature/amazing-feature`)
+6. Open a Pull Request
+7. Sign the CLA when the bot prompts you
+
+## Questions?
+
+Contact us at support@elara.ai

package/LICENSE.md

@@ -0,0 +1,31 @@
+Copyright (c) 2025 Elara AI Pty Ltd
+
+# Dual License — AGPL-3.0 / Commercial
+
+This software is available under two licenses. You may choose which license applies to your use:
+
+## Option 1: AGPL-3.0 (Open Source)
+
+You may use, modify, and distribute this software under the terms of the GNU Affero General Public License v3.0.
+
+This requires that if you use this software in a network service, you must make your complete source code available under AGPL-3.0.
+
+Full text: https://www.gnu.org/licenses/agpl-3.0.html
+
+## Option 2: Commercial License
+
+If you wish to use this software without the source code disclosure requirements of AGPL-3.0, you must obtain a commercial license from Elara AI Pty Ltd.
+
+Contact: support@elara.ai
+
+## Contributions
+
+Contributions are welcome. By submitting a pull request, you agree to license your contribution under both AGPL-3.0 and our commercial license terms.
+
+## Governing Law
+
+This license is governed by the laws of New South Wales, Australia.
+
+---
+
+*Elara AI Pty Ltd*

package/README.md

@@ -0,0 +1,149 @@
+# East UI
+
+> UI component library for the East language
+
+[![License](https://img.shields.io/badge/license-AGPL--3.0-blue.svg)](LICENSE.md)
+[![Node Version](https://img.shields.io/badge/node-%3E%3D22.0.0-brightgreen.svg)](https://nodejs.org)
+
+**East UI** provides typed UI component definitions for the [East language](https://github.com/elaraai/east-workspace/tree/main/libs/east). Components return data structures describing UI layouts rather than rendering directly, enabling portability across different rendering environments.
+
+## Packages
+
+| Package | Description | npm |
+|---------|-------------|-----|
+| [@elaraai/east-ui](packages/east-ui) | Core UI component definitions | [![npm](https://img.shields.io/npm/v/@elaraai/east-ui)](https://www.npmjs.com/package/@elaraai/east-ui) |
+| [@elaraai/east-ui-components](packages/east-ui-components) | React rendering with Chakra UI | [![npm](https://img.shields.io/npm/v/@elaraai/east-ui-components)](https://www.npmjs.com/package/@elaraai/east-ui-components) |
+| [east-ui-preview](packages/east-ui-extension) | VSCode extension for live preview | [Marketplace](https://marketplace.visualstudio.com/items?itemName=ElaraAI.east-ui-preview) |
+
+## Features
+
+- **Layout** - Box, Stack, Grid, Splitter, Separator
+- **Typography** - Text, Code, Heading, Link, Highlight, Mark, List, CodeBlock
+- **Buttons** - Button, IconButton with variants
+- **Forms** - Input, Select, Checkbox, Switch, Slider, Textarea, TagsInput, FileUpload
+- **Collections** - Table, DataList, TreeView
+- **Charts** - Area, Bar, Line, Pie, Radar, Scatter, Sparkline, BarList, BarSegment
+- **Display** - Badge, Tag, Avatar, Stat, Icon
+- **Feedback** - Alert, Progress
+- **Disclosure** - Accordion, Tabs, Carousel
+- **Overlays** - Dialog, Drawer, Popover, Tooltip, Menu, HoverCard, ToggleTip, ActionBar
+
+## Quick Start
+
+```bash
+npm install @elaraai/east-ui @elaraai/east
+```
+
+```typescript
+import { East } from "@elaraai/east";
+import { Stack, Text, Button, UIComponentType } from "@elaraai/east-ui";
+
+const MyComponent = East.function([], UIComponentType, () => {
+    return Stack.Root([
+        Text.Root("Hello, World!", { fontSize: "xl", fontWeight: "bold" }),
+        Button.Root("Click Me", { variant: "solid", colorPalette: "blue" }),
+    ], { gap: "4" });
+});
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build all packages
+npm run build
+
+# Run tests
+npm test
+
+# Run linter
+npm run lint
+```
+
+## Claude Code plugin
+
+The East ecosystem also ships a [Claude Code](https://claude.com/claude-code) plugin — East language skills, example search, and preemptive diagnostics for East code — installed separately from the `elaraai` marketplace:
+
+```text
+# Inside Claude Code
+/plugin marketplace add elaraai/east-workspace
+/plugin install east@elaraai
+```
+
+```bash
+# From a terminal
+claude plugin marketplace add elaraai/east-workspace
+claude plugin install east@elaraai
+```
+
+## License
+
+Dual-licensed:
+- **Open Source**: [AGPL-3.0](LICENSE.md) - Free for open source use
+- **Commercial**: Available for proprietary use - contact support@elara.ai
+
+
+<!-- Ecosystem — keep in sync with docs/snippets/ECOSYSTEM.md -->
+
+### Ecosystem
+
+- **[East](https://github.com/elaraai/east-workspace/tree/main/libs/east)**: Statically typed, expression-based language with serializable IR. Run portable logic across TypeScript, Python, C, and other runtimes.
+  - [@elaraai/east](https://www.npmjs.com/package/@elaraai/east): Core language SDK with type system, expressions, and reference JS compiler
+
+- **[East Node](https://github.com/elaraai/east-workspace/tree/main/libs/east-node)**: Node.js platform functions for I/O, databases, and system operations.
+  - [@elaraai/east-node-std](https://www.npmjs.com/package/@elaraai/east-node-std): Console, FileSystem, Fetch, Crypto, Time, Path, Random
+  - [@elaraai/east-node-io](https://www.npmjs.com/package/@elaraai/east-node-io): SQLite, PostgreSQL, MySQL, MongoDB, Redis, S3, FTP, SFTP, XLSX, XML, compression
+  - [@elaraai/east-node-cli](https://www.npmjs.com/package/@elaraai/east-node-cli): CLI for running East IR programs in Node.js
+
+- **[East C](https://github.com/elaraai/east-workspace/tree/main/libs/east-c)**: C11 native runtime for executing East IR. Tarballed for `linux-x64` and `linux-arm64`, attached to each GitHub Release.
+  - `east-c`: Core runtime — type system, IR interpreter, 200+ builtins, serialization (Beast2, JSON, CSV, East text)
+  - `east-c-std`: Console, FileSystem, Fetch, Crypto, Time, Path, Random
+  - `east-c-cli`: CLI for running East IR programs natively
+
+- **[East Python](https://github.com/elaraai/east-workspace/tree/main/libs/east-py)**: Python runtime, standard platform, I/O, and data-science platform functions. Published to PyPI.
+  - [east-py](https://pypi.org/project/east-py/): Core Python runtime — type system, IR compiler, 212+ builtins, Cython-accelerated hot paths
+  - [east-py-std](https://pypi.org/project/east-py-std/): Console, FileSystem, Fetch, Crypto, Time, Path, Random
+  - [east-py-io](https://pypi.org/project/east-py-io/): SQLite, PostgreSQL, MySQL, MongoDB, Redis, S3, FTP, SFTP, XLSX, XML, compression
+  - [east-py-cli](https://pypi.org/project/east-py-cli/): CLI for running East IR programs in Python
+  - [east-py-datascience](https://pypi.org/project/east-py-datascience/) (PyPI) + [@elaraai/east-py-datascience](https://www.npmjs.com/package/@elaraai/east-py-datascience) (npm): Optimization (MADS, Optuna, ALNS, GoogleOR), ML (XGBoost, LightGBM, NGBoost, PyTorch, Lightning, GP), Bayesian inference (PyMC), explainability (SHAP), conformal prediction (MAPIE)
+
+- **[East UI](https://github.com/elaraai/east-workspace/tree/main/libs/east-ui)**: Typed UI component definitions and React renderer, plus VS Code preview.
+  - [@elaraai/east-ui](https://www.npmjs.com/package/@elaraai/east-ui): 50+ typed UI components for layouts, forms, charts, tables, dialogs
+  - [@elaraai/east-ui-components](https://www.npmjs.com/package/@elaraai/east-ui-components): React renderer with Chakra UI v3 styling
+  - [@elaraai/e3-ui](https://www.npmjs.com/package/@elaraai/e3-ui): e3 + UI bridge — Data bindings, `e3.ui()` task, manifest
+  - [@elaraai/e3-ui-components](https://www.npmjs.com/package/@elaraai/e3-ui-components): React Query hooks and preview components for the e3 API
+  - [east-ui-preview](https://marketplace.visualstudio.com/items?itemName=ElaraAI.east-ui-preview): VS Code extension for live East UI component preview
+
+- **[e3 — East Execution Engine](https://github.com/elaraai/east-workspace/tree/main/libs/e3)**: Durable execution engine for running East pipelines at scale. Git-like content-addressable storage, automatic memoization, reactive dataflow, real-time monitoring.
+  - [@elaraai/e3](https://www.npmjs.com/package/@elaraai/e3): SDK for authoring e3 packages with typed tasks and pipelines
+  - [@elaraai/e3-core](https://www.npmjs.com/package/@elaraai/e3-core): Object store, dataflow orchestrator, execution state
+  - [@elaraai/e3-types](https://www.npmjs.com/package/@elaraai/e3-types): Shared type definitions for e3 packages
+  - [@elaraai/e3-cli](https://www.npmjs.com/package/@elaraai/e3-cli): `e3 repo`, `e3 package`, `e3 workspace`, `e3 start`, `e3 watch`, `e3 logs` commands
+  - [@elaraai/e3-api-client](https://www.npmjs.com/package/@elaraai/e3-api-client): HTTP client for remote e3 repositories
+  - [@elaraai/e3-api-server](https://www.npmjs.com/package/@elaraai/e3-api-server): REST API server for e3 repositories
+  - [@elaraai/e3-api-tests](https://www.npmjs.com/package/@elaraai/e3-api-tests): Shared API compliance test suites
+
+## Links
+
+- **Live Showcase**: [https://elaraai.github.io/east-ui/](https://elaraai.github.io/east-ui/)
+- **Website**: [https://elaraai.com/](https://elaraai.com/)
+- **East Repository**: [https://github.com/elaraai/east-workspace/tree/main/libs/east](https://github.com/elaraai/east-workspace/tree/main/libs/east)
+- **Issues**: [https://github.com/elaraai/east-workspace/issues](https://github.com/elaraai/east-workspace/issues)
+- **Email**: support@elara.ai
+
+
+<!-- About Elara — keep in sync with docs/snippets/ABOUT_ELARA.md -->
+
+## About Elara
+
+East is developed by [Elara AI Pty Ltd](https://elaraai.com/), an AI-powered platform that creates economic digital twins of businesses that optimize performance. Elara combines business objectives, decisions and data to help organizations make data-driven decisions across operations, purchasing, sales and customer engagement, and project and investment planning. East powers the computational layer of Elara solutions, enabling the expression of complex business logic and data in a simple, type-safe and portable language.
+
+---
+
+*Developed by [Elara AI Pty Ltd](https://elaraai.com/).*
+
+---
+
+*Developed by [Elara AI Pty Ltd](https://elaraai.com/) - Powering the computational layer of AI-driven business optimization.*

package/dist/src/buttons.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=buttons.d.ts.map

package/dist/src/buttons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buttons.d.ts","sourceRoot":"","sources":["../../src/buttons.ts"],"names":[],"mappings":""}

package/dist/src/buttons.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=buttons.js.map

package/dist/src/buttons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buttons.js","sourceRoot":"","sources":["../../src/buttons.ts"],"names":[],"mappings":""}

package/dist/src/data.d.ts

@@ -0,0 +1,241 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Reactive dataset binding for e3 UI tasks.
+ *
+ * @packageDocumentation
+ */
+import { NullType, BooleanType, FunctionType, StructType, VariantType, OptionType, type EastType, type ExprType } from '@elaraai/east';
+import { type TreePath } from '@elaraai/e3-types';
+/**
+ * The two operating modes for {@link Data.bind}.
+ *
+ * @property staged - Edits are buffered locally (in-memory + IndexedDB) and
+ *   only flushed on `commit()`. Use for editor flows where the user reviews
+ *   pending changes before publishing.
+ * @property direct - Every `write()` immediately mutates the destination
+ *   (the source dataset, or the patch dataset when `patch` is set). Use for
+ *   live shared cursors and other no-staging surfaces.
+ */
+export declare const DataBindModeType: VariantType<{
+    readonly staged: NullType;
+    readonly direct: NullType;
+}>;
+/** Type alias for {@link DataBindModeType}. */
+export type DataBindModeType = typeof DataBindModeType;
+/** String literal form of {@link DataBindModeType}. */
+export type DataBindModeLiteral = "staged" | "direct";
+/**
+ * Descriptor for a single binding the {@link Diff.Root} component displays.
+ *
+ * Every {@link Data.bind} call exposes this descriptor as its `binding`
+ * field, so callers can wire a Diff card via `Diff.Root({ bindings:
+ * [view.binding, ...] })` without re-spelling the source / patch paths.
+ *
+ * @property source - The dataset path of the source value the binding
+ *   reads from.
+ * @property patch - When the binding writes through a separate patch
+ *   dataset, this is its path. `none` means the binding writes directly to
+ *   the source on commit (or to the staging buffer in staged mode).
+ * @property mode - The binding's operating mode — see {@link DataBindModeType}.
+ */
+export declare const DiffBindingType: StructType<{
+    readonly source: import("@elaraai/east").ArrayType<VariantType<{
+        readonly field: import("@elaraai/east").StringType;
+    }>>;
+    readonly patch: OptionType<import("@elaraai/east").ArrayType<VariantType<{
+        readonly field: import("@elaraai/east").StringType;
+    }>>>;
+    readonly mode: VariantType<{
+        readonly staged: NullType;
+        readonly direct: NullType;
+    }>;
+}>;
+/** Type alias for {@link DiffBindingType}. */
+export type DiffBindingType = typeof DiffBindingType;
+/**
+ * The struct returned by every {@link Data.bind} call. Every field is
+ * present regardless of `mode` / `patch` — the per-mode semantics are
+ * captured in the property docs of {@link Data.bind}.
+ *
+ * @property read - Reactive accessor for the binding's view of the source.
+ * @property write - Update the binding (buffer in staged mode, dataset in
+ *   direct mode). Always returns null.
+ * @property writeAndStart - Like `write`, but kicks the workspace dataflow
+ *   so downstream tasks recompute. Only meaningful when `mode = "direct"`
+ *   and `patch` is absent — in other modes it falls back to `write`.
+ * @property source - Read the raw source value with no overlay applied.
+ * @property pending - True when there is an in-flight change waiting to be
+ *   committed. Always false in `mode = "direct"` without a `patch` dataset.
+ * @property commit - Resolve the in-flight change. The destination depends
+ *   on `mode` / `patch` — see {@link Data.bind} for the full matrix.
+ * @property discard - Drop the in-flight change.
+ * @property has - True iff the source dataset has a value.
+ * @property status - Per-dataset freshness signal — see
+ *   {@link DatasetStatusType}.
+ * @property binding - Descriptor for this binding — pass directly to
+ *   {@link Diff.Root}'s `bindings` array.
+ */
+export declare const DataBindHandleType: <T extends EastType | string>(t: T) => StructType<{
+    readonly read: FunctionType<[], T>;
+    readonly write: FunctionType<[T], NullType>;
+    readonly writeAndStart: FunctionType<[T], NullType>;
+    readonly source: FunctionType<[], T>;
+    readonly pending: FunctionType<[], BooleanType>;
+    readonly commit: FunctionType<[], NullType>;
+    readonly discard: FunctionType<[], NullType>;
+    readonly has: FunctionType<[], BooleanType>;
+    readonly status: FunctionType<[], VariantType<{
+        readonly unset: NullType;
+        readonly stale: NullType;
+        readonly 'up-to-date': NullType;
+    }>>;
+    readonly binding: StructType<{
+        readonly source: import("@elaraai/east").ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<import("@elaraai/east").ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>;
+}>;
+/**
+ * The underlying `Data.bind` platform-function definition. End-users
+ * should call {@link Data.bind} (the typed factory in this module);
+ * runtime implementations register against this raw definition via
+ * `bindPlatformFn.implement(...)`.
+ */
+export declare const bindPlatformFn: import("@elaraai/east").GenericPlatformDefinition<readonly ["T"], readonly [import("@elaraai/east").ArrayType<VariantType<{
+    readonly field: import("@elaraai/east").StringType;
+}>>, OptionType<import("@elaraai/east").ArrayType<VariantType<{
+    readonly field: import("@elaraai/east").StringType;
+}>>>, VariantType<{
+    readonly staged: NullType;
+    readonly direct: NullType;
+}>], StructType<{
+    readonly read: FunctionType<[], "T">;
+    readonly write: FunctionType<["T"], NullType>;
+    readonly writeAndStart: FunctionType<["T"], NullType>;
+    readonly source: FunctionType<[], "T">;
+    readonly pending: FunctionType<[], BooleanType>;
+    readonly commit: FunctionType<[], NullType>;
+    readonly discard: FunctionType<[], NullType>;
+    readonly has: FunctionType<[], BooleanType>;
+    readonly status: FunctionType<[], VariantType<{
+        readonly unset: NullType;
+        readonly stale: NullType;
+        readonly 'up-to-date': NullType;
+    }>>;
+    readonly binding: StructType<{
+        readonly source: import("@elaraai/east").ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<import("@elaraai/east").ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>;
+}>>;
+/**
+ * Options for {@link Data.bind}.
+ *
+ * @property mode - Operating mode. `"staged"` (default) buffers edits
+ *   locally and commits on demand; `"direct"` writes through immediately.
+ * @property patch - When supplied, the binding's commit / live writes
+ *   target this patch dataset (typed `PatchType(T)`). Must be a static
+ *   {@link TreePath} so manifest derivation can preload it; computed
+ *   East-side path expressions are not supported. When omitted, writes
+ *   target the source itself.
+ */
+export interface DataBindOptions {
+    /** Operating mode — `"staged"` (default) or `"direct"`. */
+    mode?: DataBindModeLiteral;
+    /** Optional separate patch dataset path. Must be statically known. */
+    patch?: TreePath;
+}
+/**
+ * The Data namespace — reactive dataset binding for e3 UI tasks.
+ *
+ * @remarks
+ * `Data.bind` exposes a single binding handle that adapts to four
+ * combinations of `mode` (staged | direct) and `patch` (absent | present).
+ * The full per-mode semantics matrix is documented on {@link Data.bind}.
+ *
+ * Use inside `Reactive.Root` for reactive re-rendering when the underlying
+ * datasets change.
+ */
+export declare const Data: {
+    /**
+     * Bind a dataset path to a reactive view of its current value, with
+     * optional local staging or a separate server-backed patch dataset.
+     *
+     * @typeParam T - The East type of the source dataset value.
+     * @param types - Single-element type-args tuple `[T]`.
+     * @param source - The source dataset path.
+     * @param options - {@link DataBindOptions}. When omitted, defaults to
+     *   `{ mode: "staged" }` (no separate patch dataset, edits buffered
+     *   locally until commit).
+     * @returns A handle struct described by {@link DataBindHandleType} —
+     *   `read` / `write` / `writeAndStart` / `source` / `pending` /
+     *   `commit` / `discard` / `has` / `status` / `binding`.
+     *
+     * @remarks
+     * Per-mode semantics matrix (rows are `mode × patch`, columns are
+     * methods):
+     *
+     * | mode    | patch   | `read()`                            | `write(v)`                              | `commit()`                                          | `discard()`                  | `pending()`         |
+     * |---------|---------|-------------------------------------|-----------------------------------------|-----------------------------------------------------|------------------------------|---------------------|
+     * | direct  | absent  | source                              | dataset write                           | no-op                                               | no-op                        | always false        |
+     * | direct  | present | apply(source, patch dataset)        | write diff(source, v) → patch dataset   | apply patch → source; clear patch dataset           | clear patch dataset          | patch non-trivial   |
+     * | staged  | absent  | buffered ?? source                  | update buffer (pin snapshot first time) | apply buffer → source; drop buffer                  | drop buffer                  | buffer non-empty    |
+     * | staged  | present | buffered ?? apply(source, patch)    | update buffer                           | write diff(source, buffer) → patch dataset; drop buffer | drop buffer (patch intact) | buffer non-empty  |
+     *
+     * `writeAndStart(v)` kicks the workspace dataflow after the write — only
+     * meaningful for `mode = "direct"` without a `patch` dataset; in other
+     * modes it falls back to `write(v)` (the workspace dataflow is triggered
+     * on `commit` instead).
+     *
+     * The `binding` field surfaces this binding's descriptor as a
+     * {@link DiffBindingType} value — pass it directly to
+     * {@link Diff.Root}'s `bindings` array to surface the in-flight change
+     * in a Diff card.
+     *
+     * Use inside `Reactive.Root` so `read` / `pending` / `status` re-fire
+     * on every dataset or staging-buffer change.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, NullType } from "@elaraai/east";
+     * import { Reactive, Slider, UIComponentType } from "@elaraai/east-ui";
+     * import { Data, Diff } from "@elaraai/e3-ui";
+     * import * as e3 from "@elaraai/e3";
+     *
+     * const thresholdInput = e3.input("threshold", FloatType, 38.0);
+     *
+     * // Mirrors `dataBindStaged` in test/data.examples.ts.
+     * const dataBindStaged = East.function([], UIComponentType, _$ => {
+     *     return Reactive.Root(East.function([], UIComponentType, $ => {
+     *         const view = $.let(Data.bind([FloatType], thresholdInput.path));
+     *         const value = $.let(view.read(), FloatType);
+     *         return Slider.Root(value, {
+     *             min: 30.0, max: 60.0, step: 1.0,
+     *             onChangeEnd: East.function([FloatType], NullType, ($, v) => {
+     *                  $(view.write(v));
+     *             }),
+     *         });
+     *     }));
+     * });
+     * ```
+     */
+    readonly bind: <T extends EastType>(types: [T], source: TreePath, options?: DataBindOptions) => ExprType<ReturnType<typeof DataBindHandleType<T>>>;
+};
+//# sourceMappingURL=data.d.ts.map

package/dist/src/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../src/data.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AAEH,OAAO,EAEH,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,UAAU,EACV,WAAW,EACX,UAAU,EAIV,KAAK,QAAQ,EACb,KAAK,QAAQ,EAGhB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAmC,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAMnF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;EAG3B,CAAC;AACH,+CAA+C;AAC/C,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AAEvD,uDAAuD;AACvD,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;EAI1B,CAAC;AACH,8CAA8C;AAC9C,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;AAMrD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,QAAQ,GAAG,MAAM,EAAE,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;EAWlE,CAAC;AAMH;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiB1B,CAAC;AAMF;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC5B,2DAA2D;IAC3D,IAAI,CAAC,EAAG,mBAAmB,CAAC;IAC5B,sEAAsE;IACtE,KAAK,CAAC,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI;IACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6DG;oBACE,CAAC,SAAS,QAAQ,SACZ,CAAC,CAAC,CAAC,UACF,QAAQ,YACN,eAAe,KAC1B,QAAQ,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;CAa/C,CAAC"}