@a2ui-sdk/react 0.0.3 → 0.1.0

package/README.md

@@ -0,0 +1,202 @@
+# @a2ui-sdk/react
+
+React implementation for rendering A2UI protocol. This package provides React components and hooks for integrating A2UI surfaces into your application.
+
+## Installation
+
+```bash
+npm install @a2ui-sdk/react
+```
+
+### Peer Dependencies
+
+- `react` ^19.0.0
+- `react-dom` ^19.0.0
+
+## Usage
+
+### Basic Usage
+
+```tsx
+import {
+  A2UIProvider,
+  A2UIRenderer,
+  type A2UIMessage,
+  type A2UIAction,
+} from '@a2ui-sdk/react/0.9'
+
+function App() {
+  const messages: A2UIMessage[] = [
+    // A2UI messages from your backend
+  ]
+
+  const handleAction = (action: A2UIAction) => {
+    console.log('Action:', action.name, action.context)
+  }
+
+  return (
+    <A2UIProvider messages={messages} onAction={handleAction}>
+      <A2UIRenderer />
+    </A2UIProvider>
+  )
+}
+```
+
+### With Custom Components
+
+You can override default components or add new ones via the `components` prop:
+
+```tsx
+import { A2UIProvider, A2UIRenderer, useDataBinding } from '@a2ui-sdk/react/0.9'
+
+// Custom component implementation
+function MyCustomText({ text }: { text: DynamicString }) {
+  const resolvedText = useDataBinding(text)
+  return <span className="my-custom-style">{resolvedText}</span>
+}
+
+function App() {
+  const components = new Map([['Text', MyCustomText]])
+
+  return (
+    <A2UIProvider
+      messages={messages}
+      onAction={handleAction}
+      components={components}
+    >
+      <A2UIRenderer />
+    </A2UIProvider>
+  )
+}
+```
+
+## Exports
+
+### v0.9 (Latest)
+
+```tsx
+import {
+  // Components
+  A2UIProvider,
+  A2UIRenderer,
+  ComponentRenderer,
+
+  // Hooks
+  useDispatchAction,
+  useDataBinding,
+  useFormBinding,
+  useStringBinding,
+  useDataModel,
+  useValidation,
+  useSurfaceContext,
+  useScope,
+  useScopeBasePath,
+
+  // Types
+  type A2UIMessage,
+  type A2UIAction,
+  type A2UIProviderProps,
+  type A2UIRendererProps,
+  type ComponentsMap,
+  type Component,
+  type Action,
+  type DynamicValue,
+  type DynamicString,
+  type DynamicNumber,
+  type DynamicBoolean,
+  type DynamicStringList,
+  type ChildList,
+  type TemplateBinding,
+  type CheckRule,
+  type Checkable,
+  type ValidationResult,
+  type ScopeValue,
+  type DataModel,
+} from '@a2ui-sdk/react/0.9'
+```
+
+### v0.8
+
+```tsx
+import {
+  // Components
+  A2UIProvider,
+  A2UIRenderer,
+  ComponentRenderer,
+
+  // Hooks
+  useDispatchAction,
+  useDataBinding,
+  useFormBinding,
+  useSurfaceContext,
+  useDataModelContext,
+
+  // Types
+  type A2UIMessage,
+  type A2UIAction,
+  type A2UIProviderProps,
+  type A2UIRendererProps,
+  type ComponentsMap,
+  type Action,
+  type ValueSource,
+} from '@a2ui-sdk/react/0.8'
+```
+
+### Namespace Import
+
+```tsx
+import { v0_8, v0_9 } from '@a2ui-sdk/react'
+
+// Use v0.9 API
+const { A2UIProvider, A2UIRenderer } = v0_9
+```
+
+## Hooks
+
+### useDataBinding
+
+Resolves a dynamic value from the data model:
+
+```tsx
+const value = useDataBinding({ path: '/user/name' })
+// Returns the value at /user/name in the data model
+```
+
+### useFormBinding
+
+Two-way binding for form components:
+
+```tsx
+const [value, setValue] = useFormBinding({ path: '/form/email' })
+// value: current value
+// setValue: update the data model
+```
+
+### useDispatchAction
+
+Dispatch actions from custom components:
+
+```tsx
+const dispatch = useDispatchAction()
+
+const handleClick = () => {
+  dispatch({
+    name: 'submit',
+    context: { formId: 'contact' },
+  })
+}
+```
+
+### useValidation
+
+Validate form inputs against check rules:
+
+```tsx
+const { valid, errors } = useValidation(checks)
+// valid: boolean
+// errors: string[] - list of failed validation messages
+```
+
+## License
+
+Apache-2.0

package/dist/0.8/components/layout/ColumnComponent.js

@@ -2,7 +2,7 @@ import { jsx as t } from "react/jsx-runtime";
 import { memo as u } from "react";
 import { useDataModel as d } from "../../hooks/useDataBinding.js";
 import { cn as y } from "../../../lib/utils.js";
-import { getValueByPath as j } from "../../utils/pathUtils.js";
+import { getValueByPath as j } from "@a2ui-sdk/utils/0.8";
 import { ComponentRenderer as r } from "../ComponentRenderer.js";
 const v = {
   start: "justify-start",

package/dist/0.8/components/layout/ListComponent.js

@@ -2,7 +2,7 @@ import { jsx as t } from "react/jsx-runtime";
 import { memo as d } from "react";
 import { useDataModel as x } from "../../hooks/useDataBinding.js";
 import { cn as u } from "../../../lib/utils.js";
-import { getValueByPath as v } from "../../utils/pathUtils.js";
+import { getValueByPath as v } from "@a2ui-sdk/utils/0.8";
 import { ComponentRenderer as r } from "../ComponentRenderer.js";
 const L = {
   start: "items-start",

package/dist/0.8/components/layout/RowComponent.js

@@ -2,7 +2,7 @@ import { jsx as t } from "react/jsx-runtime";
 import { memo as l } from "react";
 import { useDataModel as u } from "../../hooks/useDataBinding.js";
 import { cn as y } from "../../../lib/utils.js";
-import { getValueByPath as j } from "../../utils/pathUtils.js";
+import { getValueByPath as j } from "@a2ui-sdk/utils/0.8";
 import { ComponentRenderer as r } from "../ComponentRenderer.js";
 const v = {
   start: "justify-start",

package/dist/0.8/contexts/ActionContext.js

@@ -1,7 +1,7 @@
 import { jsx as m } from "react/jsx-runtime";
 import { useContext as x, createContext as C, useCallback as p, useMemo as f } from "react";
 import { useDataModelContext as v } from "./DataModelContext.js";
-import { resolveActionContext as A } from "../utils/dataBinding.js";
+import { resolveActionContext as A } from "@a2ui-sdk/utils/0.8";
 const s = C(null);
 function P({ onAction: t, children: c }) {
   const { getDataModel: o } = v(), e = p(

package/dist/0.8/contexts/DataModelContext.js

@@ -1,6 +1,6 @@
 import { jsx as C } from "react/jsx-runtime";
 import { createContext as P, useContext as f, useState as V, useCallback as a, useMemo as v } from "react";
-import { mergeAtPath as b, getValueByPath as y, setValueByPath as B } from "../utils/pathUtils.js";
+import { mergeAtPath as b, getValueByPath as y, setValueByPath as B } from "@a2ui-sdk/utils/0.8";
 const g = P(
   null
 );

package/dist/0.8/hooks/useA2UIMessageHandler.js

@@ -1,7 +1,7 @@
 import { useCallback as c } from "react";
 import { useSurfaceContext as I } from "../contexts/SurfaceContext.js";
 import { useDataModelContext as U } from "../contexts/DataModelContext.js";
-import { contentsToObject as b } from "../utils/dataBinding.js";
+import { contentsToObject as b } from "@a2ui-sdk/utils/0.8";
 function g() {
   const { initSurface: n, updateSurface: d, deleteSurface: u, clearSurfaces: f } = I(), { updateDataModel: s, initDataModel: l, deleteDataModel: i, clearDataModels: p } = U(), o = c(
     (t) => {

package/dist/0.8/hooks/useDataBinding.js

@@ -1,6 +1,6 @@
 import { useMemo as i } from "react";
 import { useDataModelContext as l } from "../contexts/DataModelContext.js";
-import { resolveValue as m } from "../utils/dataBinding.js";
+import { resolveValue as m } from "@a2ui-sdk/utils/0.8";
 function s(n, t, o) {
   const { getDataModel: e } = l();
   return i(() => {

package/dist/0.9/components/layout/TemplateRenderer.js

@@ -2,7 +2,7 @@ import { jsx as r, Fragment as i } from "react/jsx-runtime";
 import { memo as f } from "react";
 import { ScopeProvider as p } from "../../contexts/ScopeContext.js";
 import { ComponentRenderer as s } from "../ComponentRenderer.js";
-import { resolvePath as $, getValueByPath as P } from "../../utils/pathUtils.js";
+import { resolvePath as $, getValueByPath as P } from "@a2ui-sdk/utils/0.9";
 const b = f(function({
   surfaceId: l,
   template: c,

package/dist/0.9/contexts/ActionContext.js

@@ -1,6 +1,6 @@
 import { jsx as d } from "react/jsx-runtime";
 import { createContext as x, useContext as p, useCallback as C, useMemo as f } from "react";
-import { resolveContext as v } from "../utils/dataBinding.js";
+import { resolveContext as v } from "@a2ui-sdk/utils/0.9";
 const n = x(null);
 function b({ onAction: t, children: r }) {
   const e = C(

package/dist/0.9/contexts/SurfaceContext.js

@@ -1,6 +1,6 @@
 import { jsx as P } from "react/jsx-runtime";
 import { createContext as b, useContext as A, useState as U, useCallback as a, useMemo as $ } from "react";
-import { setValueByPath as y } from "../utils/pathUtils.js";
+import { setValueByPath as y } from "@a2ui-sdk/utils/0.9";
 const C = b(null);
 function z({ children: f }) {
   const [r, s] = U(/* @__PURE__ */ new Map()), i = a((e, n) => {

package/dist/0.9/hooks/useDataBinding.js

@@ -1,7 +1,7 @@
 import { useMemo as r, useCallback as D } from "react";
 import { useSurfaceContext as s } from "../contexts/SurfaceContext.js";
 import { useScope as g } from "../contexts/ScopeContext.js";
-import { resolveString as d, resolveValue as h, isPathBinding as c } from "../utils/dataBinding.js";
+import { resolveString as d, resolveValue as h, isPathBinding as c } from "@a2ui-sdk/utils/0.9";
 function S(n, t, a) {
   const { getDataModel: e } = s(), { basePath: i } = g();
   return r(() => {

package/dist/0.9/hooks/useValidation.d.ts

@@ -1,5 +1,5 @@
 import { CheckRule, ValidationResult } from '@a2ui-sdk/types/0.9';
-import { ValidationFunction } from '../utils/validation';
+import { ValidationFunction } from '@a2ui-sdk/utils/0.9';
 /**
  * Hook for evaluating validation checks on a component.
  *

package/dist/0.9/hooks/useValidation.js

@@ -1,7 +1,7 @@
 import { useMemo as n } from "react";
 import { useSurfaceContext as i } from "../contexts/SurfaceContext.js";
 import { useScope as p } from "../contexts/ScopeContext.js";
-import { evaluateChecks as u } from "../utils/validation.js";
+import { evaluateChecks as u } from "@a2ui-sdk/utils/0.9";
 function M(o, t, e) {
   const { getDataModel: r } = i(), { basePath: a } = p();
   return n(() => {

package/dist/0.9/index.d.ts

@@ -32,4 +32,3 @@ export { useDataBinding, useFormBinding, useStringBinding, useDataModel, } from
 export { useValidation } from './hooks/useValidation';
 export { useSurfaceContext } from './contexts/SurfaceContext';
 export { useScope, useScopeBasePath } from './contexts/ScopeContext';
-export { validationFunctions, evaluateChecks, evaluateCheckRule, type ValidationFunction, type EvaluationContext, } from './utils/validation';

package/dist/0.9/index.js

@@ -1,26 +1,22 @@
 import { A2UIProvider as r } from "./contexts/A2UIProvider.js";
 import { A2UIRenderer as n } from "./A2UIRenderer.js";
-import { ComponentRenderer as i } from "./components/ComponentRenderer.js";
-import { useDispatchAction as p } from "./hooks/useDispatchAction.js";
-import { useDataBinding as m, useDataModel as f, useFormBinding as x, useStringBinding as d } from "./hooks/useDataBinding.js";
-import { useValidation as l } from "./hooks/useValidation.js";
-import { useSurfaceContext as h } from "./contexts/SurfaceContext.js";
-import { useScope as B, useScopeBasePath as C } from "./contexts/ScopeContext.js";
-import { evaluateCheckRule as A, evaluateChecks as D, validationFunctions as R } from "./utils/validation.js";
+import { ComponentRenderer as p } from "./components/ComponentRenderer.js";
+import { useDispatchAction as a } from "./hooks/useDispatchAction.js";
+import { useDataBinding as u, useDataModel as f, useFormBinding as x, useStringBinding as d } from "./hooks/useDataBinding.js";
+import { useValidation as g } from "./hooks/useValidation.js";
+import { useSurfaceContext as S } from "./contexts/SurfaceContext.js";
+import { useScope as D, useScopeBasePath as h } from "./contexts/ScopeContext.js";
 export {
   r as A2UIProvider,
   n as A2UIRenderer,
-  i as ComponentRenderer,
-  A as evaluateCheckRule,
-  D as evaluateChecks,
-  m as useDataBinding,
+  p as ComponentRenderer,
+  u as useDataBinding,
   f as useDataModel,
-  p as useDispatchAction,
+  a as useDispatchAction,
   x as useFormBinding,
-  B as useScope,
-  C as useScopeBasePath,
+  D as useScope,
+  h as useScopeBasePath,
   d as useStringBinding,
-  h as useSurfaceContext,
-  l as useValidation,
-  R as validationFunctions
+  S as useSurfaceContext,
+  g as useValidation
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a2ui-sdk/react",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "A2UI SDK for React",
   "homepage": "https://easyops-cn.github.io/a2ui-sdk/",
   "repository": {
@@ -41,8 +41,8 @@
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@a2ui-sdk/types": "0.0.3",
-    "@a2ui-sdk/utils": "0.0.3",
+    "@a2ui-sdk/types": "0.1.0",
+    "@a2ui-sdk/utils": "0.1.0",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.1",

package/dist/0.8/utils/dataBinding.d.ts

@@ -1,95 +0,0 @@
-import { ValueSource, DataModel, DataEntry, DataModelValue } from '@a2ui-sdk/types/0.8';
-/**
- * Resolves a ValueSource to its actual value.
- *
- * @param source - The value source (literal or path reference)
- * @param dataModel - The data model for path lookups
- * @param defaultValue - Default value if source is undefined or path not found
- * @returns The resolved value
- *
- * @example
- * // Literal values
- * resolveValue({ literalString: "Hello" }, {}); // "Hello"
- * resolveValue({ literalNumber: 42 }, {});      // 42
- *
- * // Path references
- * const model = { user: { name: "John" } };
- * resolveValue({ path: "/user/name" }, model);  // "John"
- * resolveValue({ path: "/user/age" }, model, 0); // 0 (default)
- */
-export declare function resolveValue<T = unknown>(source: ValueSource | undefined, dataModel: DataModel, defaultValue?: T): T;
-/**
- * Checks if a value source is a path reference.
- *
- * @param source - The value source to check
- * @returns True if the source is a path reference
- */
-export declare function isPathReference(source: ValueSource | undefined): source is {
-    path: string;
-};
-/**
- * Gets the path from a value source, or undefined if it's not a path reference.
- *
- * @param source - The value source
- * @returns The path string or undefined
- */
-export declare function getPath(source: ValueSource | undefined): string | undefined;
-/**
- * Converts a DataEntry array to a plain object.
- * This is used for processing dataModelUpdate message contents.
- *
- * @param contents - Array of data entries from the server
- * @returns A plain object with the converted values
- *
- * @example
- * contentsToObject([
- *   { key: "name", valueString: "John" },
- *   { key: "age", valueNumber: 30 },
- *   { key: "active", valueBoolean: true },
- *   { key: "profile", valueMap: [
- *     { key: "email", valueString: "john@example.com" }
- *   ]}
- * ]);
- * // Returns: { name: "John", age: 30, active: true, profile: { email: "john@example.com" } }
- */
-export declare function contentsToObject(contents: DataEntry[]): Record<string, DataModelValue>;
-/**
- * Creates a literal string value source.
- *
- * @param value - The string value
- * @returns A ValueSource with literalString
- */
-export declare function literalString(value: string): ValueSource;
-/**
- * Creates a literal number value source.
- *
- * @param value - The number value
- * @returns A ValueSource with literalNumber
- */
-export declare function literalNumber(value: number): ValueSource;
-/**
- * Creates a literal boolean value source.
- *
- * @param value - The boolean value
- * @returns A ValueSource with literalBoolean
- */
-export declare function literalBoolean(value: boolean): ValueSource;
-/**
- * Creates a path reference value source.
- *
- * @param path - The data model path
- * @returns A ValueSource with path
- */
-export declare function pathRef(path: string): ValueSource;
-/**
- * Resolves action context items to a plain object.
- * This is used when dispatching actions to resolve all context values.
- *
- * @param context - Array of action context items
- * @param dataModel - The data model for path lookups
- * @returns A plain object with resolved context values
- */
-export declare function resolveActionContext(context: Array<{
-    key: string;
-    value: ValueSource;
-}> | undefined, dataModel: DataModel): Record<string, unknown>;

package/dist/0.8/utils/dataBinding.js

@@ -1,46 +0,0 @@
-import { getValueByPath as r } from "./pathUtils.js";
-function l(e, n, t) {
-  if (e == null)
-    return t;
-  if ("literalString" in e)
-    return e.literalString;
-  if ("literalNumber" in e)
-    return e.literalNumber;
-  if ("literalBoolean" in e)
-    return e.literalBoolean;
-  if ("literalArray" in e)
-    return e.literalArray;
-  if ("path" in e) {
-    const i = r(n, e.path);
-    return i === void 0 ? t : i;
-  }
-  return t;
-}
-function a(e) {
-  const n = {};
-  for (const t of e) {
-    const i = o(t.key);
-    t.valueString !== void 0 ? n[i] = t.valueString : t.valueNumber !== void 0 ? n[i] = t.valueNumber : t.valueBoolean !== void 0 ? n[i] = t.valueBoolean : t.valueMap !== void 0 && (n[i] = a(t.valueMap));
-  }
-  return n;
-}
-function o(e) {
-  if (e.includes("/")) {
-    const n = e.split("/").filter(Boolean);
-    return n[n.length - 1] || e;
-  }
-  return e;
-}
-function f(e, n) {
-  if (!e)
-    return {};
-  const t = {};
-  for (const i of e)
-    t[i.key] = l(i.value, n);
-  return t;
-}
-export {
-  a as contentsToObject,
-  f as resolveActionContext,
-  l as resolveValue
-};

package/dist/0.8/utils/pathUtils.d.ts

@@ -1,63 +0,0 @@
-import { DataModel, DataModelValue } from '@a2ui-sdk/types/0.8';
-/**
- * Gets a value from the data model by path.
- *
- * @param dataModel - The data model to read from
- * @param path - The path to the value (e.g., "/user/name")
- * @returns The value at the path, or undefined if not found
- *
- * @example
- * const model = { user: { name: "John" } };
- * getValueByPath(model, "/user/name"); // "John"
- * getValueByPath(model, "/user/age");  // undefined
- */
-export declare function getValueByPath(dataModel: DataModel, path: string): DataModelValue | undefined;
-/**
- * Sets a value in the data model by path, returning a new data model.
- * This function is immutable - it does not modify the original data model.
- *
- * @param dataModel - The data model to update
- * @param path - The path to set (e.g., "/user/name")
- * @param value - The value to set
- * @returns A new data model with the value set
- *
- * @example
- * const model = { user: { name: "John" } };
- * setValueByPath(model, "/user/name", "Jane");
- * // Returns: { user: { name: "Jane" } }
- */
-export declare function setValueByPath(dataModel: DataModel, path: string, value: unknown): DataModel;
-/**
- * Merges data into the data model at a given path.
- * This is used for dataModelUpdate messages where contents are merged.
- *
- * @param dataModel - The data model to update
- * @param path - The path to merge at (e.g., "/form")
- * @param data - The data to merge
- * @returns A new data model with the data merged
- */
-export declare function mergeAtPath(dataModel: DataModel, path: string, data: Record<string, unknown>): DataModel;
-/**
- * Normalizes a path to ensure it starts with "/" and has no trailing "/".
- *
- * @param path - The path to normalize
- * @returns The normalized path
- *
- * @example
- * normalizePath("user/name");   // "/user/name"
- * normalizePath("/user/name/"); // "/user/name"
- */
-export declare function normalizePath(path: string): string;
-/**
- * Joins two paths together.
- *
- * @param basePath - The base path
- * @param relativePath - The relative path to join
- * @returns The joined path
- *
- * @example
- * joinPaths("/user", "name");     // "/user/name"
- * joinPaths("/user", "/name");    // "/user/name"
- * joinPaths("/user/", "/name/");  // "/user/name"
- */
-export declare function joinPaths(basePath: string, relativePath: string): string;

package/dist/0.8/utils/pathUtils.js

@@ -1,44 +0,0 @@
-function l(e, t) {
-  if (!t || t === "/")
-    return e;
-  const n = t.split("/").filter(Boolean);
-  let r = e;
-  for (const o of n) {
-    if (r == null || typeof r != "object")
-      return;
-    r = r[o];
-  }
-  return r;
-}
-function g(e, t, n) {
-  if (!t || t === "/")
-    return typeof n == "object" && n !== null && !Array.isArray(n) ? { ...e, ...n } : e;
-  const r = t.split("/").filter(Boolean);
-  function o(u, s, i) {
-    if (s.length === 0)
-      return typeof i == "object" && i !== null && !Array.isArray(i) ? { ...u, ...i } : u;
-    const [f, ...y] = s;
-    if (y.length === 0)
-      return {
-        ...u,
-        [f]: i
-      };
-    const c = u[f], A = typeof c == "object" && c !== null && !Array.isArray(c) ? c : {};
-    return {
-      ...u,
-      [f]: o(A, y, i)
-    };
-  }
-  return o(e, r, n);
-}
-function b(e, t, n) {
-  if (!t || t === "/")
-    return { ...e, ...n };
-  const r = l(e, t), u = { ...typeof r == "object" && r !== null && !Array.isArray(r) ? r : {}, ...n };
-  return g(e, t, u);
-}
-export {
-  l as getValueByPath,
-  b as mergeAtPath,
-  g as setValueByPath
-};

package/dist/0.9/utils/dataBinding.d.ts

@@ -1,126 +0,0 @@
-import { DynamicValue, DynamicString, DataModel, FormBindableValue } from '@a2ui-sdk/types/0.9';
-/**
- * Type guard to check if a value is a path binding.
- *
- * @param value - The value to check
- * @returns True if the value is a path binding object
- *
- * @example
- * isPathBinding({ path: "/user/name" });  // true
- * isPathBinding("literal");               // false
- * isPathBinding({ call: "required" });    // false
- */
-export declare function isPathBinding(value: FormBindableValue | undefined | null): value is {
-    path: string;
-};
-/**
- * Type guard to check if a value is a function call.
- *
- * @param value - The value to check
- * @returns True if the value is a function call object
- */
-export declare function isFunctionCall(value: FormBindableValue | undefined | null): value is {
-    call: string;
-    args?: Record<string, DynamicValue>;
-};
-/**
- * Gets the path from a dynamic value, or undefined if it's not a path binding.
- *
- * @param value - The dynamic value
- * @returns The path string or undefined
- */
-export declare function getBindingPath(value: FormBindableValue | undefined | null): string | undefined;
-/**
- * Resolves a dynamic value to its actual value.
- *
- * Resolution order:
- * 1. If value is a path binding object → resolve from data model
- * 2. If value is a function call → return undefined (function calls not evaluated here)
- * 3. Otherwise → return literal value
- *
- * @param value - The dynamic value (literal, path binding, or function call)
- * @param dataModel - The data model for path lookups
- * @param basePath - Optional base path for relative path resolution
- * @param defaultValue - Default value if undefined or path not found
- * @returns The resolved value
- *
- * @example
- * // Literal values
- * resolveValue("Hello", {});        // "Hello"
- * resolveValue(42, {});             // 42
- * resolveValue(true, {});           // true
- *
- * // Path bindings
- * const model = { user: { name: "John" } };
- * resolveValue({ path: "/user/name" }, model);           // "John"
- * resolveValue({ path: "name" }, model, "/user");        // "John" (relative)
- * resolveValue({ path: "/nonexistent" }, model, null, "default"); // "default"
- */
-export declare function resolveValue<T = unknown>(value: FormBindableValue | undefined | null, dataModel: DataModel, basePath?: string | null, defaultValue?: T): T;
-/**
- * Resolves a DynamicString value to a string.
- * This is a convenience wrapper for string values.
- *
- * Supports interpolation: if the string contains `${...}` expressions,
- * they will be replaced with values from the data model.
- *
- * @param value - The dynamic string value
- * @param dataModel - The data model for path lookups
- * @param basePath - Optional base path for relative path resolution
- * @param defaultValue - Default value if undefined or path not found
- * @returns The resolved string
- *
- * @example
- * // Simple string
- * resolveString("Hello", {});  // "Hello"
- *
- * // Path binding
- * resolveString({ path: "/user/name" }, { user: { name: "John" } });  // "John"
- *
- * // Interpolation
- * resolveString("Hello, ${/user/name}!", { user: { name: "John" } });  // "Hello, John!"
- */
-export declare function resolveString(value: DynamicString | undefined | null, dataModel: DataModel, basePath?: string | null, defaultValue?: string): string;
-/**
- * Resolves a dynamic number value.
- *
- * @param value - The dynamic number value
- * @param dataModel - The data model for path lookups
- * @param basePath - Optional base path for relative path resolution
- * @param defaultValue - Default value if undefined or path not found
- * @returns The resolved number
- */
-export declare function resolveNumber(value: number | {
-    path: string;
-} | undefined | null, dataModel: DataModel, basePath?: string | null, defaultValue?: number): number;
-/**
- * Resolves a dynamic boolean value.
- *
- * @param value - The dynamic boolean value
- * @param dataModel - The data model for path lookups
- * @param basePath - Optional base path for relative path resolution
- * @param defaultValue - Default value if undefined or path not found
- * @returns The resolved boolean
- */
-export declare function resolveBoolean(value: boolean | {
-    path: string;
-} | undefined | null, dataModel: DataModel, basePath?: string | null, defaultValue?: boolean): boolean;
-/**
- * Resolves action context values to a plain object.
- * All path bindings are resolved to their actual values.
- *
- * @param context - Object with dynamic values
- * @param dataModel - The data model for path lookups
- * @param basePath - Optional base path for relative path resolution
- * @returns A plain object with resolved context values
- *
- * @example
- * const context = {
- *   name: { path: "/user/name" },
- *   action: "submit",
- *   count: 42
- * };
- * resolveContext(context, { user: { name: "John" } });
- * // Returns: { name: "John", action: "submit", count: 42 }
- */
-export declare function resolveContext(context: Record<string, DynamicValue> | undefined, dataModel: DataModel, basePath?: string | null): Record<string, unknown>;

package/dist/0.9/utils/dataBinding.js

@@ -1,41 +0,0 @@
-import { resolvePath as f, getValueByPath as c } from "./pathUtils.js";
-import { interpolate as y } from "@a2ui-sdk/utils/0.9";
-function e(r) {
-  return r != null && typeof r == "object" && !Array.isArray(r) && "path" in r && typeof r.path == "string";
-}
-function p(r) {
-  return r != null && typeof r == "object" && !Array.isArray(r) && "call" in r && typeof r.call == "string";
-}
-function g(r, i, o = null, t) {
-  if (r == null)
-    return t;
-  if (e(r)) {
-    const s = f(r.path, o), n = c(i, s);
-    return n === void 0 ? t : n;
-  }
-  return p(r) ? t : r;
-}
-function l(r, i, o = null, t = "") {
-  if (r == null)
-    return t;
-  if (e(r)) {
-    const s = f(r.path, o), n = c(i, s);
-    return n == null ? t : String(n);
-  }
-  return p(r) ? t : typeof r == "string" ? y(r, i, o) : String(r);
-}
-function m(r, i, o = null) {
-  if (!r)
-    return {};
-  const t = {};
-  for (const [s, n] of Object.entries(r))
-    t[s] = g(n, i, o);
-  return t;
-}
-export {
-  p as isFunctionCall,
-  e as isPathBinding,
-  m as resolveContext,
-  l as resolveString,
-  g as resolveValue
-};

package/dist/0.9/utils/pathUtils.d.ts

@@ -1,109 +0,0 @@
-import { DataModel } from '@a2ui-sdk/types/0.9';
-/**
- * Parses a JSON Pointer path into segments.
- *
- * @param path - The JSON Pointer path (e.g., "/user/name")
- * @returns Array of path segments
- *
- * @example
- * parseJsonPointer("/user/name");        // ["user", "name"]
- * parseJsonPointer("/items/0");          // ["items", "0"]
- * parseJsonPointer("/");                 // []
- * parseJsonPointer("/a~1b");             // ["a/b"] (escaped slash)
- * parseJsonPointer("/m~0n");             // ["m~n"] (escaped tilde)
- */
-export declare function parseJsonPointer(path: string): string[];
-/**
- * Creates a JSON Pointer path from segments.
- *
- * @param segments - Array of path segments
- * @returns JSON Pointer path string
- *
- * @example
- * createJsonPointer(["user", "name"]);   // "/user/name"
- * createJsonPointer(["a/b"]);            // "/a~1b"
- * createJsonPointer([]);                 // "/"
- */
-export declare function createJsonPointer(segments: string[]): string;
-/**
- * Gets a value from the data model by JSON Pointer path.
- *
- * @param dataModel - The data model to read from
- * @param path - The JSON Pointer path (e.g., "/user/name")
- * @returns The value at the path, or undefined if not found
- *
- * @example
- * const model = { user: { name: "John" }, items: ["a", "b"] };
- * getValueByPath(model, "/user/name");   // "John"
- * getValueByPath(model, "/items/0");     // "a"
- * getValueByPath(model, "/nonexistent"); // undefined
- */
-export declare function getValueByPath(dataModel: DataModel, path: string): unknown;
-/**
- * Sets a value in the data model by JSON Pointer path, returning a new data model.
- * This function is immutable - it does not modify the original data model.
- *
- * @param dataModel - The data model to update
- * @param path - The JSON Pointer path (e.g., "/user/name")
- * @param value - The value to set (undefined to delete)
- * @returns A new data model with the value set
- *
- * @example
- * const model = { user: { name: "John" } };
- * setValueByPath(model, "/user/name", "Jane");   // { user: { name: "Jane" } }
- * setValueByPath(model, "/user/age", 30);        // { user: { name: "John", age: 30 } }
- * setValueByPath(model, "/user/name", undefined); // { user: {} }
- */
-export declare function setValueByPath(dataModel: DataModel, path: string, value: unknown): DataModel;
-/**
- * Normalizes a path to ensure it starts with "/" and has no trailing "/".
- *
- * @param path - The path to normalize
- * @returns The normalized path
- *
- * @example
- * normalizePath("user/name");   // "/user/name"
- * normalizePath("/user/name/"); // "/user/name"
- */
-export declare function normalizePath(path: string): string;
-/**
- * Checks if a path is absolute (starts with "/").
- *
- * @param path - The path to check
- * @returns True if the path is absolute
- *
- * @example
- * isAbsolutePath("/user/name");  // true
- * isAbsolutePath("name");        // false
- * isAbsolutePath("");            // false
- */
-export declare function isAbsolutePath(path: string): boolean;
-/**
- * Resolves a path against a base path (scope).
- *
- * Absolute paths (starting with "/") are returned as-is.
- * Relative paths are resolved against the base path.
- *
- * @param path - The path to resolve
- * @param basePath - The base path (scope), or null for root scope
- * @returns The resolved absolute path
- *
- * @example
- * resolvePath("/user/name", "/items/0");   // "/user/name" (absolute)
- * resolvePath("name", "/items/0");         // "/items/0/name" (relative)
- * resolvePath("name", null);               // "/name" (root scope)
- */
-export declare function resolvePath(path: string, basePath: string | null): string;
-/**
- * Joins two paths together.
- *
- * @param basePath - The base path
- * @param relativePath - The relative path to join
- * @returns The joined path
- *
- * @example
- * joinPaths("/user", "name");     // "/user/name"
- * joinPaths("/user", "/name");    // "/user/name"
- * joinPaths("/user/", "/name/");  // "/user/name"
- */
-export declare function joinPaths(basePath: string, relativePath: string): string;

package/dist/0.9/utils/pathUtils.js

@@ -1,74 +0,0 @@
-function y(t) {
-  return !t || t === "/" ? [] : (t.startsWith("/") ? t.slice(1).split("/") : t.split("/")).filter((r) => r !== "").map((r) => r.replace(/~1/g, "/").replace(/~0/g, "~"));
-}
-function m(t, e) {
-  if (!e || e === "/")
-    return t;
-  const r = y(e);
-  let i = t;
-  for (const f of r) {
-    if (i == null)
-      return;
-    if (Array.isArray(i)) {
-      const n = parseInt(f, 10);
-      if (isNaN(n))
-        return;
-      i = i[n];
-    } else if (typeof i == "object")
-      i = i[f];
-    else
-      return;
-  }
-  return i;
-}
-function a(t, e, r) {
-  if (!e || e === "/")
-    return r === void 0 ? {} : typeof r == "object" && r !== null && !Array.isArray(r) ? r : t;
-  const i = y(e), f = structuredClone(t);
-  let n = f;
-  for (let o = 0; o < i.length - 1; o++) {
-    const l = i[o];
-    if (Array.isArray(n)) {
-      const s = parseInt(l, 10);
-      if (isNaN(s))
-        return f;
-      (n[s] === null || n[s] === void 0) && (n[s] = {}), n = n[s];
-    } else if (typeof n == "object" && n !== null) {
-      const s = n;
-      s[l] === null || s[l] === void 0 ? s[l] = {} : typeof s[l] != "object" && (s[l] = {}), n = s[l];
-    } else
-      return f;
-  }
-  const c = i[i.length - 1];
-  if (Array.isArray(n)) {
-    const o = parseInt(c, 10);
-    isNaN(o) || (r === void 0 ? n.splice(o, 1) : n[o] = r);
-  } else if (typeof n == "object" && n !== null) {
-    const o = n;
-    r === void 0 ? delete o[c] : o[c] = r;
-  }
-  return f;
-}
-function u(t) {
-  let e = t.trim();
-  return e.startsWith("/") || (e = "/" + e), e.length > 1 && e.endsWith("/") && (e = e.slice(0, -1)), e;
-}
-function g(t) {
-  return t.startsWith("/");
-}
-function A(t, e) {
-  return g(t) || e === null || e === "/" ? u(t) : d(e, t);
-}
-function d(t, e) {
-  const r = u(t), i = e.trim().replace(/^\/+/, "").replace(/\/+$/, "");
-  return i ? r === "/" ? "/" + i : r + "/" + i : r;
-}
-export {
-  m as getValueByPath,
-  g as isAbsolutePath,
-  d as joinPaths,
-  u as normalizePath,
-  y as parseJsonPointer,
-  A as resolvePath,
-  a as setValueByPath
-};

package/dist/0.9/utils/validation.d.ts

@@ -1,49 +0,0 @@
-import { CheckRule, DynamicValue, DataModel, ValidationResult } from '@a2ui-sdk/types/0.9';
-/**
- * Type for a validation function.
- * Takes resolved arguments and returns a boolean.
- */
-export type ValidationFunction = (args: Record<string, unknown>) => boolean;
-/**
- * Built-in validation functions.
- */
-export declare const validationFunctions: Record<string, ValidationFunction>;
-/**
- * Context for evaluating expressions.
- */
-export interface EvaluationContext {
-    dataModel: DataModel;
-    basePath: string | null;
-    functions?: Record<string, ValidationFunction>;
-}
-/**
- * Resolves function arguments from DynamicValue to actual values.
- */
-export declare function resolveArgs(args: Record<string, DynamicValue> | undefined, dataModel: DataModel, basePath: string | null): Record<string, unknown>;
-/**
- * Evaluates a function call.
- */
-export declare function evaluateFunctionCall(call: string, args: Record<string, DynamicValue> | undefined, context: EvaluationContext): boolean;
-/**
- * Evaluates a CheckRule (which is also a LogicExpression).
- *
- * @param rule - The check rule to evaluate
- * @param context - Evaluation context with data model and scope
- * @returns true if the check passes, false if it fails
- */
-export declare function evaluateCheckRule(rule: CheckRule, context: EvaluationContext): boolean;
-/**
- * Evaluates all checks for a component and returns validation result.
- *
- * @param checks - Array of check rules
- * @param dataModel - The data model for value resolution
- * @param basePath - The current scope base path (for relative paths)
- * @param functions - Optional custom validation functions
- * @returns ValidationResult with valid flag and error messages
- */
-export declare function evaluateChecks(checks: CheckRule[] | undefined, dataModel: DataModel, basePath: string | null, functions?: Record<string, ValidationFunction>): ValidationResult;
-/**
- * Extracts all paths referenced in a CheckRule for dependency tracking.
- * This is useful for knowing which data model paths affect validation.
- */
-export declare function extractCheckDependencies(checks: CheckRule[]): string[];

package/dist/0.9/utils/validation.js

@@ -1,75 +0,0 @@
-import { resolveValue as l } from "./dataBinding.js";
-const a = {
-  /**
-   * Checks if a value is present (not null, undefined, or empty string).
-   */
-  required: ({ value: r }) => r == null ? !1 : typeof r == "string" ? r.trim().length > 0 : Array.isArray(r) ? r.length > 0 : !0,
-  /**
-   * Validates email format.
-   */
-  email: ({ value: r }) => typeof r != "string" ? !1 : /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(r),
-  /**
-   * Tests value against a regular expression pattern.
-   */
-  regex: ({ value: r, pattern: e }) => {
-    if (typeof r != "string" || typeof e != "string") return !1;
-    try {
-      return new RegExp(e).test(r);
-    } catch {
-      return !1;
-    }
-  },
-  /**
-   * Validates string length within min/max bounds.
-   */
-  length: ({ value: r, min: e, max: n }) => {
-    const s = String(r ?? "").length;
-    return !(e != null && s < Number(e) || n != null && s > Number(n));
-  },
-  /**
-   * Validates numeric value within min/max bounds.
-   */
-  numeric: ({ value: r, min: e, max: n }) => {
-    const t = Number(r);
-    return !(isNaN(t) || e != null && t < Number(e) || n != null && t > Number(n));
-  }
-};
-function c(r, e, n) {
-  if (!r) return {};
-  const t = {};
-  for (const [s, i] of Object.entries(r))
-    t[s] = l(i, e, n, void 0);
-  return t;
-}
-function g(r, e, n) {
-  const { dataModel: t, basePath: s, functions: i = a } = n, o = i[r];
-  if (!o)
-    return console.warn(`[A2UI] Unknown validation function: ${r}`), !0;
-  const u = c(e, t, s);
-  return o(u);
-}
-function f(r, e) {
-  return "and" in r && r.and ? r.and.every((n) => f(n, e)) : "or" in r && r.or ? r.or.some((n) => f(n, e)) : "not" in r && r.not ? !f(r.not, e) : "true" in r && r.true === !0 ? !0 : "false" in r && r.false === !1 ? !1 : "call" in r && r.call ? g(r.call, r.args, e) : !0;
-}
-function v(r, e, n, t) {
-  if (!r || r.length === 0)
-    return { valid: !0, errors: [] };
-  const s = {
-    dataModel: e,
-    basePath: n,
-    functions: t ?? a
-  }, i = [];
-  for (const o of r)
-    !f(o, s) && o.message && i.push(o.message);
-  return {
-    valid: i.length === 0,
-    errors: i
-  };
-}
-export {
-  f as evaluateCheckRule,
-  v as evaluateChecks,
-  g as evaluateFunctionCall,
-  c as resolveArgs,
-  a as validationFunctions
-};