gonia 0.0.3 → 0.1.1

package/dist/client/hydrate.d.ts

@@ -26,7 +26,7 @@ export declare function setElementContext(el: Element, ctx: Context): void;
  * this directive and processes them immediately.
  *
  * @param registry - The directive registry
- * @param name - Directive name (without c- prefix)
+ * @param name - Directive name (without g- prefix)
  * @param fn - The directive function
  */
 export declare function registerDirective(registry: DirectiveRegistry, name: string, fn: Directive): void;

package/dist/client/hydrate.js

@@ -252,7 +252,7 @@ function processNode(node, selector, registry) {
  * this directive and processes them immediately.
  *
  * @param registry - The directive registry
- * @param name - Directive name (without c- prefix)
+ * @param name - Directive name (without g- prefix)
  * @param fn - The directive function
  */
 export function registerDirective(registry, name, fn) {

package/dist/directives/slot.js

@@ -56,14 +56,12 @@ export const slot = function slot($expr, $element, $eval) {
             return;
         }
         const content = getSavedContent(templateEl);
+        if (!content) {
+            return;
+        }
         const slotContent = content.slots.get(name);
         if (slotContent) {
             $element.innerHTML = slotContent;
-            // MutationObserver will process the new content
-        }
-        else {
-            // No content for this slot - could show fallback
-            // For now, leave any default content in the slot
         }
     };
     // If expression is provided, make it reactive
@@ -92,6 +90,9 @@ export function processNativeSlot(el) {
         return;
     }
     const content = getSavedContent(templateEl);
+    if (!content) {
+        return;
+    }
     const slotContent = content.slots.get(name);
     if (slotContent) {
         el.outerHTML = slotContent;

package/dist/directives/template.d.ts

@@ -52,4 +52,4 @@ export declare const template: Directive<['$expr', '$element', '$templates']>;
  *
  * @internal
  */
-export declare function getElementScope(el: Element): EffectScope | undefined;
+export declare function getEffectScope(el: Element): EffectScope | undefined;

package/dist/directives/template.js

@@ -142,6 +142,6 @@ directive('g-template', template);
  *
  * @internal
  */
-export function getElementScope(el) {
+export function getEffectScope(el) {
     return elementScopes.get(el);
 }

package/dist/expression.d.ts

@@ -41,7 +41,7 @@ export interface Segment {
  *
  * @remarks
  * Splits a template string with `{{ expr }}` markers into segments
- * of static text and expressions. Used by directives like c-href
+ * of static text and expressions. Useful for directives
  * that support inline interpolation.
  *
  * @param template - The template string with interpolation markers

package/dist/expression.js

@@ -52,7 +52,7 @@ export function findRoots(expr) {
  *
  * @remarks
  * Splits a template string with `{{ expr }}` markers into segments
- * of static text and expressions. Used by directives like c-href
+ * of static text and expressions. Useful for directives
  * that support inline interpolation.
  *
  * @param template - The template string with interpolation markers

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Cubist.js - A modern framework inspired by AngularJS 1.
+ * Gonia - A lightweight, SSR-first reactive UI library.
  *
  * @remarks
  * SSR-first design with HTML attributes as directives.
@@ -16,4 +16,5 @@ export { createTemplateRegistry, createMemoryRegistry, createServerRegistry } fr
 export type { TemplateRegistry } from './templates.js';
 export { findRoots, parseInterpolation } from './expression.js';
 export { getInjectables } from './inject.js';
+export { getRootScope, clearRootScope } from './scope.js';
 export * as directives from './directives/index.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * Cubist.js - A modern framework inspired by AngularJS 1.
+ * Gonia - A lightweight, SSR-first reactive UI library.
  *
  * @remarks
  * SSR-first design with HTML attributes as directives.
@@ -13,4 +13,5 @@ export { reactive, effect, createScope, createEffectScope } from './reactivity.j
 export { createTemplateRegistry, createMemoryRegistry, createServerRegistry } from './templates.js';
 export { findRoots, parseInterpolation } from './expression.js';
 export { getInjectables } from './inject.js';
+export { getRootScope, clearRootScope } from './scope.js';
 export * as directives from './directives/index.js';

package/dist/scope.d.ts

@@ -4,6 +4,24 @@
  * @packageDocumentation
  */
 import { Directive, DirectiveOptions } from './types.js';
+/**
+ * Get or create the root scope.
+ *
+ * @remarks
+ * The root scope is used as a fallback for directives that aren't
+ * inside an element with `scope: true`. This allows top-level
+ * directives like `g-model` to work without requiring a parent scope.
+ *
+ * @returns The root reactive scope
+ */
+export declare function getRootScope(): Record<string, unknown>;
+/**
+ * Clear the root scope.
+ *
+ * @remarks
+ * Primarily useful for testing.
+ */
+export declare function clearRootScope(): void;
 /**
  * Create a new scope for an element.
  *
@@ -24,9 +42,10 @@ export declare function getElementScope(el: Element): Record<string, unknown> |
  *
  * @param el - The element to start from
  * @param includeSelf - Whether to check the element itself (default: false)
- * @returns The nearest scope, or undefined if none found
+ * @param useRootFallback - Whether to return root scope if no parent found (default: true)
+ * @returns The nearest scope, or root scope if none found and fallback enabled
  */
-export declare function findParentScope(el: Element, includeSelf?: boolean): Record<string, unknown> | undefined;
+export declare function findParentScope(el: Element, includeSelf?: boolean, useRootFallback?: boolean): Record<string, unknown> | undefined;
 /**
  * Remove scope for an element (cleanup).
  *

package/dist/scope.js

@@ -9,6 +9,33 @@ import { Mode } from './types.js';
 import { getInjectables } from './inject.js';
 /** WeakMap to store element scopes */
 const elementScopes = new WeakMap();
+/** Root scope for top-level directives without explicit parent scope */
+let rootScope = null;
+/**
+ * Get or create the root scope.
+ *
+ * @remarks
+ * The root scope is used as a fallback for directives that aren't
+ * inside an element with `scope: true`. This allows top-level
+ * directives like `g-model` to work without requiring a parent scope.
+ *
+ * @returns The root reactive scope
+ */
+export function getRootScope() {
+    if (!rootScope) {
+        rootScope = reactive({});
+    }
+    return rootScope;
+}
+/**
+ * Clear the root scope.
+ *
+ * @remarks
+ * Primarily useful for testing.
+ */
+export function clearRootScope() {
+    rootScope = null;
+}
 /**
  * Create a new scope for an element.
  *
@@ -42,9 +69,10 @@ export function getElementScope(el) {
  *
  * @param el - The element to start from
  * @param includeSelf - Whether to check the element itself (default: false)
- * @returns The nearest scope, or undefined if none found
+ * @param useRootFallback - Whether to return root scope if no parent found (default: true)
+ * @returns The nearest scope, or root scope if none found and fallback enabled
  */
-export function findParentScope(el, includeSelf = false) {
+export function findParentScope(el, includeSelf = false, useRootFallback = true) {
     let current = includeSelf ? el : el.parentElement;
     while (current) {
         const scope = elementScopes.get(current);
@@ -53,7 +81,8 @@ export function findParentScope(el, includeSelf = false) {
         }
         current = current.parentElement;
     }
-    return undefined;
+    // Fall back to root scope for top-level directives
+    return useRootFallback ? getRootScope() : undefined;
 }
 /**
  * Remove scope for an element (cleanup).

package/dist/server/render.d.ts

@@ -19,7 +19,7 @@ export type ServiceRegistry = Map<string, unknown>;
  * Invalidates the cached selector so it will be rebuilt on next render.
  *
  * @param registry - The directive registry
- * @param name - Directive name (without c- prefix)
+ * @param name - Directive name (without g- prefix)
  * @param fn - The directive function
  */
 export declare function registerDirective(registry: DirectiveRegistry, name: string, fn: Directive): void;

package/dist/server/render.js

@@ -36,7 +36,7 @@ function getSelector(registry) {
  * Invalidates the cached selector so it will be rebuilt on next render.
  *
  * @param registry - The directive registry
- * @param name - Directive name (without c- prefix)
+ * @param name - Directive name (without g- prefix)
  * @param fn - The directive function
  */
 export function registerDirective(registry, name, fn) {

package/dist/vite/index.d.ts

@@ -4,3 +4,4 @@
  * @packageDocumentation
  */
 export { gonia, gonia as default } from './plugin.js';
+export type { GoniaPluginOptions } from './plugin.js';

package/dist/vite/plugin.d.ts

@@ -2,18 +2,61 @@
  * Vite plugin for gonia.js.
  *
  * @remarks
- * Transforms directive functions to add $inject arrays at build time,
- * making the code minification-safe without manual annotations.
+ * - Auto-detects directive usage in templates and injects imports
+ * - Scans custom directive sources to build import map
+ * - Transforms directive functions to add $inject arrays at build time
+ * - Configures Vite for SSR with gonia.js
  *
  * @packageDocumentation
  */
 import type { Plugin } from 'vite';
 /**
- * Cubist.js Vite plugin.
+ * Plugin options.
+ */
+export interface GoniaPluginOptions {
+    /**
+     * Automatically detect and import directives from source code.
+     * @defaultValue true
+     */
+    autoDirectives?: boolean;
+    /**
+     * Additional directives to include (for runtime/dynamic cases).
+     * Use full directive names (e.g., 'g-text', 'my-component').
+     * @example ['g-text', 'g-for', 'app-header']
+     */
+    includeDirectives?: string[];
+    /**
+     * Directives to exclude from auto-detection.
+     * Use full directive names.
+     */
+    excludeDirectives?: string[];
+    /**
+     * Glob patterns for files containing custom directive definitions.
+     * The plugin scans these files at build start to discover directive() calls.
+     * @example ['src/directives/**\/*.ts']
+     */
+    directiveSources?: string[];
+    /**
+     * Prefixes for attribute directives.
+     * @defaultValue ['g-']
+     * @example ['g-', 'v-', 'x-']
+     */
+    directiveAttributePrefixes?: string[];
+    /**
+     * Prefixes for element/component directives.
+     * Defaults to directiveAttributePrefixes if not specified.
+     * @example ['app-', 'my-', 'ui-']
+     */
+    directiveElementPrefixes?: string[];
+}
+/**
+ * Gonia Vite plugin.
  *
  * @remarks
- * Adds $inject arrays to directive functions for minification safety.
- * Also configures Vite for SSR with gonia.js.
+ * - Auto-detects directive usage and injects imports
+ * - Scans custom directive sources to discover user directives
+ * - Adds $inject arrays to directive functions for minification safety
+ * - Configures Vite for SSR with gonia.js
  *
  * @example
  * ```ts
@@ -25,6 +68,18 @@ import type { Plugin } from 'vite';
  *   plugins: [gonia()]
  * });
  * ```
+ *
+ * @example
+ * ```ts
+ * // With custom directives
+ * export default defineConfig({
+ *   plugins: [gonia({
+ *     directiveSources: ['src/directives/**\/*.ts'],
+ *     directiveAttributePrefixes: ['g-'],
+ *     directiveElementPrefixes: ['app-', 'ui-'],
+ *   })]
+ * });
+ * ```
  */
-export declare function gonia(): Plugin;
+export declare function gonia(options?: GoniaPluginOptions): Plugin;
 export default gonia;

package/dist/vite/plugin.js

@@ -2,60 +2,188 @@
  * Vite plugin for gonia.js.
  *
  * @remarks
- * Transforms directive functions to add $inject arrays at build time,
- * making the code minification-safe without manual annotations.
+ * - Auto-detects directive usage in templates and injects imports
+ * - Scans custom directive sources to build import map
+ * - Transforms directive functions to add $inject arrays at build time
+ * - Configures Vite for SSR with gonia.js
  *
  * @packageDocumentation
  */
+import { readFileSync } from 'fs';
+import { glob } from 'tinyglobby';
+import { relative } from 'path';
 /**
- * Parse function parameters from a function string.
+ * Map of built-in directive names to their export names from gonia.
  */
-function parseParams(fnStr) {
-    // Match function parameters: handles regular, arrow, and async functions
-    const match = fnStr.match(/^[^(]*\(([^)]*)\)/);
-    if (!match)
-        return null;
-    const params = match[1];
-    if (!params.trim())
-        return [];
-    return params
-        .split(',')
-        .map(p => p.trim())
-        // Remove type annotations (: Type)
-        .map(p => p.replace(/\s*:.*$/, ''))
-        // Remove default values (= value)
-        .map(p => p.replace(/\s*=.*$/, ''))
-        .filter(Boolean);
+const BUILTIN_DIRECTIVES = {
+    'g-text': { exportName: 'text', module: 'gonia/directives' },
+    'g-html': { exportName: 'html', module: 'gonia/directives' },
+    'g-show': { exportName: 'show', module: 'gonia/directives' },
+    'g-template': { exportName: 'template', module: 'gonia/directives' },
+    'g-slot': { exportName: 'slot', module: 'gonia/directives' },
+    'g-class': { exportName: 'cclass', module: 'gonia/directives' },
+    'g-model': { exportName: 'model', module: 'gonia/directives' },
+    'g-on': { exportName: 'on', module: 'gonia/directives' },
+    'g-for': { exportName: 'cfor', module: 'gonia/directives' },
+    'g-if': { exportName: 'cif', module: 'gonia/directives' },
+};
+/**
+ * Scan a file for directive() calls and extract directive names.
+ */
+function scanFileForDirectives(filePath) {
+    const directives = new Map();
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        // Match directive('name', ...) or directive("name", ...)
+        const pattern = /directive\s*\(\s*(['"`])([^'"`]+)\1/g;
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            const name = match[2];
+            directives.set(name, {
+                name,
+                exportName: null,
+                module: filePath,
+                isBuiltin: false,
+            });
+        }
+    }
+    catch {
+        // File read error - skip silently
+    }
+    return directives;
+}
+/**
+ * Build regex pattern for matching directive attributes.
+ */
+function buildAttributePattern(prefixes) {
+    const escaped = prefixes.map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    return new RegExp(`(?:${escaped.join('|')})([a-zA-Z][a-zA-Z0-9-]*)`, 'g');
+}
+/**
+ * Build regex pattern for matching directive elements (custom elements).
+ */
+function buildElementPattern(prefixes) {
+    const escaped = prefixes.map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    return new RegExp(`<((?:${escaped.join('|')})[a-zA-Z][a-zA-Z0-9-]*)`, 'g');
+}
+/**
+ * Detect directive names used in source code.
+ */
+function detectDirectives(code, id, isDev, attributePrefixes, elementPrefixes, customDirectives) {
+    const found = new Set();
+    // Pattern for attribute directives (e.g., g-text, v-if)
+    const attrPattern = buildAttributePattern(attributePrefixes);
+    let match;
+    while ((match = attrPattern.exec(code)) !== null) {
+        // Reconstruct full attribute name
+        const fullMatch = match[0];
+        found.add(fullMatch);
+    }
+    // Pattern for element directives (e.g., <app-header>, <my-component>)
+    const elemPattern = buildElementPattern(elementPrefixes);
+    while ((match = elemPattern.exec(code)) !== null) {
+        const elementName = match[1];
+        found.add(elementName);
+    }
+    // Handle dynamic directive names we can resolve
+    for (const prefix of attributePrefixes) {
+        const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const dynamicPattern = new RegExp(`\`${escaped}\\$\\{([^}]+)\\}\``, 'g');
+        while ((match = dynamicPattern.exec(code)) !== null) {
+            const expr = match[1].trim();
+            // Try to resolve simple string literals
+            const literalMatch = expr.match(/^['"]([a-zA-Z][a-zA-Z0-9-]*)['"]$/);
+            if (literalMatch) {
+                found.add(prefix + literalMatch[1]);
+                continue;
+            }
+            // Try to resolve variable
+            if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(expr)) {
+                const varPattern = new RegExp(`(?:const|let|var)\\s+${expr}\\s*=\\s*['"]([a-zA-Z][a-zA-Z0-9-]*)['"]`);
+                const varMatch = code.match(varPattern);
+                if (varMatch) {
+                    found.add(prefix + varMatch[1]);
+                }
+                else if (isDev) {
+                    console.warn(`[gonia] Could not resolve directive name in \`${prefix}\${${expr}}\` at ${id}\n` +
+                        `        Add to includeDirectives: ['${prefix}expected-name']`);
+                }
+            }
+        }
+    }
+    return found;
+}
+/**
+ * Generate import statements for detected directives.
+ */
+function generateImports(directives, customDirectives, currentFile, rootDir) {
+    if (directives.size === 0)
+        return '';
+    // Group by module
+    const moduleImports = new Map();
+    for (const name of directives) {
+        // Check built-in first
+        const builtin = BUILTIN_DIRECTIVES[name];
+        if (builtin) {
+            const imports = moduleImports.get(builtin.module) ?? [];
+            if (!imports.includes(builtin.exportName)) {
+                imports.push(builtin.exportName);
+            }
+            moduleImports.set(builtin.module, imports);
+            continue;
+        }
+        // Check custom directives
+        const custom = customDirectives.get(name);
+        if (custom) {
+            // For custom directives, we import the whole module (side effect)
+            // since the directive() call registers it
+            let modulePath = custom.module;
+            // Make path relative to current file
+            if (modulePath.startsWith('/') || modulePath.match(/^[a-zA-Z]:\\/)) {
+                const relPath = relative(currentFile.replace(/[/\\][^/\\]+$/, ''), modulePath);
+                modulePath = relPath.startsWith('.') ? relPath : './' + relPath;
+                // Normalize to forward slashes and remove .ts extension for import
+                modulePath = modulePath.replace(/\\/g, '/').replace(/\.tsx?$/, '.js');
+            }
+            // Side-effect import
+            const imports = moduleImports.get(modulePath) ?? [];
+            moduleImports.set(modulePath, imports);
+        }
+    }
+    // Generate import statements
+    const statements = [];
+    for (const [module, imports] of moduleImports) {
+        if (imports.length > 0) {
+            statements.push(`import { ${imports.join(', ')} } from '${module}';`);
+        }
+        else {
+            // Side-effect import for custom directives
+            statements.push(`import '${module}';`);
+        }
+    }
+    return statements.length > 0 ? statements.join('\n') + '\n' : '';
 }
 /**
  * Transform source code to add $inject arrays to directive functions.
  */
-function transformCode(code, id) {
-    // Skip node_modules and non-JS/TS files
-    if (id.includes('node_modules'))
-        return null;
-    if (!/\.(ts|js|tsx|jsx)$/.test(id))
-        return null;
-    // Skip if no directive calls
-    if (!code.includes('directive('))
-        return null;
+function transformInject(code) {
+    if (!code.includes('directive(')) {
+        return { code, modified: false };
+    }
     let result = code;
     let modified = false;
-    // Pattern: directive('name', functionName, ...)
-    // We need to find the function and add $inject to it
     const directiveCallPattern = /directive\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
     const functionNames = new Set();
     let match;
     while ((match = directiveCallPattern.exec(code)) !== null) {
         functionNames.add(match[2]);
     }
-    if (functionNames.size === 0)
-        return null;
+    if (functionNames.size === 0) {
+        return { code, modified: false };
+    }
     for (const fnName of functionNames) {
-        // Skip if already has $inject
         if (code.includes(`${fnName}.$inject`))
             continue;
-        // Find function declaration: function fnName(params) or const fnName = (params) =>
         const fnDeclPattern = new RegExp(`(?:function\\s+${fnName}\\s*\\(([^)]*)\\)|(?:const|let|var)\\s+${fnName}\\s*=\\s*(?:async\\s*)?(?:function\\s*)?\\(([^)]*)\\))`, 'g');
         const fnMatch = fnDeclPattern.exec(code);
         if (!fnMatch)
@@ -71,20 +199,21 @@ function transformCode(code, id) {
             .filter(Boolean);
         if (params.length === 0)
             continue;
-        // Find the directive() call and insert $inject before it
         const directivePattern = new RegExp(`(directive\\s*\\(\\s*['"\`][^'"\`]+['"\`]\\s*,\\s*${fnName})`, 'g');
         const injectStatement = `${fnName}.$inject = ${JSON.stringify(params)};\n`;
         result = result.replace(directivePattern, `${injectStatement}$1`);
         modified = true;
     }
-    return modified ? result : null;
+    return { code: result, modified };
 }
 /**
- * Cubist.js Vite plugin.
+ * Gonia Vite plugin.
  *
  * @remarks
- * Adds $inject arrays to directive functions for minification safety.
- * Also configures Vite for SSR with gonia.js.
+ * - Auto-detects directive usage and injects imports
+ * - Scans custom directive sources to discover user directives
+ * - Adds $inject arrays to directive functions for minification safety
+ * - Configures Vite for SSR with gonia.js
  *
  * @example
  * ```ts
@@ -96,17 +225,102 @@ function transformCode(code, id) {
  *   plugins: [gonia()]
  * });
  * ```
+ *
+ * @example
+ * ```ts
+ * // With custom directives
+ * export default defineConfig({
+ *   plugins: [gonia({
+ *     directiveSources: ['src/directives/**\/*.ts'],
+ *     directiveAttributePrefixes: ['g-'],
+ *     directiveElementPrefixes: ['app-', 'ui-'],
+ *   })]
+ * });
+ * ```
  */
-export function gonia() {
+export function gonia(options = {}) {
+    const { autoDirectives = true, includeDirectives = [], excludeDirectives = [], directiveSources = [], directiveAttributePrefixes = ['g-'], directiveElementPrefixes = options.directiveElementPrefixes ?? options.directiveAttributePrefixes ?? ['g-'], } = options;
+    let isDev = false;
+    let rootDir = process.cwd();
+    // Map of custom directive name -> DirectiveInfo
+    const customDirectives = new Map();
+    // Track which modules have been processed
+    const injectedModules = new Set();
     return {
         name: 'gonia',
         enforce: 'pre',
+        configResolved(config) {
+            isDev = config.command === 'serve';
+            rootDir = config.root;
+        },
+        async buildStart() {
+            // Scan directive sources to discover custom directives
+            if (directiveSources.length > 0) {
+                const files = await glob(directiveSources, {
+                    cwd: rootDir,
+                    absolute: true,
+                });
+                for (const file of files) {
+                    const directives = scanFileForDirectives(file);
+                    for (const [name, info] of directives) {
+                        customDirectives.set(name, info);
+                    }
+                }
+                if (isDev && customDirectives.size > 0) {
+                    console.log(`[gonia] Discovered ${customDirectives.size} custom directive(s)`);
+                }
+            }
+        },
         transform(code, id) {
-            const result = transformCode(code, id);
-            if (result) {
+            // Skip node_modules (except for $inject transform in gonia itself)
+            const isGoniaInternal = id.includes('gonia') && id.includes('node_modules');
+            if (id.includes('node_modules') && !isGoniaInternal)
+                return null;
+            if (!/\.(ts|js|tsx|jsx|html)$/.test(id))
+                return null;
+            let result = code;
+            let modified = false;
+            // Collect directives to import
+            if (!isGoniaInternal) {
+                const detected = new Set();
+                // Auto-detect directives if enabled
+                if (autoDirectives) {
+                    for (const name of detectDirectives(code, id, isDev, directiveAttributePrefixes, directiveElementPrefixes, customDirectives)) {
+                        detected.add(name);
+                    }
+                }
+                // Add explicitly included directives
+                for (const name of includeDirectives) {
+                    detected.add(name);
+                }
+                // Remove excluded directives
+                for (const name of excludeDirectives) {
+                    detected.delete(name);
+                }
+                // Generate imports if we found directives and haven't already
+                if (detected.size > 0 && !injectedModules.has(id)) {
+                    // Check if this file already imports from gonia/directives
+                    const hasGoniaImport = code.includes("from 'gonia/directives'") ||
+                        code.includes('from "gonia/directives"');
+                    // For custom directives, check if already imported
+                    const importStatement = generateImports(detected, customDirectives, id, rootDir);
+                    if (importStatement && !hasGoniaImport) {
+                        result = importStatement + result;
+                        modified = true;
+                        injectedModules.add(id);
+                    }
+                }
+            }
+            // Transform $inject arrays
+            const injectResult = transformInject(result);
+            if (injectResult.modified) {
+                result = injectResult.code;
+                modified = true;
+            }
+            if (modified) {
                 return {
                     code: result,
-                    map: null // TODO: proper source map support
+                    map: null
                 };
             }
             return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gonia",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "description": "A lightweight, SSR-first reactive UI library with declarative directives",
   "type": "module",
   "license": "MIT",
@@ -42,7 +42,8 @@
     }
   },
   "dependencies": {
-    "linkedom": "^0.18.0"
+    "linkedom": "^0.18.0",
+    "tinyglobby": "^0.2.15"
   },
   "peerDependencies": {
     "vite": ">=5.0.0"
@@ -53,10 +54,11 @@
     }
   },
   "devDependencies": {
+    "@types/node": "^25.0.10",
     "@vitest/coverage-v8": "^4.0.17",
     "jsdom": "^27.4.0",
     "typescript": "^5.7.0",
-    "vite": "^6.0.0",
+    "vite": "^6.4.0",
     "vitest": "^4.0.17"
   },
   "scripts": {