@allternit/ix 0.1.0 → 0.1.1

package/dist/state/store.js.bak

@@ -1,246 +0,0 @@
-/**
- * State Store
- *
- * Scoped state management for A2R-IX with binding support.
- */
-/**
- * Create state store
- */
-export function createStateStore(config = {}) {
-    const state = new Map();
-    const subscribers = new Map();
-    const bindings = new Map();
-    const computedValues = new Map();
-    const computedCache = new Map();
-    const dirtyComputed = new Set();
-    // Initialize with initial values
-    if (config.initial) {
-        Object.entries(config.initial).forEach(([key, value]) => {
-            state.set(key, value);
-        });
-    }
-    // Initialize variables with defaults
-    config.variables?.forEach((variable) => {
-        if (!state.has(variable.path) && variable.default !== undefined) {
-            state.set(variable.path, variable.default);
-        }
-    });
-    // Notify subscribers
-    function notify(path, value) {
-        const pathSubscribers = subscribers.get(path);
-        if (pathSubscribers) {
-            pathSubscribers.forEach((cb) => cb(value));
-        }
-        // Notify parent path subscribers
-        const parts = path.split('.');
-        while (parts.length > 1) {
-            parts.pop();
-            const parentPath = parts.join('.');
-            const parentSubscribers = subscribers.get(parentPath);
-            if (parentSubscribers) {
-                const parentValue = get(parentPath);
-                parentSubscribers.forEach((cb) => cb(parentValue));
-            }
-        }
-        // Mark computed values as dirty
-        computedValues.forEach((computed, name) => {
-            if (computed.deps.some((dep) => path.startsWith(dep) || dep.startsWith(path))) {
-                dirtyComputed.add(name);
-            }
-        });
-    }
-    // Get value at path
-    function get(path) {
-        // Check if it's a computed value
-        if (computedValues.has(path)) {
-            return getComputed(path);
-        }
-        const parts = path.split('.');
-        let current = Object.fromEntries(state);
-        for (const part of parts) {
-            if (current && typeof current === 'object') {
-                current = current[part];
-            }
-            else {
-                return undefined;
-            }
-        }
-        return current;
-    }
-    // Get computed value
-    function getComputed(name) {
-        const computed = computedValues.get(name);
-        if (!computed)
-            return undefined;
-        // Return cached value if not dirty
-        if (!dirtyComputed.has(name) && computedCache.has(name)) {
-            return computedCache.get(name);
-        }
-        // Recompute
-        const value = computed.compute();
-        computedCache.set(name, value);
-        dirtyComputed.delete(name);
-        return value;
-    }
-    // Set value at path
-    function set(path, value) {
-        const parts = path.split('.');
-        if (parts.length === 1) {
-            state.set(path, value);
-        }
-        else {
-            // Handle nested paths
-            const rootKey = parts[0];
-            let root = state.get(rootKey);
-            if (!root || typeof root !== 'object') {
-                root = {};
-                state.set(rootKey, root);
-            }
-            let current = root;
-            for (let i = 1; i < parts.length - 1; i++) {
-                const part = parts[i];
-                if (!current[part] || typeof current[part] !== 'object') {
-                    current[part] = {};
-                }
-                current = current[part];
-            }
-            current[parts[parts.length - 1]] = value;
-            state.set(rootKey, { ...root });
-        }
-        notify(path, value);
-        // Persist if enabled
-        if (config.persist && config.scopeId) {
-            persistState();
-        }
-    }
-    // Subscribe to path changes
-    function subscribe(path, callback) {
-        if (!subscribers.has(path)) {
-            subscribers.set(path, new Set());
-        }
-        subscribers.get(path).add(callback);
-        // Return unsubscribe function
-        return () => {
-            subscribers.get(path)?.delete(callback);
-        };
-    }
-    // Register computed value
-    function compute(name, deps, computeFn) {
-        computedValues.set(name, { deps, compute: computeFn });
-        // Subscribe to dependencies
-        deps.forEach((dep) => {
-            subscribe(dep, () => {
-                dirtyComputed.add(name);
-                notify(name, getComputed(name));
-            });
-        });
-    }
-    // Bind component prop to state
-    function bind(componentId, prop, statePath) {
-        if (!bindings.has(componentId)) {
-            bindings.set(componentId, new Map());
-        }
-        bindings.get(componentId).set(prop, statePath);
-    }
-    // Get bindings for component
-    function getBindings(componentId) {
-        const componentBindings = bindings.get(componentId);
-        if (!componentBindings)
-            return [];
-        return Array.from(componentBindings.entries()).map(([prop, statePath]) => ({
-            prop,
-            statePath,
-        }));
-    }
-    // Batch updates
-    function batch(updates) {
-        Object.entries(updates).forEach(([path, value]) => {
-            set(path, value);
-        });
-    }
-    // Get snapshot
-    function snapshot() {
-        return Object.fromEntries(state);
-    }
-    // Restore from snapshot
-    function restore(data) {
-        Object.entries(data).forEach(([key, value]) => {
-            state.set(key, value);
-            notify(key, value);
-        });
-    }
-    // Reset to initial
-    function reset() {
-        state.clear();
-        computedCache.clear();
-        dirtyComputed.clear();
-        if (config.initial) {
-            Object.entries(config.initial).forEach(([key, value]) => {
-                state.set(key, value);
-            });
-        }
-        // Notify all subscribers
-        subscribers.forEach((cbs, path) => {
-            const value = get(path);
-            cbs.forEach((cb) => cb(value));
-        });
-    }
-    // Persist to localStorage
-    function persistState() {
-        if (typeof localStorage === 'undefined')
-            return;
-        try {
-            const key = `a2r-ix-state-${config.scopeId}`;
-            localStorage.setItem(key, JSON.stringify(Object.fromEntries(state)));
-        }
-        catch (error) {
-            console.error('Failed to persist state:', error);
-        }
-    }
-    // Load from localStorage
-    function loadPersistedState() {
-        if (typeof localStorage === 'undefined' || !config.scopeId)
-            return;
-        try {
-            const key = `a2r-ix-state-${config.scopeId}`;
-            const data = localStorage.getItem(key);
-            if (data) {
-                const parsed = JSON.parse(data);
-                Object.entries(parsed).forEach(([key, value]) => {
-                    state.set(key, value);
-                });
-            }
-        }
-        catch (error) {
-            console.error('Failed to load persisted state:', error);
-        }
-    }
-    // Load persisted state on init
-    if (config.persist && config.scopeId) {
-        loadPersistedState();
-    }
-    return {
-        get,
-        set,
-        subscribe,
-        compute,
-        bind,
-        getBindings,
-        batch,
-        snapshot,
-        restore,
-        reset,
-    };
-}
-// Global stores
-const stores = new Map();
-export function getStateStore(scopeId, config) {
-    if (!stores.has(scopeId)) {
-        stores.set(scopeId, createStateStore({ ...config, scopeId }));
-    }
-    return stores.get(scopeId);
-}
-export function clearStateStore(scopeId) {
-    stores.delete(scopeId);
-}
-//# sourceMappingURL=store.js.map

package/dist/svelte/index.d.ts.bak

@@ -1,15 +0,0 @@
-/**
- * Svelte Renderer
- *
- * Generates Svelte component code from A2R-IX UI IR.
- *
- * @example
- * ```typescript
- * import { createSvelteRenderer, compileToSvelte } from '@allternit/ix/svelte';
- *
- * const svelteCode = compileToSvelte(uiDefinition);
- * // Use with Svelte compiler
- * ```
- */
-export { createSvelteRenderer, compileToSvelte, type SvelteRenderer, type SvelteRendererConfig, } from './renderer';
-//# sourceMappingURL=index.d.ts.map

package/dist/svelte/index.js.bak

@@ -1,15 +0,0 @@
-/**
- * Svelte Renderer
- *
- * Generates Svelte component code from A2R-IX UI IR.
- *
- * @example
- * ```typescript
- * import { createSvelteRenderer, compileToSvelte } from '@allternit/ix/svelte';
- *
- * const svelteCode = compileToSvelte(uiDefinition);
- * // Use with Svelte compiler
- * ```
- */
-export { createSvelteRenderer, compileToSvelte, } from './renderer';
-//# sourceMappingURL=index.js.map

package/dist/svelte/renderer.d.ts.bak

@@ -1,35 +0,0 @@
-/**
- * Svelte Renderer for A2R-IX
- *
- * Renders A2R-IX UI IR to Svelte components.
- */
-import type { UIRoot, UIComponent } from '../types';
-import type { StateStore } from '../state/store';
-import type { ComponentCatalog } from '../catalog/registry';
-export interface SvelteRendererConfig {
-    /** Component catalog */
-    catalog?: ComponentCatalog;
-    /** Initial state store */
-    stateStore?: StateStore;
-    /** Component mapping (type -> Svelte component) */
-    components?: Record<string, unknown>;
-    /** Event handler */
-    onEvent?: (name: string, payload: unknown) => void;
-    /** Error handler */
-    onError?: (error: Error, componentId?: string) => void;
-}
-export interface SvelteRenderer {
-    /** Generate Svelte component code from UI root */
-    generateComponent(root: UIRoot): string;
-    /** Generate Svelte template from component */
-    generateTemplate(component: UIComponent, depth?: number): string;
-}
-/**
- * Create Svelte renderer
- */
-export declare function createSvelteRenderer(config: SvelteRendererConfig): SvelteRenderer;
-/**
- * Compile A2R-IX UI to Svelte component
- */
-export declare function compileToSvelte(root: UIRoot, config?: SvelteRendererConfig): string;
-//# sourceMappingURL=renderer.d.ts.map

package/dist/svelte/renderer.js.bak

@@ -1,317 +0,0 @@
-/**
- * Svelte Renderer for A2R-IX
- *
- * Renders A2R-IX UI IR to Svelte components.
- */
-import { createDefaultCatalog } from '../catalog/registry';
-/**
- * Create Svelte renderer
- */
-export function createSvelteRenderer(config) {
-    const catalog = config.catalog ?? createDefaultCatalog();
-    const customComponents = config.components ?? {};
-    const store = config.stateStore;
-    /**
-     * Generate full Svelte component code
-     */
-    function generateComponent(root) {
-        const script = generateScript(root);
-        const template = root.components.map((c) => generateTemplate(c)).join('\n');
-        const style = root.css ? `<style>\n${root.css}\n</style>` : '';
-        return `<script>
-${script}
-</script>
-
-${template}
-
-${style}`;
-    }
-    /**
-     * Generate script section
-     */
-    function generateScript(root) {
-        const lines = [
-            '// Auto-generated A2R-IX Svelte component',
-            '',
-            '// State bindings',
-        ];
-        // Generate state variable declarations
-        root.state.variables.forEach((variable) => {
-            const defaultValue = variable.default !== undefined
-                ? JSON.stringify(variable.default)
-                : getDefaultForType(variable.type);
-            lines.push(`export let ${sanitizeName(variable.path)} = ${defaultValue};`);
-        });
-        // Generate computed values
-        lines.push('');
-        lines.push('// Computed values');
-        root.state.computed?.forEach((computed) => {
-            lines.push(`$: ${computed.name} = ${generateExpression(computed.compute)};`);
-        });
-        // Generate action handlers
-        lines.push('');
-        lines.push('// Action handlers');
-        root.actions.forEach((action) => {
-            lines.push(`function handle_${action.id}(event) {`);
-            lines.push(`  dispatch('${action.id}', { event, ...${JSON.stringify(action.handler)} });`);
-            lines.push('}');
-        });
-        // Event dispatcher
-        if (root.actions.length > 0) {
-            lines.unshift("import { createEventDispatcher } from 'svelte';");
-            lines.unshift('');
-            lines.unshift('const dispatch = createEventDispatcher();');
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Generate template for a component
-     */
-    function generateTemplate(component, depth = 0) {
-        const indent = '  '.repeat(depth);
-        // Handle condition
-        if (component.condition) {
-            const condition = generateExpression(component.condition);
-            const inner = generateSingleTemplate(component, depth + 1);
-            return `${indent}{#if ${condition}}\n${inner}\n${indent}{/if}`;
-        }
-        // Handle repeat
-        if (component.repeat) {
-            return generateRepeatTemplate(component, depth);
-        }
-        return generateSingleTemplate(component, depth);
-    }
-    /**
-     * Generate single component template (no condition/repeat)
-     */
-    function generateSingleTemplate(component, depth) {
-        const indent = '  '.repeat(depth);
-        const tag = getComponentTag(component.type);
-        const props = generateProps(component);
-        const events = generateEvents(component);
-        const propString = [...props, ...events].join(' ');
-        if (component.children && component.children.length > 0) {
-            const children = component.children.map((c) => generateTemplate(c, depth + 1)).join('\n');
-            return `${indent}<${tag}${propString ? ' ' + propString : ''}>\n${children}\n${indent}</${tag}>`;
-        }
-        // Self-closing or with text content
-        const textContent = component.props?.children ? String(component.props.children) : '';
-        if (textContent) {
-            return `${indent}<${tag}${propString ? ' ' + propString : ''}>${textContent}</${tag}>`;
-        }
-        return `${indent}<${tag}${propString ? ' ' + propString : ''} />`;
-    }
-    /**
-     * Generate repeat template
-     */
-    function generateRepeatTemplate(component, depth) {
-        const indent = '  '.repeat(depth);
-        const repeat = component.repeat;
-        const tag = getComponentTag(component.type);
-        const props = generateProps(component);
-        const events = generateEvents(component);
-        const propString = [...props, ...events].join(' ');
-        const asVar = sanitizeName(repeat.as);
-        const indexVar = repeat.indexAs ? sanitizeName(repeat.indexAs) : 'index';
-        let eachBlock = `${indent}{#each ${sanitizeName(repeat.items)} as ${asVar}, ${indexVar}`;
-        if (repeat.filter) {
-            const filterExpr = generateExpression(repeat.filter);
-            // Note: Svelte doesn't have built-in filter, we'd need to use a computed
-            eachBlock += ` (${filterExpr})`;
-        }
-        eachBlock += '}';
-        // Generate inner content
-        let innerContent;
-        if (component.children && component.children.length > 0) {
-            const children = component.children.map((c) => generateTemplate(c, depth + 1)).join('\n');
-            innerContent = `<${tag}${propString ? ' ' + propString : ''}>\n${children}\n${indent}  </${tag}>`;
-        }
-        else {
-            innerContent = `<${tag}${propString ? ' ' + propString : ''} />`;
-        }
-        return `${eachBlock}\n${indent}  ${innerContent}\n${indent}{/each}`;
-    }
-    /**
-     * Generate props string
-     */
-    function generateProps(component) {
-        const props = [];
-        // Regular props
-        Object.entries(component.props || {}).forEach(([key, value]) => {
-            if (key !== 'children') {
-                if (typeof value === 'string') {
-                    props.push(`${key}="${escapeHtml(value)}"`);
-                }
-                else if (typeof value === 'boolean') {
-                    if (value)
-                        props.push(key);
-                }
-                else if (typeof value === 'number') {
-                    props.push(`${key}={${value}}`);
-                }
-                else {
-                    props.push(`${key}={${JSON.stringify(value)}}`);
-                }
-            }
-        });
-        // Bindings
-        component.bindings?.forEach((binding) => {
-            const stateVar = sanitizeName(binding.statePath);
-            if (binding.direction === 'two-way') {
-                props.push(`bind:${binding.prop}={${stateVar}}`);
-            }
-            else {
-                props.push(`${binding.prop}={${stateVar}}`);
-            }
-        });
-        return props;
-    }
-    /**
-     * Generate event handlers
-     */
-    function generateEvents(component) {
-        const events = [];
-        component.events?.forEach((event) => {
-            const handler = `handle_${event.action}`;
-            const params = event.params ? `({ ...event.detail, ...${JSON.stringify(event.params)} })` : 'event';
-            events.push(`on:${getSvelteEventName(event.event)}={() => ${handler}(${params})}`);
-        });
-        return events;
-    }
-    /**
-     * Get component tag name
-     */
-    function getComponentTag(type) {
-        // Map built-ins to HTML or custom components
-        const tagMap = {
-            Box: 'div',
-            Stack: 'div',
-            Text: 'span',
-            Heading: 'h1',
-            Paragraph: 'p',
-            Button: 'button',
-            Input: 'input',
-            TextArea: 'textarea',
-            Select: 'select',
-            Card: 'div',
-            Image: 'img',
-            Icon: 'span',
-            Badge: 'span',
-            List: 'ul',
-            Table: 'table',
-        };
-        return customComponents[type] ? type : tagMap[type] || type.toLowerCase();
-    }
-    /**
-     * Convert event name to Svelte format
-     */
-    function getSvelteEventName(event) {
-        // Remove 'on' prefix and lowercase
-        if (event.startsWith('on')) {
-            return event.slice(2).toLowerCase();
-        }
-        return event.toLowerCase();
-    }
-    /**
-     * Generate expression string
-     */
-    function generateExpression(expr) {
-        if (expr === null)
-            return 'null';
-        if (typeof expr === 'string')
-            return sanitizeName(expr);
-        if (typeof expr === 'number')
-            return String(expr);
-        if (typeof expr === 'boolean')
-            return String(expr);
-        // Handle expression objects
-        if (typeof expr === 'object') {
-            if ('$path' in expr) {
-                return sanitizeName(expr.$path);
-            }
-            if ('$expr' in expr) {
-                return expr.$expr;
-            }
-            if ('$cond' in expr) {
-                const [cond, trueVal, falseVal] = expr.$cond;
-                return `${generateExpression(cond)} ? ${generateExpression(trueVal)} : ${generateExpression(falseVal)}`;
-            }
-            if ('$and' in expr) {
-                const arr = expr.$and;
-                return arr.map(generateExpression).join(' && ');
-            }
-            if ('$or' in expr) {
-                const arr = expr.$or;
-                return arr.map(generateExpression).join(' || ');
-            }
-            if ('$not' in expr) {
-                return `!${generateExpression(expr.$not)}`;
-            }
-            if ('$eq' in expr) {
-                const [a, b] = expr.$eq;
-                return `${generateExpression(a)} === ${generateExpression(b)}`;
-            }
-            if ('$gt' in expr) {
-                const [a, b] = expr.$gt;
-                return `${generateExpression(a)} > ${generateExpression(b)}`;
-            }
-            if ('$lt' in expr) {
-                const [a, b] = expr.$lt;
-                return `${generateExpression(a)} < ${generateExpression(b)}`;
-            }
-            if ('$add' in expr) {
-                const [a, b] = expr.$add;
-                return `${generateExpression(a)} + ${generateExpression(b)}`;
-            }
-        }
-        return String(expr);
-    }
-    /**
-     * Get default value for type
-     */
-    function getDefaultForType(type) {
-        switch (type) {
-            case 'string':
-                return "''";
-            case 'number':
-                return '0';
-            case 'boolean':
-                return 'false';
-            case 'array':
-                return '[]';
-            case 'object':
-                return '{}';
-            default:
-                return 'undefined';
-        }
-    }
-    /**
-     * Sanitize variable name
-     */
-    function sanitizeName(path) {
-        return path.replace(/\./g, '_').replace(/[^a-zA-Z0-9_]/g, '');
-    }
-    /**
-     * Escape HTML for attributes
-     */
-    function escapeHtml(text) {
-        return text
-            .replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;')
-            .replace(/'/g, '&#039;');
-    }
-    return {
-        generateComponent,
-        generateTemplate,
-    };
-}
-/**
- * Compile A2R-IX UI to Svelte component
- */
-export function compileToSvelte(root, config = {}) {
-    const renderer = createSvelteRenderer(config);
-    return renderer.generateComponent(root);
-}
-//# sourceMappingURL=renderer.js.map