@nine1ie/a2ui-vue-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A2UI Vue contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,285 @@
+interface DynamicString {
+    literalString?: string;
+    path?: string;
+    functionCall?: FunctionCall;
+}
+interface DynamicNumber {
+    literalNumber?: number;
+    path?: string;
+    functionCall?: FunctionCall;
+}
+interface DynamicBoolean {
+    literalBoolean?: boolean;
+    path?: string;
+    functionCall?: FunctionCall;
+}
+interface DynamicStringList {
+    literalArray?: string[];
+    path?: string;
+    functionCall?: FunctionCall;
+}
+type DynamicValue = DynamicString | DynamicNumber | DynamicBoolean | DynamicStringList;
+interface FunctionCall {
+    call: string;
+    args?: Record<string, any>;
+}
+interface ExplicitChildList {
+    explicitList: string[];
+}
+interface TemplateChildList {
+    template: {
+        componentId: string;
+        dataBinding: string;
+    };
+}
+type ChildList = ExplicitChildList | TemplateChildList;
+declare function isTemplateChildList(child: ChildList): child is TemplateChildList;
+interface ComponentDef {
+    id: string;
+    component: string;
+    [key: string]: any;
+}
+interface ActionEvent {
+    event: {
+        name: string;
+        context?: Record<string, any>;
+    };
+}
+interface ActionFunctionCall {
+    functionCall: {
+        call: string;
+        args?: Record<string, any>;
+    };
+}
+type Action = ActionEvent | ActionFunctionCall;
+interface ValidationCheck {
+    call: string;
+    args?: Record<string, any>;
+    message?: string;
+}
+interface Theme {
+    primaryColor?: string;
+    iconUrl?: string;
+    agentDisplayName?: string;
+}
+interface CreateSurfaceMessage {
+    surfaceId: string;
+    catalogId: string;
+    theme?: Theme;
+    sendDataModel?: boolean;
+}
+interface UpdateComponentsMessage {
+    surfaceId: string;
+    components: ComponentDef[];
+}
+interface UpdateDataModelMessage {
+    surfaceId?: string;
+    path?: string;
+    value?: any;
+}
+interface DeleteSurfaceMessage {
+    surfaceId: string;
+}
+interface A2UIServerMessage {
+    createSurface?: CreateSurfaceMessage;
+    updateComponents?: UpdateComponentsMessage;
+    updateDataModel?: UpdateDataModelMessage;
+    deleteSurface?: DeleteSurfaceMessage;
+}
+interface ActionMessage {
+    name: string;
+    surfaceId: string;
+    sourceComponentId: string;
+    timestamp: string;
+    context: Record<string, any>;
+}
+interface ErrorMessage {
+    code: string;
+    surfaceId?: string;
+    path?: string;
+    message: string;
+}
+interface A2UIClientCapabilities {
+    supportedCatalogIds: string[];
+    inlineCatalogs?: any[];
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+interface ValidationError {
+    code: string;
+    surfaceId?: string;
+    path?: string;
+    message: string;
+}
+
+interface RowProps {
+    alignment?: 'start' | 'center' | 'end' | 'space-between' | 'space-around';
+    children?: ChildList;
+}
+interface ColumnProps {
+    alignment?: 'start' | 'center' | 'end' | 'space-between' | 'space-around';
+    children?: ChildList;
+}
+interface ListProps {
+    children?: ChildList;
+}
+interface TextProps {
+    text: DynamicString;
+    usageHint?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'body' | 'caption';
+}
+interface ImageProps {
+    url: DynamicString;
+    alt?: DynamicString;
+}
+interface IconProps {
+    icon: DynamicString;
+}
+interface VideoProps {
+    url: DynamicString;
+}
+interface AudioPlayerProps {
+    url: DynamicString;
+}
+interface DividerProps {
+}
+interface CardProps {
+    child: string;
+}
+interface TabItem {
+    title: string;
+    child: string;
+}
+interface TabsProps {
+    tabs: TabItem[];
+}
+interface ModalProps {
+    trigger: string;
+    child: string;
+}
+interface ButtonProps {
+    label: DynamicString;
+    action?: Action;
+    variant?: 'primary' | 'borderless' | 'default';
+    checks?: ValidationCheck[];
+}
+interface TextFieldProps {
+    label: DynamicString;
+    value: DynamicString;
+    placeholder?: DynamicString;
+    checks?: ValidationCheck[];
+}
+interface CheckBoxProps {
+    label: DynamicString;
+    value: DynamicBoolean;
+}
+interface ChoiceOption {
+    label: string;
+    value: string;
+}
+interface ChoicePickerProps {
+    options: ChoiceOption[];
+    value: DynamicString | DynamicStringList;
+    multi?: boolean;
+}
+interface SliderProps {
+    min: DynamicNumber;
+    max: DynamicNumber;
+    step?: DynamicNumber;
+    value: DynamicNumber;
+}
+interface DateTimeInputProps {
+    mode: 'date' | 'time' | 'datetime';
+    value: DynamicString;
+    label?: DynamicString;
+}
+interface ComponentTypeMap {
+    Text: TextProps;
+    Image: ImageProps;
+    Icon: IconProps;
+    Video: VideoProps;
+    AudioPlayer: AudioPlayerProps;
+    Divider: DividerProps;
+    Row: RowProps;
+    Column: ColumnProps;
+    List: ListProps;
+    Card: CardProps;
+    Tabs: TabsProps;
+    Modal: ModalProps;
+    Button: ButtonProps;
+    TextField: TextFieldProps;
+    CheckBox: CheckBoxProps;
+    ChoicePicker: ChoicePickerProps;
+    Slider: SliderProps;
+    DateTimeInput: DateTimeInputProps;
+}
+
+declare function parseMessage(json: string): A2UIServerMessage;
+declare function parseMessageStream(chunk: string): A2UIServerMessage[];
+declare function validateMessage(message: A2UIServerMessage): ValidationResult;
+declare class A2UIParseError extends Error {
+    constructor(message: string);
+}
+
+declare function getByPointer(obj: any, pointer: string): any;
+declare function setByPointer(obj: any, pointer: string, value: any): void;
+declare function deleteByPointer(obj: any, pointer: string): void;
+declare function deepMerge(target: any, source: any): any;
+interface Scope {
+    currentItem: any;
+    index: number;
+    parent?: Scope;
+}
+declare function isDynamicValue(value: any): value is DynamicValue;
+declare function resolvePath(path: string, dataModel: any, scope?: Scope): any;
+declare function setPath(path: string, dataModel: any, value: any, scope?: Scope): void;
+declare function resolveLiteral(dynamic: DynamicValue): any;
+
+declare class ComponentRegistry {
+    private components;
+    updateComponents(components: ComponentDef[]): void;
+    getComponent(id: string): ComponentDef | undefined;
+    hasComponent(id: string): boolean;
+    get size(): number;
+    resolveChildren(id: string, dataModel?: any, scope?: Scope): ComponentDef[];
+    private resolveTemplate;
+    getAll(): ComponentDef[];
+    clear(): void;
+}
+
+interface SurfaceInstance {
+    id: string;
+    catalogId: string;
+    theme?: Theme;
+    sendDataModel: boolean;
+    componentRegistry: ComponentRegistry;
+    dataModel: Record<string, any>;
+    createdAt: number;
+    _version: number;
+}
+type ActionHandler = (action: ActionMessage) => void;
+declare class SurfaceManager {
+    private surfaces;
+    private actionHandler?;
+    createSurface(msg: CreateSurfaceMessage): SurfaceInstance;
+    deleteSurface(surfaceId: string): void;
+    getSurface(surfaceId: string): SurfaceInstance | undefined;
+    hasSurface(surfaceId: string): boolean;
+    getAllSurfaces(): SurfaceInstance[];
+    clear(): void;
+    updateDataModel(surfaceId: string, path: string | undefined, value: any): void;
+    onAction(handler: ActionHandler): void;
+    dispatchAction(action: ActionMessage): void;
+    getDataModelSnapshot(): Record<string, Record<string, any>>;
+}
+
+type FunctionImpl = (args: Record<string, any>, dataModel: any, scope?: Scope) => any;
+declare function executeFunction(functionCall: {
+    call: string;
+    args?: Record<string, any>;
+}, dataModel: any, scope?: Scope): any;
+declare function registerFunction(name: string, impl: FunctionImpl): void;
+declare function getFunction(name: string): FunctionImpl | undefined;
+
+export { type A2UIClientCapabilities, A2UIParseError, type A2UIServerMessage, type Action, type ActionEvent, type ActionFunctionCall, type ActionHandler, type ActionMessage, type AudioPlayerProps, type ButtonProps, type CardProps, type CheckBoxProps, type ChildList, type ChoiceOption, type ChoicePickerProps, type ColumnProps, type ComponentDef, ComponentRegistry, type ComponentTypeMap, type CreateSurfaceMessage, type DateTimeInputProps, type DeleteSurfaceMessage, type DividerProps, type DynamicBoolean, type DynamicNumber, type DynamicString, type DynamicStringList, type DynamicValue, type ErrorMessage, type ExplicitChildList, type FunctionCall, type FunctionImpl, type IconProps, type ImageProps, type ListProps, type ModalProps, type RowProps, type Scope, type SliderProps, type SurfaceInstance, SurfaceManager, type TabItem, type TabsProps, type TemplateChildList, type TextFieldProps, type TextProps, type Theme, type UpdateComponentsMessage, type UpdateDataModelMessage, type ValidationCheck, type ValidationError, type ValidationResult, type VideoProps, deepMerge, deleteByPointer, executeFunction, getByPointer, getFunction, isDynamicValue, isTemplateChildList, parseMessage, parseMessageStream, registerFunction, resolveLiteral, resolvePath, setByPointer, setPath, validateMessage };

package/dist/index.js

@@ -0,0 +1,524 @@
+// src/types/protocol.ts
+function isTemplateChildList(child) {
+  return "template" in child;
+}
+
+// src/parser.ts
+function parseMessage(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (e) {
+    throw new A2UIParseError(`Invalid JSON: ${e.message}`);
+  }
+  const message = {};
+  if ("createSurface" in parsed) {
+    message.createSurface = parsed.createSurface;
+  } else if ("updateComponents" in parsed) {
+    message.updateComponents = parsed.updateComponents;
+  } else if ("updateDataModel" in parsed) {
+    message.updateDataModel = parsed.updateDataModel;
+  } else if ("deleteSurface" in parsed) {
+    message.deleteSurface = parsed.deleteSurface;
+  } else {
+    throw new A2UIParseError("Unknown message type. Expected one of: createSurface, updateComponents, updateDataModel, deleteSurface");
+  }
+  return message;
+}
+function parseMessageStream(chunk) {
+  const lines = chunk.split("\n").filter((line) => line.trim());
+  return lines.map((line) => parseMessage(line));
+}
+function validateMessage(message) {
+  const errors = [];
+  if (message.createSurface) {
+    validateCreateSurface(message.createSurface, errors);
+  } else if (message.updateComponents) {
+    validateUpdateComponents(message.updateComponents, errors);
+  } else if (message.updateDataModel) {
+    validateUpdateDataModel(message.updateDataModel, errors);
+  } else if (message.deleteSurface) {
+    validateDeleteSurface(message.deleteSurface, errors);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateCreateSurface(msg, errors) {
+  if (!msg.surfaceId) {
+    errors.push({ code: "VALIDATION_FAILED", path: "/createSurface/surfaceId", message: "surfaceId is required" });
+  }
+  if (!msg.catalogId) {
+    errors.push({ code: "VALIDATION_FAILED", path: "/createSurface/catalogId", message: "catalogId is required" });
+  }
+}
+function validateUpdateComponents(msg, errors) {
+  if (!msg.surfaceId) {
+    errors.push({ code: "VALIDATION_FAILED", surfaceId: msg.surfaceId, path: "/updateComponents/surfaceId", message: "surfaceId is required" });
+  }
+  if (!Array.isArray(msg.components)) {
+    errors.push({ code: "VALIDATION_FAILED", surfaceId: msg.surfaceId, path: "/updateComponents/components", message: "components must be an array" });
+    return;
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (let i = 0; i < msg.components.length; i++) {
+    const comp = msg.components[i];
+    if (!comp.id) {
+      errors.push({
+        code: "VALIDATION_FAILED",
+        surfaceId: msg.surfaceId,
+        path: `/updateComponents/components/${i}/id`,
+        message: "Component id is required"
+      });
+    } else if (ids.has(comp.id)) {
+      errors.push({
+        code: "VALIDATION_FAILED",
+        surfaceId: msg.surfaceId,
+        path: `/updateComponents/components/${i}/id`,
+        message: `Duplicate component id: ${comp.id}`
+      });
+    } else {
+      ids.add(comp.id);
+    }
+    if (!comp.component) {
+      errors.push({
+        code: "VALIDATION_FAILED",
+        surfaceId: msg.surfaceId,
+        path: `/updateComponents/components/${i}/component`,
+        message: "Component type is required"
+      });
+    }
+  }
+}
+function validateUpdateDataModel(msg, errors) {
+  if (!msg.surfaceId) {
+    errors.push({ code: "VALIDATION_FAILED", path: "/updateDataModel/surfaceId", message: "surfaceId is required" });
+  }
+}
+function validateDeleteSurface(msg, errors) {
+  if (!msg.surfaceId) {
+    errors.push({ code: "VALIDATION_FAILED", path: "/deleteSurface/surfaceId", message: "surfaceId is required" });
+  }
+}
+var A2UIParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "A2UIParseError";
+  }
+};
+
+// src/data-model.ts
+function decodePointerSegment(segment) {
+  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function getByPointer(obj, pointer) {
+  if (!pointer || pointer === "/") return obj;
+  const parts = pointer.split("/").filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (current == null) return void 0;
+    current = current[decodePointerSegment(part)];
+  }
+  return current;
+}
+function setByPointer(obj, pointer, value) {
+  if (!pointer || pointer === "/") return;
+  const parts = pointer.split("/").filter(Boolean);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current == null) return;
+    const decoded = decodePointerSegment(parts[i]);
+    if (typeof current[decoded] !== "object" || current[decoded] === null) {
+      current[decoded] = {};
+    }
+    current = current[decoded];
+  }
+  if (current != null) {
+    const lastKey = decodePointerSegment(parts[parts.length - 1]);
+    current[lastKey] = value;
+  }
+}
+function deleteByPointer(obj, pointer) {
+  if (!pointer || pointer === "/") return;
+  const parts = pointer.split("/").filter(Boolean);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current == null) return;
+    current = current[decodePointerSegment(parts[i])];
+  }
+  if (current != null) {
+    const lastKey = decodePointerSegment(parts[parts.length - 1]);
+    if (Array.isArray(current)) {
+      current.splice(Number(lastKey), 1);
+    } else {
+      delete current[lastKey];
+    }
+  }
+}
+function deepMerge(target, source) {
+  if (source === void 0) return target;
+  if (typeof source !== "object" || source === null) return source;
+  if (typeof target !== "object" || target === null) return structuredClone(source);
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] === void 0) {
+      delete result[key];
+    } else {
+      result[key] = deepMerge(target[key], source[key]);
+    }
+  }
+  return result;
+}
+function isDynamicValue(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return "literalString" in value || "literalNumber" in value || "literalBoolean" in value || "literalArray" in value || "path" in value || "functionCall" in value;
+}
+function resolvePath(path, dataModel, scope) {
+  if (path.startsWith("/")) {
+    return getByPointer(dataModel, path);
+  }
+  let current = scope;
+  const parts = path.split("/");
+  let result = void 0;
+  for (let i = 0; i < parts.length; i++) {
+    if (i === 0) {
+      result = current?.currentItem?.[parts[0]];
+      current = current?.parent;
+    } else {
+      result = result?.[parts[i]];
+    }
+  }
+  return result;
+}
+function setPath(path, dataModel, value, scope) {
+  if (path.startsWith("/")) {
+    setByPointer(dataModel, path, value);
+    return;
+  }
+  const parts = path.split("/").filter(Boolean);
+  if (parts.length === 0) return;
+  let current = scope?.currentItem ?? dataModel;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current == null) return;
+    const key = parts[i];
+    if (typeof current[key] !== "object" || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  if (current != null) {
+    current[parts[parts.length - 1]] = value;
+  }
+}
+function resolveLiteral(dynamic) {
+  if ("literalString" in dynamic) return dynamic.literalString;
+  if ("literalNumber" in dynamic) return dynamic.literalNumber;
+  if ("literalBoolean" in dynamic) return dynamic.literalBoolean;
+  if ("literalArray" in dynamic) return dynamic.literalArray;
+  return void 0;
+}
+
+// src/component-registry.ts
+var ComponentRegistry = class {
+  components = /* @__PURE__ */ new Map();
+  // Merge new component definitions (upsert)
+  updateComponents(components) {
+    for (const comp of components) {
+      this.components.set(comp.id, comp);
+    }
+  }
+  getComponent(id) {
+    return this.components.get(id);
+  }
+  hasComponent(id) {
+    return this.components.has(id);
+  }
+  get size() {
+    return this.components.size;
+  }
+  // Resolve children of a component, returns ordered ComponentDef list
+  resolveChildren(id, dataModel, scope) {
+    const comp = this.components.get(id);
+    if (!comp) return [];
+    const childList = comp.children;
+    if (!childList) return [];
+    if (isTemplateChildList(childList)) {
+      return this.resolveTemplate(childList, dataModel, scope);
+    }
+    return (childList.explicitList ?? []).map((childId) => this.components.get(childId)).filter((c) => c != null);
+  }
+  // Resolve template-based children (data-bound lists)
+  resolveTemplate(templateChild, dataModel, scope) {
+    if (!dataModel) return [];
+    const { componentId, dataBinding } = templateChild.template;
+    const array = getByPointer(dataModel, dataBinding);
+    if (!Array.isArray(array)) return [];
+    return array.map((_, index) => {
+      const base = this.components.get(componentId);
+      return {
+        ...base,
+        id: `${componentId}__${index}`,
+        _templateIndex: index,
+        _templateSource: componentId
+      };
+    });
+  }
+  // Get all components as a flat array
+  getAll() {
+    return Array.from(this.components.values());
+  }
+  // Clear all components
+  clear() {
+    this.components.clear();
+  }
+};
+
+// src/surface.ts
+var SurfaceManager = class {
+  surfaces = /* @__PURE__ */ new Map();
+  actionHandler;
+  createSurface(msg) {
+    const surface = {
+      id: msg.surfaceId,
+      catalogId: msg.catalogId,
+      theme: msg.theme,
+      sendDataModel: msg.sendDataModel ?? false,
+      componentRegistry: new ComponentRegistry(),
+      dataModel: {},
+      createdAt: Date.now(),
+      _version: 0
+    };
+    this.surfaces.set(msg.surfaceId, surface);
+    return surface;
+  }
+  deleteSurface(surfaceId) {
+    this.surfaces.delete(surfaceId);
+  }
+  getSurface(surfaceId) {
+    return this.surfaces.get(surfaceId);
+  }
+  hasSurface(surfaceId) {
+    return this.surfaces.has(surfaceId);
+  }
+  getAllSurfaces() {
+    return Array.from(this.surfaces.values());
+  }
+  clear() {
+    this.surfaces.clear();
+  }
+  // Update data model with upsert semantics
+  updateDataModel(surfaceId, path, value) {
+    const surface = this.surfaces.get(surfaceId);
+    if (!surface) return;
+    if (!path || path === "/") {
+      surface.dataModel = value ?? {};
+    } else if (value === void 0) {
+      deleteByPointer(surface.dataModel, path);
+    } else {
+      const existing = getByPointer(surface.dataModel, path);
+      if (typeof value === "object" && value !== null && typeof existing === "object" && existing !== null) {
+        setByPointer(surface.dataModel, path, deepMerge(existing, value));
+      } else {
+        setByPointer(surface.dataModel, path, value);
+      }
+    }
+  }
+  // Set action handler for user interactions
+  onAction(handler) {
+    this.actionHandler = handler;
+  }
+  // Dispatch user action
+  dispatchAction(action) {
+    this.actionHandler?.(action);
+  }
+  // Get data model snapshot for capability exchange
+  getDataModelSnapshot() {
+    const snapshot = {};
+    for (const [id, surface] of this.surfaces) {
+      snapshot[id] = surface.dataModel;
+    }
+    return snapshot;
+  }
+};
+
+// src/functions/validation.ts
+var validationFunctions = {
+  required: (args) => {
+    const value = args.value;
+    return value != null && value !== "";
+  },
+  regex: (args) => {
+    const { value, pattern } = args;
+    if (value == null || !pattern) return false;
+    return new RegExp(pattern).test(String(value));
+  },
+  length: (args) => {
+    const { value, min, max } = args;
+    if (value == null) return false;
+    const len = String(value).length;
+    if (min != null && len < min) return false;
+    if (max != null && len > max) return false;
+    return true;
+  },
+  numeric: (args) => {
+    const { value, min, max } = args;
+    if (value == null) return false;
+    const num = Number(value);
+    if (isNaN(num)) return false;
+    if (min != null && num < min) return false;
+    if (max != null && num > max) return false;
+    return true;
+  },
+  email: (args) => {
+    const { value } = args;
+    if (value == null) return false;
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value));
+  }
+};
+
+// src/functions/format.ts
+var formatFunctions = {
+  formatString: (args, dataModel, scope) => {
+    const template = String(args.template ?? args.value ?? "");
+    return template.replace(/\$\{(.*?)\}/g, (_, expr) => {
+      if (expr.startsWith("{")) return "${" + expr.slice(1);
+      if (!expr.includes("(")) {
+        const value = resolvePath(expr.trim(), dataModel, scope);
+        return value != null ? String(value) : "";
+      }
+      return "";
+    });
+  },
+  formatNumber: (args) => {
+    const { value, precision, grouping } = args;
+    if (value == null) return "";
+    const num = Number(value);
+    if (isNaN(num)) return "";
+    return num.toLocaleString(void 0, {
+      minimumFractionDigits: precision ?? 0,
+      maximumFractionDigits: precision ?? 0,
+      useGrouping: grouping !== false
+    });
+  },
+  formatCurrency: (args) => {
+    const { value, currency, precision } = args;
+    if (value == null) return "";
+    const num = Number(value);
+    if (isNaN(num)) return "";
+    return num.toLocaleString(void 0, {
+      style: "currency",
+      currency: currency ?? "USD",
+      minimumFractionDigits: precision ?? 2,
+      maximumFractionDigits: precision ?? 2
+    });
+  },
+  formatDate: (args) => {
+    const { value, format } = args;
+    if (value == null) return "";
+    const date = new Date(value);
+    if (isNaN(date.getTime())) return "";
+    const tokens = {
+      yyyy: String(date.getFullYear()),
+      MM: String(date.getMonth() + 1).padStart(2, "0"),
+      dd: String(date.getDate()).padStart(2, "0"),
+      HH: String(date.getHours()).padStart(2, "0"),
+      mm: String(date.getMinutes()).padStart(2, "0"),
+      ss: String(date.getSeconds()).padStart(2, "0")
+    };
+    let result = format ?? "yyyy-MM-dd";
+    for (const [token, replacement] of Object.entries(tokens)) {
+      result = result.replace(token, replacement);
+    }
+    return result;
+  }
+};
+
+// src/functions/logic.ts
+var logicFunctions = {
+  and: (args) => {
+    const values = args.values ?? args.value ?? [];
+    if (!Array.isArray(values)) return Boolean(values);
+    return values.every(Boolean);
+  },
+  or: (args) => {
+    const values = args.values ?? args.value ?? [];
+    if (!Array.isArray(values)) return Boolean(values);
+    return values.some(Boolean);
+  },
+  not: (args) => {
+    return !Boolean(args.value);
+  }
+};
+
+// src/functions/pluralize.ts
+var pluralizeFunction = (args) => {
+  const { count, zero, one, other } = args;
+  const n = Number(count) || 0;
+  if (n === 0 && zero != null) return zero;
+  if (n === 1 && one != null) return one;
+  return other ?? "";
+};
+
+// src/functions/index.ts
+var builtinFunctions = {
+  ...validationFunctions,
+  ...formatFunctions,
+  ...logicFunctions,
+  pluralize: pluralizeFunction,
+  openUrl: (args) => {
+    if (args.url) window.open(String(args.url), "_blank");
+  }
+};
+function resolveArgs(args, dataModel, scope) {
+  if (!args) return {};
+  const resolved = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (isDynamicValue(value)) {
+      if ("path" in value && value.path) {
+        resolved[key] = resolvePath(value.path, dataModel, scope);
+      } else if ("functionCall" in value && value.functionCall) {
+        resolved[key] = executeFunction(value.functionCall, dataModel, scope);
+      } else {
+        resolved[key] = resolveLiteral(value);
+      }
+    } else if (typeof value === "object" && value !== null && "call" in value) {
+      resolved[key] = executeFunction(value, dataModel, scope);
+    } else {
+      resolved[key] = value;
+    }
+  }
+  return resolved;
+}
+function executeFunction(functionCall, dataModel, scope) {
+  const impl = builtinFunctions[functionCall.call];
+  if (!impl) {
+    console.warn(`[A2UI] Unknown function: ${functionCall.call}`);
+    return void 0;
+  }
+  const resolvedArgs = resolveArgs(functionCall.args, dataModel, scope);
+  return impl(resolvedArgs, dataModel, scope);
+}
+function registerFunction(name, impl) {
+  builtinFunctions[name] = impl;
+}
+function getFunction(name) {
+  return builtinFunctions[name];
+}
+export {
+  A2UIParseError,
+  ComponentRegistry,
+  SurfaceManager,
+  deepMerge,
+  deleteByPointer,
+  executeFunction,
+  getByPointer,
+  getFunction,
+  isDynamicValue,
+  isTemplateChildList,
+  parseMessage,
+  parseMessageStream,
+  registerFunction,
+  resolveLiteral,
+  resolvePath,
+  setByPointer,
+  setPath,
+  validateMessage
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@nine1ie/a2ui-vue-core",
+  "version": "0.1.0",
+  "description": "A2UI v0.9 protocol core: parser, data model, client functions",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --outDir dist",
+    "dev": "tsup src/index.ts --format esm --dts --outDir dist --watch",
+    "test": "vitest run",
+    "typecheck": "vue-tsc --noEmit"
+  }
+}