@a2ui-sdk/utils 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a2ui-sdk/utils",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "A2UI utilities",
   "homepage": "https://a2ui-sdk.js.org/",
   "repository": {
@@ -11,6 +11,7 @@
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -29,8 +30,8 @@
     "dist"
   ],
   "scripts": {
-    "dev": "tsc -b --watch",
-    "build": "tsc -b",
+    "dev": "tsc -b tsconfig.build.json --watch",
+    "build": "tsc -b tsconfig.build.json",
     "test": "vitest",
     "test:run": "vitest run",
     "test:coverage": "vitest run --coverage"
@@ -42,6 +43,6 @@
     "vitest": "^4.0.16"
   },
   "dependencies": {
-    "@a2ui-sdk/types": "0.1.1"
+    "@a2ui-sdk/types": "0.2.0"
   }
 }

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

@@ -1,6 +0,0 @@
-/**
- * dataBinding Tests
- *
- * Tests for data binding utility functions used in A2UI.
- */
-export {};

package/dist/0.8/dataBinding.test.js

@@ -1,271 +0,0 @@
-/**
- * dataBinding Tests
- *
- * Tests for data binding utility functions used in A2UI.
- */
-import { describe, it, expect } from 'vitest';
-import { resolveValue, contentsToObject, resolveActionContext, } from './dataBinding.js';
-describe('dataBinding', () => {
-    describe('resolveValue', () => {
-        const testModel = {
-            user: {
-                name: 'John',
-                age: 30,
-                active: true,
-            },
-            items: ['a', 'b', 'c'],
-            count: 42,
-        };
-        describe('with undefined/null source', () => {
-            it('should return default value when source is undefined', () => {
-                expect(resolveValue(undefined, testModel, 'default')).toBe('default');
-            });
-            it('should return default value when source is null', () => {
-                expect(resolveValue(null, testModel, 'default')).toBe('default');
-            });
-            it('should return undefined when no default provided and source is undefined', () => {
-                expect(resolveValue(undefined, testModel)).toBeUndefined();
-            });
-        });
-        describe('with literal values', () => {
-            it('should resolve literalString', () => {
-                const source = { literalString: 'Hello' };
-                expect(resolveValue(source, testModel)).toBe('Hello');
-            });
-            it('should resolve empty literalString', () => {
-                const source = { literalString: '' };
-                expect(resolveValue(source, testModel, 'default')).toBe('');
-            });
-            it('should resolve literalNumber', () => {
-                const source = { literalNumber: 42 };
-                expect(resolveValue(source, testModel)).toBe(42);
-            });
-            it('should resolve zero literalNumber', () => {
-                const source = { literalNumber: 0 };
-                expect(resolveValue(source, testModel, 99)).toBe(0);
-            });
-            it('should resolve negative literalNumber', () => {
-                const source = { literalNumber: -10 };
-                expect(resolveValue(source, testModel)).toBe(-10);
-            });
-            it('should resolve literalBoolean true', () => {
-                const source = { literalBoolean: true };
-                expect(resolveValue(source, testModel)).toBe(true);
-            });
-            it('should resolve literalBoolean false', () => {
-                const source = { literalBoolean: false };
-                expect(resolveValue(source, testModel, true)).toBe(false);
-            });
-            it('should resolve literalArray', () => {
-                const source = { literalArray: ['x', 'y', 'z'] };
-                expect(resolveValue(source, testModel)).toEqual([
-                    'x',
-                    'y',
-                    'z',
-                ]);
-            });
-            it('should resolve empty literalArray', () => {
-                const source = { literalArray: [] };
-                expect(resolveValue(source, testModel, ['default'])).toEqual([]);
-            });
-        });
-        describe('with path references', () => {
-            it('should resolve path to string value', () => {
-                const source = { path: '/user/name' };
-                expect(resolveValue(source, testModel)).toBe('John');
-            });
-            it('should resolve path to number value', () => {
-                const source = { path: '/count' };
-                expect(resolveValue(source, testModel)).toBe(42);
-            });
-            it('should resolve path to boolean value', () => {
-                const source = { path: '/user/active' };
-                expect(resolveValue(source, testModel)).toBe(true);
-            });
-            it('should resolve path to nested object', () => {
-                const source = { path: '/user' };
-                expect(resolveValue(source, testModel)).toEqual({
-                    name: 'John',
-                    age: 30,
-                    active: true,
-                });
-            });
-            it('should resolve path to array', () => {
-                const source = { path: '/items' };
-                expect(resolveValue(source, testModel)).toEqual([
-                    'a',
-                    'b',
-                    'c',
-                ]);
-            });
-            it('should return default when path not found', () => {
-                const source = { path: '/nonexistent' };
-                expect(resolveValue(source, testModel, 'default')).toBe('default');
-            });
-            it('should return undefined when path not found and no default', () => {
-                const source = { path: '/nonexistent' };
-                expect(resolveValue(source, testModel)).toBeUndefined();
-            });
-            it('should handle empty data model', () => {
-                const source = { path: '/user/name' };
-                expect(resolveValue(source, {}, 'default')).toBe('default');
-            });
-        });
-        describe('with unknown source structure', () => {
-            it('should return default value for unknown source structure', () => {
-                const source = { unknown: 'value' };
-                expect(resolveValue(source, testModel, 'default')).toBe('default');
-            });
-        });
-    });
-    describe('contentsToObject', () => {
-        it('should convert string entry', () => {
-            const contents = [{ key: 'name', valueString: 'John' }];
-            expect(contentsToObject(contents)).toEqual({ name: 'John' });
-        });
-        it('should convert number entry', () => {
-            const contents = [{ key: 'age', valueNumber: 30 }];
-            expect(contentsToObject(contents)).toEqual({ age: 30 });
-        });
-        it('should convert boolean entry', () => {
-            const contents = [{ key: 'active', valueBoolean: true }];
-            expect(contentsToObject(contents)).toEqual({ active: true });
-        });
-        it('should convert false boolean entry', () => {
-            const contents = [{ key: 'active', valueBoolean: false }];
-            expect(contentsToObject(contents)).toEqual({ active: false });
-        });
-        it('should convert zero number entry', () => {
-            const contents = [{ key: 'count', valueNumber: 0 }];
-            expect(contentsToObject(contents)).toEqual({ count: 0 });
-        });
-        it('should convert empty string entry', () => {
-            const contents = [{ key: 'name', valueString: '' }];
-            expect(contentsToObject(contents)).toEqual({ name: '' });
-        });
-        it('should convert nested map entry', () => {
-            const contents = [
-                {
-                    key: 'user',
-                    valueMap: [
-                        { key: 'name', valueString: 'John' },
-                        { key: 'age', valueNumber: 30 },
-                    ],
-                },
-            ];
-            expect(contentsToObject(contents)).toEqual({
-                user: { name: 'John', age: 30 },
-            });
-        });
-        it('should convert deeply nested map entry', () => {
-            const contents = [
-                {
-                    key: 'user',
-                    valueMap: [
-                        {
-                            key: 'profile',
-                            valueMap: [{ key: 'email', valueString: 'john@example.com' }],
-                        },
-                    ],
-                },
-            ];
-            expect(contentsToObject(contents)).toEqual({
-                user: { profile: { email: 'john@example.com' } },
-            });
-        });
-        it('should convert multiple entries', () => {
-            const contents = [
-                { key: 'name', valueString: 'John' },
-                { key: 'age', valueNumber: 30 },
-                { key: 'active', valueBoolean: true },
-            ];
-            expect(contentsToObject(contents)).toEqual({
-                name: 'John',
-                age: 30,
-                active: true,
-            });
-        });
-        it('should normalize path keys to last segment', () => {
-            const contents = [
-                { key: '/form/name', valueString: 'John' },
-                { key: '/form/age', valueNumber: 30 },
-            ];
-            expect(contentsToObject(contents)).toEqual({
-                name: 'John',
-                age: 30,
-            });
-        });
-        it('should handle empty contents array', () => {
-            expect(contentsToObject([])).toEqual({});
-        });
-        it('should handle entry with no value type', () => {
-            const contents = [{ key: 'empty' }];
-            expect(contentsToObject(contents)).toEqual({});
-        });
-    });
-    describe('resolveActionContext', () => {
-        const testModel = {
-            user: {
-                name: 'John',
-                age: 30,
-            },
-            selectedId: 'item-123',
-        };
-        it('should return empty object for undefined context', () => {
-            expect(resolveActionContext(undefined, testModel)).toEqual({});
-        });
-        it('should return empty object for empty context array', () => {
-            expect(resolveActionContext([], testModel)).toEqual({});
-        });
-        it('should resolve literalString values', () => {
-            const context = [{ key: 'action', value: { literalString: 'submit' } }];
-            expect(resolveActionContext(context, testModel)).toEqual({
-                action: 'submit',
-            });
-        });
-        it('should resolve literalNumber values', () => {
-            const context = [{ key: 'count', value: { literalNumber: 5 } }];
-            expect(resolveActionContext(context, testModel)).toEqual({ count: 5 });
-        });
-        it('should resolve literalBoolean values', () => {
-            const context = [{ key: 'confirmed', value: { literalBoolean: true } }];
-            expect(resolveActionContext(context, testModel)).toEqual({
-                confirmed: true,
-            });
-        });
-        it('should resolve path references', () => {
-            const context = [{ key: 'userName', value: { path: '/user/name' } }];
-            expect(resolveActionContext(context, testModel)).toEqual({
-                userName: 'John',
-            });
-        });
-        it('should resolve multiple context items', () => {
-            const context = [
-                { key: 'action', value: { literalString: 'update' } },
-                { key: 'userId', value: { path: '/selectedId' } },
-                { key: 'confirmed', value: { literalBoolean: true } },
-            ];
-            expect(resolveActionContext(context, testModel)).toEqual({
-                action: 'update',
-                userId: 'item-123',
-                confirmed: true,
-            });
-        });
-        it('should return undefined for non-existent path', () => {
-            const context = [{ key: 'missing', value: { path: '/nonexistent' } }];
-            expect(resolveActionContext(context, testModel)).toEqual({
-                missing: undefined,
-            });
-        });
-        it('should resolve nested path references', () => {
-            const context = [
-                { key: 'name', value: { path: '/user/name' } },
-                { key: 'age', value: { path: '/user/age' } },
-            ];
-            expect(resolveActionContext(context, testModel)).toEqual({
-                name: 'John',
-                age: 30,
-            });
-        });
-    });
-});

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

@@ -1,6 +0,0 @@
-/**
- * pathUtils Tests
- *
- * Tests for path utility functions used in A2UI data model operations.
- */
-export {};

package/dist/0.8/pathUtils.test.js

@@ -1,211 +0,0 @@
-/**
- * pathUtils Tests
- *
- * Tests for path utility functions used in A2UI data model operations.
- */
-import { describe, it, expect } from 'vitest';
-import { getValueByPath, setValueByPath, mergeAtPath } from './pathUtils.js';
-describe('pathUtils', () => {
-    describe('getValueByPath', () => {
-        const testModel = {
-            user: {
-                name: 'John',
-                age: 30,
-                profile: {
-                    email: 'john@example.com',
-                    active: true,
-                },
-            },
-            items: ['a', 'b', 'c'],
-            count: 42,
-        };
-        it('should return entire data model for empty path', () => {
-            expect(getValueByPath(testModel, '')).toEqual(testModel);
-        });
-        it('should return entire data model for root path', () => {
-            expect(getValueByPath(testModel, '/')).toEqual(testModel);
-        });
-        it('should get top-level string value', () => {
-            const model = { name: 'test' };
-            expect(getValueByPath(model, '/name')).toBe('test');
-        });
-        it('should get top-level number value', () => {
-            expect(getValueByPath(testModel, '/count')).toBe(42);
-        });
-        it('should get top-level array value', () => {
-            expect(getValueByPath(testModel, '/items')).toEqual(['a', 'b', 'c']);
-        });
-        it('should get nested object value', () => {
-            expect(getValueByPath(testModel, '/user')).toEqual({
-                name: 'John',
-                age: 30,
-                profile: {
-                    email: 'john@example.com',
-                    active: true,
-                },
-            });
-        });
-        it('should get deeply nested string value', () => {
-            expect(getValueByPath(testModel, '/user/name')).toBe('John');
-        });
-        it('should get deeply nested number value', () => {
-            expect(getValueByPath(testModel, '/user/age')).toBe(30);
-        });
-        it('should get deeply nested object value', () => {
-            expect(getValueByPath(testModel, '/user/profile')).toEqual({
-                email: 'john@example.com',
-                active: true,
-            });
-        });
-        it('should get very deeply nested value', () => {
-            expect(getValueByPath(testModel, '/user/profile/email')).toBe('john@example.com');
-            expect(getValueByPath(testModel, '/user/profile/active')).toBe(true);
-        });
-        it('should return undefined for non-existent path', () => {
-            expect(getValueByPath(testModel, '/nonexistent')).toBeUndefined();
-        });
-        it('should return undefined for non-existent nested path', () => {
-            expect(getValueByPath(testModel, '/user/nonexistent')).toBeUndefined();
-        });
-        it('should return undefined for path through non-object', () => {
-            expect(getValueByPath(testModel, '/count/nested')).toBeUndefined();
-        });
-        it('should return undefined when intermediate value is null', () => {
-            const model = { user: null };
-            expect(getValueByPath(model, '/user/name')).toBeUndefined();
-        });
-        it('should return undefined when intermediate value is undefined', () => {
-            const model = { user: undefined };
-            expect(getValueByPath(model, '/user/name')).toBeUndefined();
-        });
-        it('should handle paths without leading slash', () => {
-            expect(getValueByPath(testModel, 'user/name')).toBe('John');
-        });
-        it('should handle empty data model', () => {
-            expect(getValueByPath({}, '/user/name')).toBeUndefined();
-        });
-    });
-    describe('setValueByPath', () => {
-        it('should return merged object for empty path with object value', () => {
-            const model = { a: 1 };
-            const result = setValueByPath(model, '', { b: 2 });
-            expect(result).toEqual({ a: 1, b: 2 });
-        });
-        it('should return merged object for root path with object value', () => {
-            const model = { a: 1 };
-            const result = setValueByPath(model, '/', { b: 2 });
-            expect(result).toEqual({ a: 1, b: 2 });
-        });
-        it('should return original model for root path with non-object value', () => {
-            const model = { a: 1 };
-            const result = setValueByPath(model, '/', 'string');
-            expect(result).toEqual({ a: 1 });
-        });
-        it('should return original model for root path with array value', () => {
-            const model = { a: 1 };
-            const result = setValueByPath(model, '/', [1, 2, 3]);
-            expect(result).toEqual({ a: 1 });
-        });
-        it('should set top-level value', () => {
-            const model = { a: 1 };
-            const result = setValueByPath(model, '/b', 2);
-            expect(result).toEqual({ a: 1, b: 2 });
-        });
-        it('should update existing top-level value', () => {
-            const model = { a: 1 };
-            const result = setValueByPath(model, '/a', 2);
-            expect(result).toEqual({ a: 2 });
-        });
-        it('should set nested value in existing object', () => {
-            const model = { user: { name: 'John' } };
-            const result = setValueByPath(model, '/user/age', 30);
-            expect(result).toEqual({ user: { name: 'John', age: 30 } });
-        });
-        it('should update existing nested value', () => {
-            const model = { user: { name: 'John' } };
-            const result = setValueByPath(model, '/user/name', 'Jane');
-            expect(result).toEqual({ user: { name: 'Jane' } });
-        });
-        it('should create nested structure if not exists', () => {
-            const model = {};
-            const result = setValueByPath(model, '/user/profile/email', 'test@test.com');
-            expect(result).toEqual({
-                user: { profile: { email: 'test@test.com' } },
-            });
-        });
-        it('should replace non-object with object when setting nested path', () => {
-            const model = { user: 'string' };
-            const result = setValueByPath(model, '/user/name', 'John');
-            expect(result).toEqual({ user: { name: 'John' } });
-        });
-        it('should be immutable - not modify original model', () => {
-            const model = { user: { name: 'John' } };
-            const result = setValueByPath(model, '/user/name', 'Jane');
-            expect(model).toEqual({ user: { name: 'John' } });
-            expect(result).toEqual({ user: { name: 'Jane' } });
-        });
-        it('should handle setting null value', () => {
-            const model = { user: { name: 'John' } };
-            const result = setValueByPath(model, '/user/name', null);
-            expect(result).toEqual({ user: { name: null } });
-        });
-        it('should handle setting array value', () => {
-            const model = { items: [] };
-            const result = setValueByPath(model, '/items', ['a', 'b']);
-            expect(result).toEqual({ items: ['a', 'b'] });
-        });
-        it('should handle setting object value', () => {
-            const model = { user: null };
-            const result = setValueByPath(model, '/user', { name: 'John' });
-            expect(result).toEqual({ user: { name: 'John' } });
-        });
-    });
-    describe('mergeAtPath', () => {
-        it('should merge at root for empty path', () => {
-            const model = { a: 1 };
-            const result = mergeAtPath(model, '', { b: 2 });
-            expect(result).toEqual({ a: 1, b: 2 });
-        });
-        it('should merge at root for root path', () => {
-            const model = { a: 1 };
-            const result = mergeAtPath(model, '/', { b: 2 });
-            expect(result).toEqual({ a: 1, b: 2 });
-        });
-        it('should overwrite existing keys at root', () => {
-            const model = { a: 1, b: 2 };
-            const result = mergeAtPath(model, '/', { b: 3, c: 4 });
-            expect(result).toEqual({ a: 1, b: 3, c: 4 });
-        });
-        it('should merge at nested path', () => {
-            const model = { user: { name: 'John' } };
-            const result = mergeAtPath(model, '/user', { age: 30 });
-            expect(result).toEqual({ user: { name: 'John', age: 30 } });
-        });
-        it('should overwrite existing keys at nested path', () => {
-            const model = { user: { name: 'John', age: 25 } };
-            const result = mergeAtPath(model, '/user', { age: 30 });
-            expect(result).toEqual({ user: { name: 'John', age: 30 } });
-        });
-        it('should create path if not exists', () => {
-            const model = {};
-            const result = mergeAtPath(model, '/user', { name: 'John' });
-            expect(result).toEqual({ user: { name: 'John' } });
-        });
-        it('should replace non-object at path with merged result', () => {
-            const model = { user: 'string' };
-            const result = mergeAtPath(model, '/user', { name: 'John' });
-            expect(result).toEqual({ user: { name: 'John' } });
-        });
-        it('should handle array at path by treating as non-object', () => {
-            const model = { items: [1, 2, 3] };
-            const result = mergeAtPath(model, '/items', { a: 1 });
-            expect(result).toEqual({ items: { a: 1 } });
-        });
-        it('should be immutable - not modify original model', () => {
-            const model = { user: { name: 'John' } };
-            const result = mergeAtPath(model, '/user', { age: 30 });
-            expect(model).toEqual({ user: { name: 'John' } });
-            expect(result).toEqual({ user: { name: 'John', age: 30 } });
-        });
-    });
-});

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

@@ -1,6 +0,0 @@
-/**
- * dataBinding Tests
- *
- * Tests for data binding utility functions used in A2UI 0.9.
- */
-export {};