@allternit/ix 0.1.0 → 0.1.1

package/dist/state/patch.js.bak

@@ -1,437 +0,0 @@
-/**
- * JSON Patch Engine (RFC 6902)
- *
- * Implements JSON Patch operations for state synchronization.
- */
-/**
- * JSON Pointer helpers
- */
-export function decodeJsonPointer(pointer) {
-    if (pointer === '' || pointer === '/')
-        return [];
-    if (!pointer.startsWith('/')) {
-        throw new Error(`Invalid JSON Pointer: ${pointer}`);
-    }
-    return pointer
-        .slice(1)
-        .split('/')
-        .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
-}
-export function encodeJsonPointer(segments) {
-    if (segments.length === 0)
-        return '';
-    return '/' + segments
-        .map((segment) => segment.replace(/~/g, '~0').replace(/\//g, '~1'))
-        .join('/');
-}
-/**
- * Get value at JSON Pointer path
- */
-export function getValueAtPath(obj, pointer) {
-    const segments = decodeJsonPointer(pointer);
-    let current = obj;
-    for (const segment of segments) {
-        if (current === null || typeof current !== 'object') {
-            return undefined;
-        }
-        if (Array.isArray(current)) {
-            const index = segment === '-' ? current.length : parseInt(segment, 10);
-            if (isNaN(index) || index < 0 || index > current.length) {
-                return undefined;
-            }
-            current = current[index];
-        }
-        else {
-            current = current[segment];
-        }
-    }
-    return current;
-}
-/**
- * Set value at JSON Pointer path
- */
-export function setValueAtPath(obj, pointer, value, operation) {
-    const segments = decodeJsonPointer(pointer);
-    if (segments.length === 0) {
-        return operation === 'remove' ? undefined : value;
-    }
-    // Clone to avoid mutation
-    const root = deepClone(obj);
-    let current = root;
-    for (let i = 0; i < segments.length - 1; i++) {
-        const segment = segments[i];
-        const nextSegment = segments[i + 1];
-        if (Array.isArray(current)) {
-            const index = parseInt(segment, 10);
-            if (isNaN(index) || index < 0 || index >= current.length) {
-                throw new Error(`Array index out of bounds: ${segment}`);
-            }
-            // Ensure next level exists
-            if (current[index] === null || typeof current[index] !== 'object') {
-                const isNextArray = !isNaN(parseInt(nextSegment, 10)) || nextSegment === '-';
-                current[index] = isNextArray ? [] : {};
-            }
-            current = current[index];
-        }
-        else {
-            const currentObj = current;
-            if (!(segment in currentObj) || currentObj[segment] === null || typeof currentObj[segment] !== 'object') {
-                const isNextArray = !isNaN(parseInt(nextSegment, 10)) || nextSegment === '-';
-                currentObj[segment] = isNextArray ? [] : {};
-            }
-            current = currentObj[segment];
-        }
-    }
-    const lastSegment = segments[segments.length - 1];
-    if (Array.isArray(current)) {
-        const index = lastSegment === '-' ? current.length : parseInt(lastSegment, 10);
-        if (operation === 'remove') {
-            if (index < 0 || index >= current.length) {
-                throw new Error(`Array index out of bounds: ${lastSegment}`);
-            }
-            current.splice(index, 1);
-        }
-        else if (operation === 'add' && lastSegment === '-') {
-            current.push(value);
-        }
-        else {
-            if (isNaN(index) || index < 0 || (operation === 'replace' && index >= current.length)) {
-                throw new Error(`Invalid array index: ${lastSegment}`);
-            }
-            current[index] = value;
-        }
-    }
-    else {
-        const currentObj = current;
-        if (operation === 'remove') {
-            delete currentObj[lastSegment];
-        }
-        else {
-            currentObj[lastSegment] = value;
-        }
-    }
-    return root;
-}
-/**
- * Deep clone value
- */
-function deepClone(value) {
-    if (value === null || typeof value !== 'object') {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map(deepClone);
-    }
-    if (typeof value === 'object') {
-        const cloned = {};
-        for (const key of Object.keys(value)) {
-            cloned[key] = deepClone(value[key]);
-        }
-        return cloned;
-    }
-    return value;
-}
-/**
- * Deep equality check
- */
-function deepEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a === null || b === null)
-        return false;
-    if (typeof a !== typeof b)
-        return false;
-    if (typeof a !== 'object')
-        return false;
-    if (Array.isArray(a) !== Array.isArray(b))
-        return false;
-    if (Array.isArray(a)) {
-        if (a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i++) {
-            if (!deepEqual(a[i], b[i]))
-                return false;
-        }
-        return true;
-    }
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length)
-        return false;
-    for (const key of keysA) {
-        if (!keysB.includes(key))
-            return false;
-        if (!deepEqual(a[key], b[key])) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Apply single patch operation
- */
-export function applyOperation(state, operation) {
-    try {
-        switch (operation.op) {
-            case 'add': {
-                if (operation.value === undefined) {
-                    return { success: false, newState: state, error: 'Add operation requires value' };
-                }
-                const newState = setValueAtPath(state, operation.path, operation.value, 'add');
-                return { success: true, newState: newState };
-            }
-            case 'remove': {
-                if (!getValueAtPath(state, operation.path)) {
-                    return { success: false, newState: state, error: `Path not found: ${operation.path}` };
-                }
-                const newState = setValueAtPath(state, operation.path, undefined, 'remove');
-                return { success: true, newState: newState };
-            }
-            case 'replace': {
-                if (operation.value === undefined) {
-                    return { success: false, newState: state, error: 'Replace operation requires value' };
-                }
-                if (getValueAtPath(state, operation.path) === undefined) {
-                    return { success: false, newState: state, error: `Path not found: ${operation.path}` };
-                }
-                const newState = setValueAtPath(state, operation.path, operation.value, 'replace');
-                return { success: true, newState: newState };
-            }
-            case 'move': {
-                if (!operation.from) {
-                    return { success: false, newState: state, error: 'Move operation requires from path' };
-                }
-                const value = getValueAtPath(state, operation.from);
-                if (value === undefined) {
-                    return { success: false, newState: state, error: `Source path not found: ${operation.from}` };
-                }
-                let newState = setValueAtPath(state, operation.from, undefined, 'remove');
-                newState = setValueAtPath(newState, operation.path, value, 'add');
-                return { success: true, newState: newState };
-            }
-            case 'copy': {
-                if (!operation.from) {
-                    return { success: false, newState: state, error: 'Copy operation requires from path' };
-                }
-                const value = getValueAtPath(state, operation.from);
-                if (value === undefined) {
-                    return { success: false, newState: state, error: `Source path not found: ${operation.from}` };
-                }
-                const newState = setValueAtPath(state, operation.path, deepClone(value), 'add');
-                return { success: true, newState: newState };
-            }
-            case 'test': {
-                if (operation.value === undefined) {
-                    return { success: false, newState: state, error: 'Test operation requires value' };
-                }
-                const currentValue = getValueAtPath(state, operation.path);
-                if (!deepEqual(currentValue, operation.value)) {
-                    return {
-                        success: false,
-                        newState: state,
-                        error: `Test failed: expected ${JSON.stringify(operation.value)}, got ${JSON.stringify(currentValue)}`
-                    };
-                }
-                return { success: true, newState: state };
-            }
-            default:
-                return { success: false, newState: state, error: `Unknown operation: ${operation.op}` };
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            newState: state,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-/**
- * Apply JSON Patch to state
- */
-export function applyPatch(state, patch) {
-    let currentState = deepClone(state);
-    for (let i = 0; i < patch.length; i++) {
-        const operation = patch[i];
-        const result = applyOperation(currentState, operation);
-        if (!result.success) {
-            return {
-                success: false,
-                operations: patch.slice(0, i + 1),
-                failedAt: i,
-                error: result.error,
-            };
-        }
-        currentState = result.newState;
-    }
-    return {
-        success: true,
-        operations: patch,
-        newState: currentState,
-    };
-}
-/**
- * Apply patch to state store
- */
-export function applyPatchToStore(store, patch) {
-    const snapshot = store.snapshot();
-    const result = applyPatch(snapshot, patch);
-    if (result.success) {
-        store.restore(result.operations.reduce((state, op) => {
-            if (op.op !== 'test') {
-                const { newState } = applyOperation(state, op);
-                return newState;
-            }
-            return state;
-        }, snapshot));
-    }
-    return result;
-}
-/**
- * Generate JSON Patch from two objects (diff)
- */
-export function generatePatch(from, to, path = '') {
-    const patch = [];
-    // Handle primitive types
-    if (typeof from !== typeof to || (typeof from !== 'object' && from !== to)) {
-        if (from === undefined) {
-            patch.push({ op: 'add', path, value: to });
-        }
-        else if (to === undefined) {
-            patch.push({ op: 'remove', path });
-        }
-        else {
-            patch.push({ op: 'replace', path, value: to });
-        }
-        return patch;
-    }
-    // Handle null
-    if (from === null || to === null) {
-        if (from !== to) {
-            patch.push({ op: 'replace', path, value: to });
-        }
-        return patch;
-    }
-    // Handle arrays
-    if (Array.isArray(from) && Array.isArray(to)) {
-        // Simple array diff - could be optimized with LCS
-        const maxLen = Math.max(from.length, to.length);
-        for (let i = 0; i < maxLen; i++) {
-            const itemPath = path + '/' + i;
-            if (i >= from.length) {
-                patch.push({ op: 'add', path: itemPath, value: to[i] });
-            }
-            else if (i >= to.length) {
-                patch.push({ op: 'remove', path: itemPath });
-            }
-            else {
-                patch.push(...generatePatch(from[i], to[i], itemPath));
-            }
-        }
-        return patch;
-    }
-    // Handle objects
-    if (typeof from === 'object' && typeof to === 'object') {
-        const fromKeys = new Set(Object.keys(from));
-        const toKeys = new Set(Object.keys(to));
-        const allKeys = new Set([...fromKeys, ...toKeys]);
-        for (const key of allKeys) {
-            const keyPath = path ? `${path}/${key}` : `/${key}`;
-            if (!fromKeys.has(key)) {
-                // Added key
-                patch.push({ op: 'add', path: keyPath, value: to[key] });
-            }
-            else if (!toKeys.has(key)) {
-                // Removed key
-                patch.push({ op: 'remove', path: keyPath });
-            }
-            else {
-                // Modified key
-                patch.push(...generatePatch(from[key], to[key], keyPath));
-            }
-        }
-        return patch;
-    }
-    return patch;
-}
-/**
- * Invert a patch for undo functionality
- */
-export function invertPatch(patch, state) {
-    const inverted = [];
-    // Process in reverse order
-    for (let i = patch.length - 1; i >= 0; i--) {
-        const op = patch[i];
-        switch (op.op) {
-            case 'add': {
-                // Undo add -> remove
-                inverted.push({ op: 'remove', path: op.path });
-                break;
-            }
-            case 'remove': {
-                // Undo remove -> add with original value
-                const originalValue = getValueAtPath(state, op.path);
-                inverted.push({ op: 'add', path: op.path, value: originalValue });
-                break;
-            }
-            case 'replace': {
-                // Undo replace -> replace with original value
-                const originalValue = getValueAtPath(state, op.path);
-                inverted.push({ op: 'replace', path: op.path, value: originalValue });
-                break;
-            }
-            case 'move': {
-                // Undo move -> move back
-                if (op.from) {
-                    inverted.push({ op: 'move', path: op.from, from: op.path });
-                }
-                break;
-            }
-            case 'copy': {
-                // Undo copy -> remove
-                inverted.push({ op: 'remove', path: op.path });
-                break;
-            }
-            // test operations are self-inverting
-            case 'test': {
-                inverted.push(op);
-                break;
-            }
-        }
-    }
-    return inverted;
-}
-/**
- * Validate patch operation
- */
-export function validateOperation(op) {
-    if (!op.op || !['add', 'remove', 'replace', 'move', 'copy', 'test'].includes(op.op)) {
-        return { valid: false, error: `Invalid operation: ${op.op}` };
-    }
-    if (!op.path || !op.path.startsWith('/')) {
-        return { valid: false, error: `Invalid path: ${op.path}` };
-    }
-    if ((op.op === 'add' || op.op === 'replace' || op.op === 'test') && op.value === undefined) {
-        return { valid: false, error: `${op.op} operation requires value` };
-    }
-    if ((op.op === 'move' || op.op === 'copy') && !op.from) {
-        return { valid: false, error: `${op.op} operation requires from path` };
-    }
-    if ((op.op === 'move' || op.op === 'copy') && op.from && !op.from.startsWith('/')) {
-        return { valid: false, error: `Invalid from path: ${op.from}` };
-    }
-    return { valid: true };
-}
-/**
- * Validate entire patch
- */
-export function validatePatch(patch) {
-    for (let i = 0; i < patch.length; i++) {
-        const result = validateOperation(patch[i]);
-        if (!result.valid) {
-            return { valid: false, error: result.error, index: i };
-        }
-    }
-    return { valid: true };
-}
-//# sourceMappingURL=patch.js.map

package/dist/state/store.d.ts.bak

@@ -1,50 +0,0 @@
-/**
- * State Store
- *
- * Scoped state management for A2R-IX with binding support.
- */
-import type { StateVariable, ComputedValue } from '../types';
-export interface StateStore {
-    /** Get value at path */
-    get<T>(path: string): T | undefined;
-    /** Set value at path */
-    set<T>(path: string, value: T): void;
-    /** Subscribe to changes */
-    subscribe(path: string, callback: (value: unknown) => void): () => void;
-    /** Compute derived value */
-    compute<T>(name: string, deps: string[], compute: () => T): void;
-    /** Bind component prop to state */
-    bind(componentId: string, prop: string, statePath: string): void;
-    /** Get all bindings for a component */
-    getBindings(componentId: string): Array<{
-        prop: string;
-        statePath: string;
-    }>;
-    /** Batch multiple updates */
-    batch(updates: Record<string, unknown>): void;
-    /** Get state snapshot */
-    snapshot(): Record<string, unknown>;
-    /** Restore from snapshot */
-    restore(snapshot: Record<string, unknown>): void;
-    /** Reset to initial values */
-    reset(): void;
-}
-export interface StateStoreConfig {
-    /** Initial state values */
-    initial?: Record<string, unknown>;
-    /** State variable definitions */
-    variables?: StateVariable[];
-    /** Computed values */
-    computed?: ComputedValue[];
-    /** Scope ID (for persistence) */
-    scopeId?: string;
-    /** Persist to storage */
-    persist?: boolean;
-}
-/**
- * Create state store
- */
-export declare function createStateStore(config?: StateStoreConfig): StateStore;
-export declare function getStateStore(scopeId: string, config?: StateStoreConfig): StateStore;
-export declare function clearStateStore(scopeId: string): void;
-//# sourceMappingURL=store.d.ts.map