gonia 0.0.3 → 0.1.0

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,41 @@
  * 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
+ * - 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 directive names without the 'g-' prefix.
+     * @example ['text', 'for', 'if']
+     */
+    includeDirectives?: string[];
+    /**
+     * Directives to exclude from auto-detection.
+     * Use directive names without the 'g-' prefix.
+     */
+    excludeDirectives?: 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
+ * - Adds $inject arrays to directive functions for minification safety
+ * - Configures Vite for SSR with gonia.js
  *
  * @example
  * ```ts
@@ -25,6 +48,18 @@ import type { Plugin } from 'vite';
  *   plugins: [gonia()]
  * });
  * ```
+ *
+ * @example
+ * ```ts
+ * // With options
+ * export default defineConfig({
+ *   plugins: [gonia({
+ *     autoDirectives: true,
+ *     includeDirectives: ['text', 'for'],  // For dynamic/runtime HTML
+ *     excludeDirectives: ['model'],        // Never include these
+ *   })]
+ * });
+ * ```
  */
-export declare function gonia(): Plugin;
+export declare function gonia(options?: GoniaPluginOptions): Plugin;
 export default gonia;

package/dist/vite/plugin.js

@@ -2,60 +2,108 @@
  * 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
+ * - Transforms directive functions to add $inject arrays at build time
+ * - Configures Vite for SSR with gonia.js
  *
  * @packageDocumentation
  */
 /**
- * Parse function parameters from a function string.
+ * Map of 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 DIRECTIVE_MAP = {
+    text: 'text',
+    html: 'html',
+    show: 'show',
+    template: 'template',
+    slot: 'slot',
+    class: 'cclass',
+    model: 'model',
+    on: 'on',
+    for: 'cfor',
+    if: 'cif',
+};
+/**
+ * Detect directive names used in source code.
+ */
+function detectDirectives(code, id, isDev) {
+    const found = new Set();
+    // Pattern 1: g-name as attribute in template literals or strings
+    // Matches: g-text, g-for, g-if, etc.
+    const attrPattern = /g-([a-z]+)/g;
+    let match;
+    while ((match = attrPattern.exec(code)) !== null) {
+        const name = match[1];
+        if (DIRECTIVE_MAP[name]) {
+            found.add(name);
+        }
+    }
+    // Pattern 2: Dynamic directive names we can resolve
+    // Matches: `g-${expr}` where expr is a string literal or simple variable
+    const dynamicPattern = /`g-\$\{([^}]+)\}`/g;
+    while ((match = dynamicPattern.exec(code)) !== null) {
+        const expr = match[1].trim();
+        // Try to resolve simple string literals
+        if (/^['"]([a-z]+)['"]$/.test(expr)) {
+            const name = expr.slice(1, -1);
+            if (DIRECTIVE_MAP[name]) {
+                found.add(name);
+            }
+        }
+        else if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(expr)) {
+            // It's a variable - try to find its value
+            const varPattern = new RegExp(`(?:const|let|var)\\s+${expr}\\s*=\\s*['"]([a-z]+)['"]`);
+            const varMatch = code.match(varPattern);
+            if (varMatch && DIRECTIVE_MAP[varMatch[1]]) {
+                found.add(varMatch[1]);
+            }
+            else if (isDev) {
+                console.warn(`[gonia] Could not resolve directive name in \`g-\${${expr}}\` at ${id}\n` +
+                    `        Add to vite config: includeDirectives: ['expected-directive']`);
+            }
+        }
+    }
+    return found;
+}
+/**
+ * Generate import statement for detected directives.
+ */
+function generateDirectiveImports(directives) {
+    if (directives.size === 0)
+        return '';
+    const imports = [];
+    for (const name of directives) {
+        const exportName = DIRECTIVE_MAP[name];
+        if (exportName) {
+            imports.push(exportName);
+        }
+    }
+    if (imports.length === 0)
+        return '';
+    // Import from gonia/directives which auto-registers
+    return `import { ${imports.join(', ')} } from 'gonia/directives';\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, id) {
+    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 +119,20 @@ 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
+ * - Adds $inject arrays to directive functions for minification safety
+ * - Configures Vite for SSR with gonia.js
  *
  * @example
  * ```ts
@@ -96,14 +144,76 @@ function transformCode(code, id) {
  *   plugins: [gonia()]
  * });
  * ```
+ *
+ * @example
+ * ```ts
+ * // With options
+ * export default defineConfig({
+ *   plugins: [gonia({
+ *     autoDirectives: true,
+ *     includeDirectives: ['text', 'for'],  // For dynamic/runtime HTML
+ *     excludeDirectives: ['model'],        // Never include these
+ *   })]
+ * });
+ * ```
  */
-export function gonia() {
+export function gonia(options = {}) {
+    const { autoDirectives = true, includeDirectives = [], excludeDirectives = [], } = options;
+    let isDev = false;
+    // Track which directives have been injected per chunk
+    const injectedModules = new Set();
     return {
         name: 'gonia',
         enforce: 'pre',
+        configResolved(config) {
+            isDev = config.command === 'serve';
+        },
         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)) {
+                        detected.add(name);
+                    }
+                }
+                // Add explicitly included directives (always, regardless of autoDirectives)
+                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
+                    if (!code.includes("from 'gonia/directives'") && !code.includes('from "gonia/directives"')) {
+                        const importStatement = generateDirectiveImports(detected);
+                        if (importStatement) {
+                            result = importStatement + result;
+                            modified = true;
+                            injectedModules.add(id);
+                        }
+                    }
+                }
+            }
+            // Transform $inject arrays
+            const injectResult = transformInject(result, id);
+            if (injectResult.modified) {
+                result = injectResult.code;
+                modified = true;
+            }
+            if (modified) {
                 return {
                     code: result,
                     map: null // TODO: proper source map support

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gonia",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "A lightweight, SSR-first reactive UI library with declarative directives",
   "type": "module",
   "license": "MIT",