@a2ui-sdk/utils 0.0.2 → 0.1.0

package/dist/0.9/dataBinding.test.js

@@ -0,0 +1,180 @@
+/**
+ * dataBinding Tests
+ *
+ * Tests for data binding utility functions used in A2UI 0.9.
+ */
+import { describe, it, expect } from 'vitest';
+import { isPathBinding, isFunctionCall, resolveValue, resolveString, resolveContext, } from './dataBinding.js';
+describe('dataBinding', () => {
+    const testModel = {
+        user: {
+            name: 'John',
+            age: 30,
+            active: true,
+        },
+        items: ['a', 'b', 'c'],
+        count: 42,
+    };
+    describe('isPathBinding', () => {
+        it('should return true for path binding object', () => {
+            expect(isPathBinding({ path: '/user/name' })).toBe(true);
+        });
+        it('should return true for relative path binding', () => {
+            expect(isPathBinding({ path: 'name' })).toBe(true);
+        });
+        it('should return false for string literal', () => {
+            expect(isPathBinding('Hello')).toBe(false);
+        });
+        it('should return false for number literal', () => {
+            expect(isPathBinding(42)).toBe(false);
+        });
+        it('should return false for boolean literal', () => {
+            expect(isPathBinding(true)).toBe(false);
+        });
+        it('should return false for function call', () => {
+            expect(isPathBinding({ call: 'required' })).toBe(false);
+        });
+        it('should return false for undefined', () => {
+            expect(isPathBinding(undefined)).toBe(false);
+        });
+        it('should return false for null', () => {
+            expect(isPathBinding(null)).toBe(false);
+        });
+        it('should return false for object without path property', () => {
+            expect(isPathBinding({ other: 'value' })).toBe(false);
+        });
+    });
+    describe('isFunctionCall', () => {
+        it('should return true for function call object', () => {
+            expect(isFunctionCall({ call: 'required' })).toBe(true);
+        });
+        it('should return true for function call with args', () => {
+            expect(isFunctionCall({ call: 'regex', args: { pattern: '.*' } })).toBe(true);
+        });
+        it('should return false for path binding', () => {
+            expect(isFunctionCall({ path: '/user/name' })).toBe(false);
+        });
+        it('should return false for string literal', () => {
+            expect(isFunctionCall('Hello')).toBe(false);
+        });
+        it('should return false for undefined', () => {
+            expect(isFunctionCall(undefined)).toBe(false);
+        });
+        it('should return false for null', () => {
+            expect(isFunctionCall(null)).toBe(false);
+        });
+    });
+    // Note: hasInterpolation is now an internal function (not exported)
+    // Tests for interpolation behavior are in interpolation.test.ts
+    describe('resolveValue', () => {
+        it('should resolve string literal', () => {
+            expect(resolveValue('Hello', testModel)).toBe('Hello');
+        });
+        it('should resolve number literal', () => {
+            expect(resolveValue(42, testModel)).toBe(42);
+        });
+        it('should resolve boolean literal', () => {
+            expect(resolveValue(true, testModel)).toBe(true);
+            expect(resolveValue(false, testModel)).toBe(false);
+        });
+        it('should resolve absolute path binding', () => {
+            expect(resolveValue({ path: '/user/name' }, testModel)).toBe('John');
+        });
+        it('should resolve nested path binding', () => {
+            expect(resolveValue({ path: '/user/age' }, testModel)).toBe(30);
+        });
+        it('should resolve relative path binding with base path', () => {
+            expect(resolveValue({ path: 'name' }, testModel, '/user')).toBe('John');
+        });
+        it('should resolve absolute path even with base path', () => {
+            expect(resolveValue({ path: '/count' }, testModel, '/user')).toBe(42);
+        });
+        it('should return default for undefined value', () => {
+            expect(resolveValue(undefined, testModel, null, 'default')).toBe('default');
+        });
+        it('should return default for null value', () => {
+            expect(resolveValue(null, testModel, null, 'default')).toBe('default');
+        });
+        it('should return default for non-existent path', () => {
+            expect(resolveValue({ path: '/nonexistent' }, testModel, null, 'default')).toBe('default');
+        });
+        it('should return default for function call', () => {
+            expect(resolveValue({ call: 'required' }, testModel, null, 'default')).toBe('default');
+        });
+        it('should resolve array element by index', () => {
+            expect(resolveValue({ path: '/items/0' }, testModel)).toBe('a');
+        });
+    });
+    describe('resolveString', () => {
+        it('should resolve string literal', () => {
+            expect(resolveString('Hello', testModel)).toBe('Hello');
+        });
+        it('should resolve path binding to string', () => {
+            expect(resolveString({ path: '/user/name' }, testModel)).toBe('John');
+        });
+        it('should convert number to string', () => {
+            expect(resolveString({ path: '/count' }, testModel)).toBe('42');
+        });
+        it('should return default for undefined', () => {
+            expect(resolveString(undefined, testModel, null, 'default')).toBe('default');
+        });
+        it('should return empty string as default', () => {
+            expect(resolveString(undefined, testModel)).toBe('');
+        });
+    });
+    describe('resolveContext', () => {
+        it('should resolve context with literal values', () => {
+            const context = {
+                name: 'John',
+                age: 30,
+                active: true,
+            };
+            expect(resolveContext(context, testModel)).toEqual({
+                name: 'John',
+                age: 30,
+                active: true,
+            });
+        });
+        it('should resolve context with path bindings', () => {
+            const context = {
+                name: { path: '/user/name' },
+                age: { path: '/user/age' },
+            };
+            expect(resolveContext(context, testModel)).toEqual({
+                name: 'John',
+                age: 30,
+            });
+        });
+        it('should resolve context with mixed values', () => {
+            const context = {
+                userName: { path: '/user/name' },
+                action: 'submit',
+                count: 42,
+            };
+            expect(resolveContext(context, testModel)).toEqual({
+                userName: 'John',
+                action: 'submit',
+                count: 42,
+            });
+        });
+        it('should resolve relative paths with base path', () => {
+            const context = {
+                name: { path: 'name' },
+            };
+            expect(resolveContext(context, testModel, '/user')).toEqual({
+                name: 'John',
+            });
+        });
+        it('should return empty object for undefined context', () => {
+            expect(resolveContext(undefined, testModel)).toEqual({});
+        });
+        it('should handle non-existent paths', () => {
+            const context = {
+                name: { path: '/nonexistent' },
+            };
+            expect(resolveContext(context, testModel)).toEqual({
+                name: undefined,
+            });
+        });
+    });
+});

package/dist/0.9/index.d.ts

@@ -1 +1,4 @@
-export { interpolate } from './interpolation/index.js';
+export { hasInterpolation, interpolate } from './interpolation/index.js';
+export * from './dataBinding.js';
+export * from './pathUtils.js';
+export * from './validation.js';

package/dist/0.9/index.js

@@ -1 +1,4 @@
-export { interpolate } from './interpolation/index.js';
+export { hasInterpolation, interpolate } from './interpolation/index.js';
+export * from './dataBinding.js';
+export * from './pathUtils.js';
+export * from './validation.js';

package/dist/0.9/interpolation/index.d.ts

@@ -11,10 +11,6 @@
  * const result = interpolate('Hello, ${/user/name}!', { user: { name: 'John' } })
  * // result: "Hello, John!"
  */
-export type { TokenType, Token, ASTNode, LiteralNode, PathNode, FunctionCallNode, InterpolatedStringNode, ParseError, DataModel, FunctionRegistry, InterpolationFunction, EvaluationContext, } from './types.js';
-export { tokenize } from './lexer.js';
-export { parse } from './parser.js';
-export { evaluate } from './evaluator.js';
 import type { InterpolatedStringNode, DataModel, FunctionRegistry } from './types.js';
 export declare function hasInterpolation(value: string): boolean;
 /**

package/dist/0.9/interpolation/index.js

@@ -11,9 +11,6 @@
  * const result = interpolate('Hello, ${/user/name}!', { user: { name: 'John' } })
  * // result: "Hello, John!"
  */
-export { tokenize } from './lexer.js';
-export { parse } from './parser.js';
-export { evaluate } from './evaluator.js';
 import { tokenize } from './lexer.js';
 import { parse } from './parser.js';
 import { evaluate } from './evaluator.js';

package/dist/0.9/interpolation.test.js

@@ -3,7 +3,7 @@
  * Tests the new refactored parser module.
  */
 import { describe, it, expect } from 'vitest';
-import { parseInterpolation, interpolate } from './interpolation';
+import { parseInterpolation, interpolate } from './interpolation/index.js';
 describe('parseInterpolation', () => {
     it('should parse simple path expression', () => {
         const ast = parseInterpolation('${/user/name}');

package/dist/0.9/pathUtils.d.ts

@@ -19,18 +19,6 @@ import type { DataModel } from '@a2ui-sdk/types/0.9';
  * 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.
  *

package/dist/0.9/pathUtils.js

@@ -30,25 +30,6 @@ export function parseJsonPointer(path) {
         .filter((s) => s !== '')
         .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
 }
-/**
- * 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 function createJsonPointer(segments) {
-    if (segments.length === 0) {
-        return '/';
-    }
-    // Escape special characters (~ -> ~0, / -> ~1)
-    const escaped = segments.map((segment) => segment.replace(/~/g, '~0').replace(/\//g, '~1'));
-    return '/' + escaped.join('/');
-}
 /**
  * Gets a value from the data model by JSON Pointer path.
  *

package/dist/0.9/pathUtils.test.js

@@ -4,7 +4,7 @@
  * Tests for path utility functions used in A2UI 0.9 data model operations.
  */
 import { describe, it, expect } from 'vitest';
-import { parseJsonPointer, createJsonPointer, getValueByPath, setValueByPath, normalizePath, isAbsolutePath, resolvePath, joinPaths, } from './pathUtils.js';
+import { parseJsonPointer, getValueByPath, setValueByPath, normalizePath, isAbsolutePath, resolvePath, joinPaths, } from './pathUtils.js';
 describe('pathUtils', () => {
     describe('parseJsonPointer', () => {
         it('should return empty array for empty path', () => {
@@ -38,26 +38,6 @@ describe('pathUtils', () => {
             expect(parseJsonPointer('user/name')).toEqual(['user', 'name']);
         });
     });
-    describe('createJsonPointer', () => {
-        it('should return "/" for empty array', () => {
-            expect(createJsonPointer([])).toBe('/');
-        });
-        it('should create simple path', () => {
-            expect(createJsonPointer(['user'])).toBe('/user');
-        });
-        it('should create nested path', () => {
-            expect(createJsonPointer(['user', 'name'])).toBe('/user/name');
-        });
-        it('should escape / to ~1', () => {
-            expect(createJsonPointer(['a/b'])).toBe('/a~1b');
-        });
-        it('should escape ~ to ~0', () => {
-            expect(createJsonPointer(['m~n'])).toBe('/m~0n');
-        });
-        it('should handle combined escapes', () => {
-            expect(createJsonPointer(['~/'])).toBe('/~0~1');
-        });
-    });
     describe('getValueByPath', () => {
         const testModel = {
             user: {

package/dist/0.9/validation.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Validation utilities for A2UI 0.9 Renderer.
+ *
+ * Implements validation functions and LogicExpression evaluation
+ * for the `checks` property on input components and Buttons.
+ */
+import type { 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;

package/dist/0.9/validation.js

@@ -0,0 +1,162 @@
+/**
+ * Validation utilities for A2UI 0.9 Renderer.
+ *
+ * Implements validation functions and LogicExpression evaluation
+ * for the `checks` property on input components and Buttons.
+ */
+import { resolveValue } from './dataBinding.js';
+/**
+ * Built-in validation functions.
+ */
+export const validationFunctions = {
+    /**
+     * Checks if a value is present (not null, undefined, or empty string).
+     */
+    required: ({ value }) => {
+        if (value === null || value === undefined)
+            return false;
+        if (typeof value === 'string')
+            return value.trim().length > 0;
+        if (Array.isArray(value))
+            return value.length > 0;
+        return true;
+    },
+    /**
+     * Validates email format.
+     */
+    email: ({ value }) => {
+        if (typeof value !== 'string')
+            return false;
+        // Simple email validation - matches most valid emails
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(value);
+    },
+    /**
+     * Tests value against a regular expression pattern.
+     */
+    regex: ({ value, pattern }) => {
+        if (typeof value !== 'string')
+            return false;
+        if (typeof pattern !== 'string')
+            return false;
+        try {
+            return new RegExp(pattern).test(value);
+        }
+        catch {
+            // Invalid regex pattern
+            return false;
+        }
+    },
+    /**
+     * Validates string length within min/max bounds.
+     */
+    length: ({ value, min, max }) => {
+        const str = String(value ?? '');
+        const len = str.length;
+        if (min !== undefined && min !== null && len < Number(min))
+            return false;
+        if (max !== undefined && max !== null && len > Number(max))
+            return false;
+        return true;
+    },
+    /**
+     * Validates numeric value within min/max bounds.
+     */
+    numeric: ({ value, min, max }) => {
+        const num = Number(value);
+        if (isNaN(num))
+            return false;
+        if (min !== undefined && min !== null && num < Number(min))
+            return false;
+        if (max !== undefined && max !== null && num > Number(max))
+            return false;
+        return true;
+    },
+};
+/**
+ * Resolves function arguments from DynamicValue to actual values.
+ */
+export function resolveArgs(args, dataModel, basePath) {
+    if (!args)
+        return {};
+    const resolved = {};
+    for (const [key, value] of Object.entries(args)) {
+        resolved[key] = resolveValue(value, dataModel, basePath, undefined);
+    }
+    return resolved;
+}
+/**
+ * Evaluates a function call.
+ */
+export function evaluateFunctionCall(call, args, context) {
+    const { dataModel, basePath, functions = validationFunctions } = context;
+    const fn = functions[call];
+    if (!fn) {
+        console.warn(`[A2UI] Unknown validation function: ${call}`);
+        return true; // Unknown functions pass by default
+    }
+    const resolvedArgs = resolveArgs(args, dataModel, basePath);
+    return fn(resolvedArgs);
+}
+/**
+ * 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 function evaluateCheckRule(rule, context) {
+    // Handle logical operators
+    if ('and' in rule && rule.and) {
+        return rule.and.every((r) => evaluateCheckRule(r, context));
+    }
+    if ('or' in rule && rule.or) {
+        return rule.or.some((r) => evaluateCheckRule(r, context));
+    }
+    if ('not' in rule && rule.not) {
+        return !evaluateCheckRule(rule.not, context);
+    }
+    // Handle boolean constants
+    if ('true' in rule && rule.true === true) {
+        return true;
+    }
+    if ('false' in rule && rule.false === false) {
+        return false;
+    }
+    // Handle function call
+    if ('call' in rule && rule.call) {
+        return evaluateFunctionCall(rule.call, rule.args, context);
+    }
+    // No valid expression found - default to pass
+    return true;
+}
+/**
+ * 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 function evaluateChecks(checks, dataModel, basePath, functions) {
+    if (!checks || checks.length === 0) {
+        return { valid: true, errors: [] };
+    }
+    const context = {
+        dataModel,
+        basePath,
+        functions: functions ?? validationFunctions,
+    };
+    const errors = [];
+    for (const check of checks) {
+        const passes = evaluateCheckRule(check, context);
+        if (!passes && check.message) {
+            errors.push(check.message);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Tests for validation utilities.
+ */
+export {};