dalila 1.3.2 → 1.4.0

package/dist/compiler/dalila-lang.js

@@ -1,442 +0,0 @@
-// dalila Template Language Compiler v0.1
-// SPEC Implementation
-export function isElementNode(node) {
-    return node.type === 'element';
-}
-export function isTextNode(node) {
-    return node.type === 'text';
-}
-export function isInterpolationNode(node) {
-    return node.type === 'interpolation';
-}
-// Parser
-export class DalilaParser {
-    constructor(input) {
-        this.position = 0;
-        this.line = 1;
-        this.column = 1;
-        this.rawTextTags = new Set(['pre', 'code']);
-        this.input = input;
-    }
-    parse() {
-        const diagnostics = [];
-        const ast = [];
-        try {
-            while (!this.isAtEnd()) {
-                this.skipWhitespace();
-                if (this.isAtEnd())
-                    break;
-                if (this.peek() === '<') {
-                    const element = this.parseElement();
-                    if (element) {
-                        ast.push(element);
-                    }
-                }
-                else {
-                    // Parse text content
-                    const text = this.parseText(true);
-                    if (text) {
-                        if (isTextNode(text)) {
-                            ast.push(text);
-                        }
-                        else if (isInterpolationNode(text)) {
-                            ast.push(text);
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            diagnostics.push({
-                message: `Parse error: ${errorMessage}`,
-                line: this.line,
-                column: this.column,
-                severity: 'error'
-            });
-        }
-        return { ast, diagnostics };
-    }
-    parseElement() {
-        if (!this.match('<'))
-            return null;
-        const startLocation = this.currentLocation();
-        // Parse tag name
-        const tagName = this.parseTagName();
-        if (!tagName) {
-            throw new Error('Expected tag name after <');
-        }
-        // Parse attributes
-        const attributes = this.parseAttributes();
-        // Check if self-closing
-        const selfClosing = this.match('/>');
-        let children = [];
-        if (!selfClosing) {
-            if (!this.match('>')) {
-                throw new Error('Expected > after tag attributes');
-            }
-            // Parse children until closing tag
-            children = [];
-            const allowInterpolation = !this.rawTextTags.has(tagName);
-            while (!this.isAtEnd() && !this.lookingAt(`</${tagName}`)) {
-                this.skipWhitespace();
-                if (this.lookingAt(`</${tagName}`))
-                    break;
-                if (this.peek() === '<') {
-                    const childElement = this.parseElement();
-                    if (childElement) {
-                        children.push(childElement);
-                    }
-                }
-                else {
-                    const text = this.parseText(allowInterpolation);
-                    if (text) {
-                        children.push(text);
-                    }
-                }
-            }
-            // Parse closing tag
-            if (!this.match(`</${tagName}>`)) {
-                throw new Error(`Expected closing tag </${tagName}>`);
-            }
-        }
-        return {
-            type: 'element',
-            tagName,
-            attributes,
-            children,
-            selfClosing,
-            location: startLocation
-        };
-    }
-    parseTagName() {
-        let name = '';
-        while (!this.isAtEnd() && /[a-zA-Z0-9\-_]/.test(this.peek())) {
-            name += this.advance();
-        }
-        return name || null;
-    }
-    parseAttributes() {
-        const attributes = [];
-        while (!this.isAtEnd() && !['>', '/>'].includes(this.peek(2))) {
-            this.skipWhitespace();
-            if (['>', '/>'].includes(this.peek(2)))
-                break;
-            const attr = this.parseAttribute();
-            if (attr) {
-                attributes.push(attr);
-            }
-        }
-        return attributes;
-    }
-    parseAttribute() {
-        const startLocation = this.currentLocation();
-        // Parse attribute name
-        let name = '';
-        while (!this.isAtEnd() && /[a-zA-Z0-9\-_:]/.test(this.peek())) {
-            name += this.advance();
-        }
-        if (!name)
-            return null;
-        this.skipWhitespace();
-        let value = null;
-        if (this.match('=')) {
-            this.skipWhitespace();
-            if (this.match('"')) {
-                // Parse string literal or interpolation
-                if (this.peek() === '{') {
-                    const interpolation = this.parseInterpolation();
-                    if (interpolation) {
-                        value = interpolation;
-                    }
-                }
-                else {
-                    // Parse string literal
-                    let str = '';
-                    while (!this.isAtEnd() && this.peek() !== '"') {
-                        str += this.advance();
-                    }
-                    value = str;
-                }
-                this.match('"'); // consume closing quote
-            }
-            else if (this.peek() === '{') {
-                value = this.parseInterpolation();
-            }
-        }
-        return {
-            name,
-            value,
-            location: startLocation
-        };
-    }
-    parseInterpolation() {
-        if (!this.match('{'))
-            return null;
-        const startLocation = this.currentLocation();
-        this.skipWhitespace();
-        // Parse identifier
-        let identifier = '';
-        while (!this.isAtEnd() && /[a-zA-Z_$][a-zA-Z0-9_$]*/.test(this.peek())) {
-            identifier += this.advance();
-        }
-        this.skipWhitespace();
-        if (!this.match('}')) {
-            throw new Error('Expected } to close interpolation');
-        }
-        if (!identifier) {
-            throw new Error('Expected identifier in interpolation');
-        }
-        return {
-            type: 'interpolation',
-            identifier,
-            location: startLocation
-        };
-    }
-    parseText(allowInterpolation) {
-        const startLocation = this.currentLocation();
-        let content = '';
-        while (!this.isAtEnd() && this.peek() !== '<') {
-            if (allowInterpolation && this.peek() === '{') {
-                // Found interpolation in text
-                if (content) {
-                    // Return text node up to interpolation
-                    this.backup(content.length);
-                    return {
-                        type: 'text',
-                        content,
-                        location: startLocation
-                    };
-                }
-                // Parse interpolation
-                const interpolation = this.parseInterpolation();
-                if (interpolation) {
-                    return interpolation;
-                }
-            }
-            else {
-                content += this.advance();
-            }
-        }
-        if (!content.trim())
-            return null;
-        return {
-            type: 'text',
-            content,
-            location: startLocation
-        };
-    }
-    skipWhitespace() {
-        while (!this.isAtEnd() && /\s/.test(this.peek())) {
-            if (this.peek() === '\n') {
-                this.line++;
-                this.column = 1;
-            }
-            else {
-                this.column++;
-            }
-            this.position++;
-        }
-    }
-    match(expected) {
-        if (this.lookingAt(expected)) {
-            for (let i = 0; i < expected.length; i++) {
-                if (expected[i] === '\n') {
-                    this.line++;
-                    this.column = 1;
-                }
-                else {
-                    this.column++;
-                }
-                this.position++;
-            }
-            return true;
-        }
-        return false;
-    }
-    lookingAt(expected) {
-        for (let i = 0; i < expected.length; i++) {
-            if (this.position + i >= this.input.length ||
-                this.input[this.position + i] !== expected[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    peek(n = 1) {
-        const start = this.position;
-        return this.input.slice(start, start + n);
-    }
-    advance() {
-        if (this.isAtEnd())
-            return '\0';
-        const char = this.input[this.position++];
-        if (char === '\n') {
-            this.line++;
-            this.column = 1;
-        }
-        else {
-            this.column++;
-        }
-        return char;
-    }
-    backup(count) {
-        for (let i = 0; i < count; i++) {
-            this.position--;
-            const char = this.input[this.position];
-            if (char === '\n') {
-                this.line--;
-                // Note: column would need more complex tracking
-            }
-            else {
-                this.column--;
-            }
-        }
-    }
-    isAtEnd() {
-        return this.position >= this.input.length;
-    }
-    currentLocation() {
-        return {
-            line: this.line,
-            column: this.column,
-            offset: this.position
-        };
-    }
-}
-// Code Generator
-export class DalilaCodeGenerator {
-    constructor() {
-        this.indentLevel = 0;
-        this.output = [];
-    }
-    generate(ast, componentName) {
-        this.output = [];
-        const diagnostics = [];
-        this.emit(`import { watch } from '../core/watch.js';`);
-        this.emit('');
-        this.emit(`export function render${componentName}(ctx: any): Node {`);
-        this.indentLevel++;
-        // Generate root fragment or single element
-        if (ast.length === 1 && ast[0].type === 'element') {
-            this.generateElement(ast[0], 'root');
-        }
-        else {
-            this.emit('const root = document.createDocumentFragment();');
-            for (let i = 0; i < ast.length; i++) {
-                const node = ast[i];
-                const varName = `node_${i}`;
-                if (node.type === 'element') {
-                    this.generateElement(node, varName);
-                }
-                else if (node.type === 'text') {
-                    this.emit(`const ${varName} = document.createTextNode(${JSON.stringify(node.content)});`);
-                }
-                else if (node.type === 'interpolation') {
-                    this.generateTextInterpolation(node, varName);
-                }
-                this.emit(`root.append(${varName});`);
-            }
-        }
-        this.emit('return root;');
-        this.indentLevel--;
-        this.emit('}');
-        // Generate type definition (simplified)
-        const typeDef = this.generateTypeDefinition(componentName, ast);
-        return {
-            source: this.output.join('\n'),
-            typeDefinition: typeDef,
-            diagnostics
-        };
-    }
-    generateElement(node, varName) {
-        this.emit(`const ${varName} = document.createElement(${JSON.stringify(node.tagName)});`);
-        // Generate attributes
-        for (const attr of node.attributes) {
-            this.generateAttribute(varName, attr);
-        }
-        // Generate children
-        for (let i = 0; i < node.children.length; i++) {
-            const child = node.children[i];
-            const childVar = `${varName}_child_${i}`;
-            if (child.type === 'element') {
-                this.generateElement(child, childVar);
-                this.emit(`${varName}.append(${childVar});`);
-            }
-            else if (child.type === 'text') {
-                this.emit(`${varName}.append(${JSON.stringify(child.content)});`);
-            }
-            else if (child.type === 'interpolation') {
-                this.generateTextInterpolation(child, childVar);
-                this.emit(`${varName}.append(${childVar});`);
-            }
-        }
-    }
-    generateAttribute(elementVar, attr) {
-        const attrName = attr.name;
-        if (attr.value === null) {
-            // Boolean attribute
-            this.emit(`${elementVar}.setAttribute(${JSON.stringify(attrName)}, '');`);
-        }
-        else if (typeof attr.value === 'string') {
-            // String literal
-            this.emit(`${elementVar}.setAttribute(${JSON.stringify(attrName)}, ${JSON.stringify(attr.value)});`);
-        }
-        else if (attr.value.type === 'interpolation') {
-            // Dynamic attribute
-            if (attrName.startsWith('on:')) {
-                // Event handler
-                const eventName = attrName.slice(3); // remove 'on:'
-                this.emit(`${elementVar}.addEventListener(${JSON.stringify(eventName)}, ctx.${attr.value.identifier});`);
-            }
-            else {
-                // Attribute binding
-                const watchFn = `() => {
-  const value = ctx.${attr.value.identifier}();
-  if (value == null || value === false) {
-    ${elementVar}.removeAttribute(${JSON.stringify(attrName)});
-  } else {
-    ${elementVar}.setAttribute(${JSON.stringify(attrName)}, String(value));
-  }
-}`;
-                this.emit(`watch(${elementVar}, ${watchFn});`);
-            }
-        }
-    }
-    generateTextInterpolation(node, varName) {
-        this.emit(`const ${varName} = document.createTextNode('');`);
-        const watchFn = `() => {
-  ${varName}.data = String(ctx.${node.identifier}() ?? '');
-}`;
-        this.emit(`watch(${varName}, ${watchFn});`);
-    }
-    generateTypeDefinition(componentName, ast) {
-        // Simplified type generation - in a real implementation this would analyze all usages
-        return `export interface ${componentName}Ctx {
-  // Type definition would be inferred from template usage
-  [key: string]: any;
-}`;
-    }
-    emit(line) {
-        const indent = '  '.repeat(this.indentLevel);
-        this.output.push(indent + line);
-    }
-}
-// Main Compiler
-export function compileDalilaTemplate(template) {
-    const parser = new DalilaParser(template.content);
-    const { ast, diagnostics } = parser.parse();
-    if (diagnostics.some(d => d.severity === 'error')) {
-        return {
-            source: '',
-            typeDefinition: '',
-            diagnostics
-        };
-    }
-    const generator = new DalilaCodeGenerator();
-    const result = generator.generate(ast, template.componentName);
-    return {
-        ...result,
-        diagnostics: [...diagnostics, ...result.diagnostics]
-    };
-}

package/dist/dom/elements.d.ts

@@ -1,15 +0,0 @@
-export declare function div(children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLDivElement;
-export declare function span(children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLSpanElement;
-export declare function p(children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLParagraphElement;
-export declare function h1(children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLHeadingElement;
-export declare function h2(children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLHeadingElement;
-export declare function h3(children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLHeadingElement;
-export declare function button(children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLButtonElement;
-export declare function input(attrs?: Record<string, any>): HTMLInputElement;
-export declare function a(children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLAnchorElement;
-export declare function ul(children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLUListElement;
-export declare function li(children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLLIElement;
-export declare function createElement<K extends keyof HTMLElementTagNameMap>(tag: K, children?: Node | Node[] | string, attrs?: Record<string, any>): HTMLElementTagNameMap[K];
-export declare function fragment(...children: Node[]): DocumentFragment;
-import { Signal } from '../core/signal.js';
-export declare function text(content: string | Signal<any>): Text;

package/dist/dom/elements.js

@@ -1,100 +0,0 @@
-// DOM element creation utilities
-export function div(children, attrs) {
-    return createElement('div', children, attrs);
-}
-export function span(children, attrs) {
-    return createElement('span', children, attrs);
-}
-export function p(children, attrs) {
-    return createElement('p', children, attrs);
-}
-export function h1(children, attrs) {
-    return createElement('h1', children, attrs);
-}
-export function h2(children, attrs) {
-    return createElement('h2', children, attrs);
-}
-export function h3(children, attrs) {
-    return createElement('h3', children, attrs);
-}
-export function button(children, attrs) {
-    return createElement('button', children, attrs);
-}
-export function input(attrs) {
-    return createElement('input', undefined, attrs);
-}
-export function a(children, attrs) {
-    return createElement('a', children, attrs);
-}
-export function ul(children, attrs) {
-    return createElement('ul', children, attrs);
-}
-export function li(children, attrs) {
-    return createElement('li', children, attrs);
-}
-export function createElement(tag, children, attrs) {
-    const element = document.createElement(tag);
-    let resolvedChildren = children;
-    let resolvedAttrs = attrs;
-    const isAttrsObject = (value) => value !== null &&
-        typeof value === 'object' &&
-        !Array.isArray(value) &&
-        !(value instanceof Node);
-    const isChildValue = (value) => value === undefined ||
-        typeof value === 'string' ||
-        value instanceof Node ||
-        Array.isArray(value);
-    if (isAttrsObject(children) && (attrs === undefined || isChildValue(attrs))) {
-        resolvedAttrs = children;
-        resolvedChildren = attrs;
-    }
-    // Set attributes
-    if (resolvedAttrs) {
-        Object.entries(resolvedAttrs).forEach(([key, value]) => {
-            if (key === 'class') {
-                element.className = value;
-            }
-            else if (key === 'style' && typeof value === 'object') {
-                Object.assign(element.style, value);
-            }
-            else if (key.startsWith('on') && typeof value === 'function') {
-                const eventName = key.slice(2).toLowerCase();
-                element.addEventListener(eventName, value);
-            }
-            else {
-                element.setAttribute(key, String(value));
-            }
-        });
-    }
-    // Add children
-    if (resolvedChildren !== undefined) {
-        if (typeof resolvedChildren === 'string') {
-            element.textContent = resolvedChildren;
-        }
-        else {
-            const nodes = Array.isArray(resolvedChildren) ? resolvedChildren : [resolvedChildren];
-            element.append(...nodes);
-        }
-    }
-    return element;
-}
-// Fragment utility
-export function fragment(...children) {
-    const frag = document.createDocumentFragment();
-    frag.append(...children);
-    return frag;
-}
-// Reactive text binding
-import { effect } from '../core/signal.js';
-export function text(content) {
-    const textNode = document.createTextNode('');
-    if (typeof content === 'string') {
-        textNode.textContent = content;
-    }
-    else {
-        effect(() => {
-            textNode.textContent = String(content());
-        });
-    }
-    return textNode;
-}

package/dist/dom/events.d.ts

@@ -1,7 +0,0 @@
-export type EventHandler<T extends Event = Event> = (event: T) => void;
-export declare function on<K extends keyof HTMLElementEventMap>(element: Element, event: K, handler: EventHandler<HTMLElementEventMap[K]>): () => void;
-export declare function once<K extends keyof HTMLElementEventMap>(element: Element, event: K, handler: EventHandler<HTMLElementEventMap[K]>): () => void;
-export declare function preventDefault<T extends Event>(handler: EventHandler<T>): EventHandler<T>;
-export declare function stopPropagation<T extends Event>(handler: EventHandler<T>): EventHandler<T>;
-export declare function debounce<T extends Event>(handler: EventHandler<T>, delay: number): EventHandler<T>;
-export declare function throttle<T extends Event>(handler: EventHandler<T>, delay: number): EventHandler<T>;

package/dist/dom/events.js

@@ -1,47 +0,0 @@
-export function on(element, event, handler) {
-    element.addEventListener(event, handler);
-    return () => element.removeEventListener(event, handler);
-}
-export function once(element, event, handler) {
-    const onceHandler = (e) => {
-        handler(e);
-        element.removeEventListener(event, onceHandler);
-    };
-    element.addEventListener(event, onceHandler);
-    return () => element.removeEventListener(event, onceHandler);
-}
-// Prevent default utility
-export function preventDefault(handler) {
-    return (event) => {
-        event.preventDefault();
-        handler(event);
-    };
-}
-// Stop propagation utility
-export function stopPropagation(handler) {
-    return (event) => {
-        event.stopPropagation();
-        handler(event);
-    };
-}
-// Debounce utility for events
-export function debounce(handler, delay) {
-    let timeoutId = null;
-    return (event) => {
-        if (timeoutId !== null) {
-            clearTimeout(timeoutId);
-        }
-        timeoutId = window.setTimeout(() => handler(event), delay);
-    };
-}
-// Throttle utility for events
-export function throttle(handler, delay) {
-    let lastCall = 0;
-    return (event) => {
-        const now = Date.now();
-        if (now - lastCall >= delay) {
-            lastCall = now;
-            handler(event);
-        }
-    };
-}

package/dist/dom/index.d.ts

@@ -1,2 +0,0 @@
-export * from './elements.js';
-export * from './events.js';

package/dist/dom/index.js

@@ -1,2 +0,0 @@
-export * from './elements.js';
-export * from './events.js';