dalila 1.1.0 → 1.1.1

package/dist/compiler/dalila-lang.d.ts

@@ -0,0 +1,85 @@
+export interface DalilaTemplate {
+    path: string;
+    content: string;
+    componentName: string;
+}
+export interface CompilationResult {
+    source: string;
+    typeDefinition: string;
+    diagnostics: Diagnostic[];
+}
+export interface Diagnostic {
+    message: string;
+    line: number;
+    column: number;
+    severity: 'error' | 'warning' | 'info';
+}
+export interface ElementNode {
+    type: 'element';
+    tagName: string;
+    attributes: Attribute[];
+    children: Node[];
+    selfClosing: boolean;
+    location: Location;
+}
+export interface TextNode {
+    type: 'text';
+    content: string;
+    location: Location;
+}
+export interface InterpolationNode {
+    type: 'interpolation';
+    identifier: string;
+    location: Location;
+}
+export interface Attribute {
+    name: string;
+    value: string | InterpolationNode | null;
+    location: Location;
+}
+export interface Location {
+    line: number;
+    column: number;
+    offset: number;
+}
+export type Node = ElementNode | TextNode | InterpolationNode;
+export declare function isElementNode(node: Node): node is ElementNode;
+export declare function isTextNode(node: Node): node is TextNode;
+export declare function isInterpolationNode(node: Node): node is InterpolationNode;
+export declare class DalilaParser {
+    private input;
+    private position;
+    private line;
+    private column;
+    private rawTextTags;
+    constructor(input: string);
+    parse(): {
+        ast: Node[];
+        diagnostics: Diagnostic[];
+    };
+    private parseElement;
+    private parseTagName;
+    private parseAttributes;
+    private parseAttribute;
+    private parseInterpolation;
+    private parseText;
+    private skipWhitespace;
+    private match;
+    private lookingAt;
+    private peek;
+    private advance;
+    private backup;
+    private isAtEnd;
+    private currentLocation;
+}
+export declare class DalilaCodeGenerator {
+    private indentLevel;
+    private output;
+    generate(ast: Node[], componentName: string): CompilationResult;
+    private generateElement;
+    private generateAttribute;
+    private generateTextInterpolation;
+    private generateTypeDefinition;
+    private emit;
+}
+export declare function compileDalilaTemplate(template: DalilaTemplate): CompilationResult;

package/dist/compiler/dalila-lang.js

@@ -0,0 +1,442 @@
+// 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/context/context.d.ts

@@ -0,0 +1,7 @@
+export interface ContextToken<T> {
+    readonly name?: string;
+    readonly _brand: T;
+}
+export declare function createContext<T>(name?: string): ContextToken<T>;
+export declare function provide<T>(token: ContextToken<T>, value: T): void;
+export declare function inject<T>(token: ContextToken<T>): T;

package/dist/context/context.js

@@ -0,0 +1,61 @@
+import { getCurrentScope } from '../core/scope.js';
+export function createContext(name) {
+    return { name };
+}
+class ContextRegistry {
+    constructor(parent) {
+        this.contexts = new Map();
+        this.parent = parent;
+    }
+    set(token, value) {
+        this.contexts.set(token, { token, value });
+    }
+    get(token) {
+        const value = this.contexts.get(token);
+        if (value !== undefined) {
+            return value.value;
+        }
+        if (this.parent) {
+            return this.parent.get(token);
+        }
+        return undefined;
+    }
+}
+const scopeRegistries = new WeakMap();
+function getScopeRegistry(scope) {
+    let registry = scopeRegistries.get(scope);
+    if (!registry) {
+        const parentScope = getCurrentScope();
+        const parentRegistry = parentScope ? scopeRegistries.get(parentScope) : undefined;
+        registry = new ContextRegistry(parentRegistry);
+        scopeRegistries.set(scope, registry);
+    }
+    return registry;
+}
+export function provide(token, value) {
+    const scope = getCurrentScope();
+    if (!scope) {
+        throw new Error('provide() must be called within a scope');
+    }
+    const registry = getScopeRegistry(scope);
+    registry.set(token, value);
+}
+export function inject(token) {
+    const scope = getCurrentScope();
+    if (!scope) {
+        throw new Error('inject() must be called within a scope');
+    }
+    let currentScope = scope;
+    while (currentScope) {
+        const registry = scopeRegistries.get(currentScope);
+        if (registry) {
+            const value = registry.get(token);
+            if (value !== undefined) {
+                return value;
+            }
+        }
+        // For now, we don't have parent scope tracking, so we break
+        break;
+    }
+    throw new Error(`Context ${token.name || 'unnamed'} not found`);
+}

package/dist/context/index.d.ts

@@ -0,0 +1 @@
+export * from './context.js';

package/dist/context/index.js

@@ -0,0 +1 @@
+export * from './context.js';

package/dist/core/dev.d.ts

@@ -0,0 +1,23 @@
+export declare function setDevMode(enabled: boolean): void;
+export declare function isInDevMode(): boolean;
+export declare function warnIfAsyncEffectWithoutAbort(): void;
+export declare function warnIfLayoutReadInMutate(): void;
+export declare function warnIfSignalUsedOutsideScope(): void;
+export declare function checkLayoutThrashing(): Promise<void>;
+export declare function monitorPerformance(): void;
+export declare function detectMemoryLeaks(): void;
+export declare function initDevTools(): Promise<void>;
+export declare function inspectSignal<T>(signal: () => T): {
+    value: T;
+    subscribers: number;
+};
+export declare function trackEffect(fn: Function): () => void;
+export declare function getActiveEffects(): Array<{
+    id: number;
+    fn: Function;
+    stack: string;
+}>;
+export declare function getCurrentScopeInfo(): {
+    cleanupCount: number;
+    effectCount: number;
+};