@liteforge/vite-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SchildW3rk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,228 @@
+# @liteforge/vite-plugin
+
+Vite plugin for LiteForge that transforms JSX into optimized DOM operations.
+
+## Installation
+
+```bash
+npm install @liteforge/vite-plugin --save-dev
+```
+
+## Setup
+
+**vite.config.ts:**
+
+```ts
+import { defineConfig } from 'vite'
+import liteforge from '@liteforge/vite-plugin'
+
+export default defineConfig({
+  plugins: [liteforge()]
+})
+```
+
+**tsconfig.json:**
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "@liteforge/runtime"
+  }
+}
+```
+
+## Overview
+
+The LiteForge Vite plugin transforms JSX syntax into direct DOM operations with signal-safe getter wrapping. This eliminates the need for a virtual DOM while maintaining familiar JSX syntax.
+
+## How It Works
+
+The plugin transforms JSX at build time:
+
+**Input:**
+```tsx
+const Counter = () => {
+  const count = signal(0)
+  return (
+    <div class="counter">
+      <p>Count: {count()}</p>
+      <button onclick={() => count.update(n => n + 1)}>
+        Increment
+      </button>
+    </div>
+  )
+}
+```
+
+**Output (conceptual):**
+```ts
+const Counter = () => {
+  const count = signal(0)
+  
+  const _div = document.createElement('div')
+  _div.className = 'counter'
+  
+  const _p = document.createElement('p')
+  effect(() => {
+    _p.textContent = `Count: ${count()}`
+  })
+  
+  const _button = document.createElement('button')
+  _button.textContent = 'Increment'
+  _button.addEventListener('click', () => count.update(n => n + 1))
+  
+  _div.appendChild(_p)
+  _div.appendChild(_button)
+  
+  return _div
+}
+```
+
+## Options
+
+```ts
+import liteforge from '@liteforge/vite-plugin'
+
+export default defineConfig({
+  plugins: [
+    liteforge({
+      // File extensions to transform
+      extensions: ['.tsx', '.jsx'],
+      
+      // Enable HMR (experimental)
+      hmr: true,
+      
+      // Enable template extraction for static content
+      templates: true,
+      
+      // Debug mode (logs transformed code)
+      debug: false
+    })
+  ]
+})
+```
+
+## Signal-Safe Getters
+
+The plugin automatically wraps reactive expressions in getters to ensure proper signal tracking:
+
+```tsx
+// Input
+<p class={isActive() ? 'active' : 'inactive'}>
+  {user().name}
+</p>
+
+// The plugin wraps these in getters so effects can track them
+```
+
+This means you write natural JSX with signal calls, and the plugin handles reactivity.
+
+## Static Extraction
+
+Static HTML is extracted and converted to templates for better performance:
+
+```tsx
+// Static content is optimized
+<div class="container">
+  <header>
+    <h1>My App</h1>
+    <nav>...</nav>
+  </header>
+  {/* Dynamic content still uses effects */}
+  <main>{content()}</main>
+</div>
+```
+
+## Event Handlers
+
+Event handlers are detected and attached directly:
+
+```tsx
+<button
+  onclick={() => handleClick()}
+  onmouseover={(e) => highlight(e)}
+>
+  Click me
+</button>
+```
+
+All standard DOM events are supported with the `on` prefix.
+
+## Fragments
+
+Use `<>...</>` for multiple root elements:
+
+```tsx
+const List = () => (
+  <>
+    <li>Item 1</li>
+    <li>Item 2</li>
+    <li>Item 3</li>
+  </>
+)
+```
+
+## Components
+
+Component detection is automatic based on naming convention (PascalCase):
+
+```tsx
+// Components (PascalCase) - passed to h() as function reference
+<UserCard user={user} />
+<Modal isOpen={showModal()} />
+
+// HTML elements (lowercase) - created as DOM elements
+<div class="card">...</div>
+<button onclick={...}>...</button>
+```
+
+## Known Limitations
+
+1. **HMR** — Hot Module Replacement is not fully working yet. Manual browser refresh is required after changes.
+
+2. **Text Spacing** — Adjacent text and signals need explicit spacing:
+   ```tsx
+   // May need explicit spaces
+   <p>Hello{' '}{name()}</p>
+   ```
+
+3. **Value Binding** — Form inputs require getter syntax:
+   ```tsx
+   // Correct
+   <input value={() => field.value()} />
+   
+   // Won't update reactively
+   <input value={field.value()} />
+   ```
+
+## Advanced: Transform API
+
+For testing or custom tooling:
+
+```ts
+import { transform, transformCode } from '@liteforge/vite-plugin'
+
+const result = transform(code, {
+  extensions: ['.tsx'],
+  hmr: false,
+  templates: true
+}, isDev)
+
+// result.code - transformed code
+// result.map - source map
+// result.hasJsx - whether JSX was found
+```
+
+## Types
+
+```ts
+import type {
+  LiteForgePluginOptions,
+  ResolvedPluginOptions
+} from '@liteforge/vite-plugin'
+```
+
+## License
+
+MIT

package/dist/getter-wrap.d.ts

@@ -0,0 +1,69 @@
+/**
+ * LiteForge Getter Wrapping Logic
+ *
+ * Determines whether expressions in JSX should be wrapped in getter functions
+ * to preserve fine-grained reactivity with signals.
+ *
+ * CRITICAL: Any dynamic expression that could contain signal reads must be
+ * wrapped in a getter function. The runtime's h() function will detect
+ * function props and set up effects to re-evaluate them when dependencies change.
+ *
+ * Wrapping Rules:
+ * - String/Number/Boolean/null/undefined literals: NO wrap (static)
+ * - Template literals with only strings: NO wrap (static)
+ * - Arrow functions / Function expressions: NO wrap (already functions)
+ * - Event handlers (onX props): NO wrap (are functions, should not be invoked)
+ * - Everything else: WRAP (could contain signal reads)
+ */
+import * as t from '@babel/types';
+/**
+ * Check if an expression should be wrapped in a getter function.
+ * Returns true if the expression is dynamic and could contain signal reads.
+ */
+export declare function shouldWrapExpression(node: t.Expression | t.JSXEmptyExpression): boolean;
+/**
+ * Check if an expression is static (doesn't need getter wrapping).
+ * Static expressions can be evaluated once at component creation.
+ */
+export declare function isStaticExpression(node: t.Expression | t.JSXEmptyExpression): boolean;
+/**
+ * Check if a node is a literal value (string, number, boolean, null, undefined)
+ */
+export declare function isLiteralValue(node: t.Node): boolean;
+/**
+ * Wrap an expression in an arrow function getter: () => expression
+ */
+export declare function wrapInGetter(node: t.Expression): t.ArrowFunctionExpression;
+/**
+ * Check if expression is a function call (potentially a signal read)
+ */
+export declare function isFunctionCall(node: t.Node): node is t.CallExpression;
+/**
+ * Check if expression is a binary operation (e.g., a() + b())
+ */
+export declare function isBinaryExpression(node: t.Node): node is t.BinaryExpression;
+/**
+ * Check if expression is a ternary/conditional (e.g., x() ? 'a' : 'b')
+ */
+export declare function isConditionalExpression(node: t.Node): node is t.ConditionalExpression;
+/**
+ * Check if expression is a member access (e.g., user.name)
+ */
+export declare function isMemberExpression(node: t.Node): node is t.MemberExpression;
+/**
+ * Check if expression is an identifier (variable reference)
+ */
+export declare function isIdentifier(node: t.Node): node is t.Identifier;
+/**
+ * Check if expression is a template literal with expressions
+ */
+export declare function isTemplateLiteralWithExpressions(node: t.Node): boolean;
+/**
+ * Check if expression is a logical expression (&&, ||, ??)
+ */
+export declare function isLogicalExpression(node: t.Node): node is t.LogicalExpression;
+/**
+ * Check if expression is a unary expression (!, -, +, etc.)
+ */
+export declare function isUnaryExpression(node: t.Node): node is t.UnaryExpression;
+//# sourceMappingURL=getter-wrap.d.ts.map

package/dist/getter-wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getter-wrap.d.ts","sourceRoot":"","sources":["../src/getter-wrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAMlC;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,kBAAkB,GAAG,OAAO,CAOvF;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,kBAAkB,GAAG,OAAO,CAuBrF;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,OAAO,CA2BpD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,uBAAuB,CAE1E;AAMD;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,cAAc,CAErE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,gBAAgB,CAE3E;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,qBAAqB,CAErF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,gBAAgB,CAE3E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,UAAU,CAE/D;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,OAAO,CAEtE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,iBAAiB,CAE7E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,eAAe,CAEzE"}

package/dist/getter-wrap.js

@@ -0,0 +1,140 @@
+/**
+ * LiteForge Getter Wrapping Logic
+ *
+ * Determines whether expressions in JSX should be wrapped in getter functions
+ * to preserve fine-grained reactivity with signals.
+ *
+ * CRITICAL: Any dynamic expression that could contain signal reads must be
+ * wrapped in a getter function. The runtime's h() function will detect
+ * function props and set up effects to re-evaluate them when dependencies change.
+ *
+ * Wrapping Rules:
+ * - String/Number/Boolean/null/undefined literals: NO wrap (static)
+ * - Template literals with only strings: NO wrap (static)
+ * - Arrow functions / Function expressions: NO wrap (already functions)
+ * - Event handlers (onX props): NO wrap (are functions, should not be invoked)
+ * - Everything else: WRAP (could contain signal reads)
+ */
+import * as t from '@babel/types';
+// =============================================================================
+// Main API
+// =============================================================================
+/**
+ * Check if an expression should be wrapped in a getter function.
+ * Returns true if the expression is dynamic and could contain signal reads.
+ */
+export function shouldWrapExpression(node) {
+    // JSXEmptyExpression ({}) is static (nothing to wrap)
+    if (t.isJSXEmptyExpression(node)) {
+        return false;
+    }
+    return !isStaticExpression(node);
+}
+/**
+ * Check if an expression is static (doesn't need getter wrapping).
+ * Static expressions can be evaluated once at component creation.
+ */
+export function isStaticExpression(node) {
+    // JSXEmptyExpression is considered static
+    if (t.isJSXEmptyExpression(node)) {
+        return true;
+    }
+    // Literal values are static
+    if (isLiteralValue(node)) {
+        return true;
+    }
+    // Arrow functions and function expressions are already functions
+    if (t.isArrowFunctionExpression(node) || t.isFunctionExpression(node)) {
+        return true;
+    }
+    // Template literals with no expressions are static
+    if (t.isTemplateLiteral(node) && node.expressions.length === 0) {
+        return true;
+    }
+    // Everything else is potentially dynamic
+    return false;
+}
+/**
+ * Check if a node is a literal value (string, number, boolean, null, undefined)
+ */
+export function isLiteralValue(node) {
+    // String literal
+    if (t.isStringLiteral(node)) {
+        return true;
+    }
+    // Numeric literal
+    if (t.isNumericLiteral(node)) {
+        return true;
+    }
+    // Boolean literal
+    if (t.isBooleanLiteral(node)) {
+        return true;
+    }
+    // Null literal
+    if (t.isNullLiteral(node)) {
+        return true;
+    }
+    // Undefined identifier
+    if (t.isIdentifier(node) && node.name === 'undefined') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Wrap an expression in an arrow function getter: () => expression
+ */
+export function wrapInGetter(node) {
+    return t.arrowFunctionExpression([], node);
+}
+// =============================================================================
+// Expression Type Checks (for more granular analysis)
+// =============================================================================
+/**
+ * Check if expression is a function call (potentially a signal read)
+ */
+export function isFunctionCall(node) {
+    return t.isCallExpression(node);
+}
+/**
+ * Check if expression is a binary operation (e.g., a() + b())
+ */
+export function isBinaryExpression(node) {
+    return t.isBinaryExpression(node);
+}
+/**
+ * Check if expression is a ternary/conditional (e.g., x() ? 'a' : 'b')
+ */
+export function isConditionalExpression(node) {
+    return t.isConditionalExpression(node);
+}
+/**
+ * Check if expression is a member access (e.g., user.name)
+ */
+export function isMemberExpression(node) {
+    return t.isMemberExpression(node);
+}
+/**
+ * Check if expression is an identifier (variable reference)
+ */
+export function isIdentifier(node) {
+    return t.isIdentifier(node);
+}
+/**
+ * Check if expression is a template literal with expressions
+ */
+export function isTemplateLiteralWithExpressions(node) {
+    return t.isTemplateLiteral(node) && node.expressions.length > 0;
+}
+/**
+ * Check if expression is a logical expression (&&, ||, ??)
+ */
+export function isLogicalExpression(node) {
+    return t.isLogicalExpression(node);
+}
+/**
+ * Check if expression is a unary expression (!, -, +, etc.)
+ */
+export function isUnaryExpression(node) {
+    return t.isUnaryExpression(node);
+}
+//# sourceMappingURL=getter-wrap.js.map

package/dist/getter-wrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getter-wrap.js","sourceRoot":"","sources":["../src/getter-wrap.ts"],"names":[],"mappings":"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"}

package/dist/hmr.d.ts

@@ -0,0 +1,20 @@
+/**
+ * LiteForge HMR Support
+ *
+ * Hot Module Replacement integration for LiteForge components.
+ * In Phase 1, we use a simple approach: accept updates and trigger a full
+ * component remount. State preservation will come in a later phase.
+ */
+/**
+ * Generate HMR acceptance code to append to a module
+ */
+export declare function generateHmrCode(): string;
+/**
+ * Append HMR code to the transformed output
+ */
+export declare function appendHmrCode(code: string): string;
+/**
+ * Check if code already has HMR acceptance
+ */
+export declare function hasHmrAcceptance(code: string): boolean;
+//# sourceMappingURL=hmr.d.ts.map

package/dist/hmr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr.d.ts","sourceRoot":"","sources":["../src/hmr.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAMxC;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD"}

package/dist/hmr.js

@@ -0,0 +1,33 @@
+/**
+ * LiteForge HMR Support
+ *
+ * Hot Module Replacement integration for LiteForge components.
+ * In Phase 1, we use a simple approach: accept updates and trigger a full
+ * component remount. State preservation will come in a later phase.
+ */
+// =============================================================================
+// HMR Code Injection
+// =============================================================================
+/**
+ * Generate HMR acceptance code to append to a module
+ */
+export function generateHmrCode() {
+    return `
+if (import.meta.hot) {
+  import.meta.hot.accept();
+}
+`;
+}
+/**
+ * Append HMR code to the transformed output
+ */
+export function appendHmrCode(code) {
+    return code + generateHmrCode();
+}
+/**
+ * Check if code already has HMR acceptance
+ */
+export function hasHmrAcceptance(code) {
+    return code.includes('import.meta.hot.accept');
+}
+//# sourceMappingURL=hmr.js.map

package/dist/hmr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr.js","sourceRoot":"","sources":["../src/hmr.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,gFAAgF;AAChF,qBAAqB;AACrB,gFAAgF;AAEhF;;GAEG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO;;;;CAIR,CAAC;AACF,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,IAAI,GAAG,eAAe,EAAE,CAAC;AAClC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,IAAI,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAAC;AACjD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * LiteForge Vite Plugin
+ *
+ * Transforms JSX/TSX into LiteForge h() calls with signal-safe getter wrapping.
+ *
+ * Usage:
+ * ```ts
+ * import liteforge from '@liteforge/vite-plugin';
+ *
+ * export default defineConfig({
+ *   plugins: [liteforge()]
+ * });
+ * ```
+ */
+import type { Plugin } from 'vite';
+import type { LiteForgePluginOptions } from './types.js';
+/**
+ * Create the LiteForge Vite plugin
+ */
+export default function liteforgePlugin(options?: LiteForgePluginOptions): Plugin;
+export type { LiteForgePluginOptions, ResolvedPluginOptions } from './types.js';
+export { transform, transformCode } from './transform.js';
+export { shouldWrapExpression, isStaticExpression, wrapInGetter } from './getter-wrap.js';
+export { isEventHandler, isComponent } from './utils.js';
+export { analyzeElement, extractElementInfo, generateTemplateString, type ElementInfo, type ChildInfo, type TemplateAnalysis, type ElementClassification, } from './template-extractor.js';
+export { resolvePaths, pathToAccessor, type DomPath, type PathStep, type PathResolution, } from './path-resolver.js';
+export { compileTemplate, generateModuleTemplates, type CompiledTemplate, } from './template-compiler.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,sBAAsB,EAAyB,MAAM,YAAY,CAAC;AAShF;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,MAAM,CA4ChF;AAOD,YAAY,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGhF,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG1D,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzD,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,sBAAsB,EACtB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,GAC3B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,YAAY,EACZ,cAAc,EACd,KAAK,OAAO,EACZ,KAAK,QAAQ,EACb,KAAK,cAAc,GACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,KAAK,gBAAgB,GACtB,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,70 @@
+/**
+ * LiteForge Vite Plugin
+ *
+ * Transforms JSX/TSX into LiteForge h() calls with signal-safe getter wrapping.
+ *
+ * Usage:
+ * ```ts
+ * import liteforge from '@liteforge/vite-plugin';
+ *
+ * export default defineConfig({
+ *   plugins: [liteforge()]
+ * });
+ * ```
+ */
+import { resolveOptions, shouldTransform, isNodeModules } from './utils.js';
+import { transform } from './transform.js';
+import { appendHmrCode, hasHmrAcceptance } from './hmr.js';
+// =============================================================================
+// Plugin Factory
+// =============================================================================
+/**
+ * Create the LiteForge Vite plugin
+ */
+export default function liteforgePlugin(options) {
+    let resolvedOptions;
+    let isDev = false;
+    return {
+        name: 'vite-plugin-liteforge',
+        enforce: 'pre',
+        configResolved(config) {
+            isDev = config.command === 'serve';
+            resolvedOptions = resolveOptions(options, isDev);
+        },
+        transform(code, id) {
+            // Skip node_modules
+            if (isNodeModules(id)) {
+                return null;
+            }
+            // Only transform files with matching extensions
+            if (!shouldTransform(id, resolvedOptions.extensions)) {
+                return null;
+            }
+            // Transform the code
+            const result = transform(code, resolvedOptions, isDev);
+            // If no JSX was found, return null (no change)
+            if (!result.hasJsx) {
+                return null;
+            }
+            // Add HMR code in dev mode
+            let finalCode = result.code;
+            if (isDev && resolvedOptions.hmr && !hasHmrAcceptance(finalCode)) {
+                finalCode = appendHmrCode(finalCode);
+            }
+            return {
+                code: finalCode,
+                map: result.map ?? undefined,
+            };
+        },
+    };
+}
+// Export transform for testing
+export { transform, transformCode } from './transform.js';
+// Export utilities for advanced use
+export { shouldWrapExpression, isStaticExpression, wrapInGetter } from './getter-wrap.js';
+export { isEventHandler, isComponent } from './utils.js';
+// Export template extraction utilities for advanced use
+export { analyzeElement, extractElementInfo, generateTemplateString, } from './template-extractor.js';
+export { resolvePaths, pathToAccessor, } from './path-resolver.js';
+export { compileTemplate, generateModuleTemplates, } from './template-compiler.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE3D,gFAAgF;AAChF,iBAAiB;AACjB,gFAAgF;AAEhF;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,OAAgC;IACtE,IAAI,eAAsC,CAAC;IAC3C,IAAI,KAAK,GAAG,KAAK,CAAC;IAElB,OAAO;QACL,IAAI,EAAE,uBAAuB;QAC7B,OAAO,EAAE,KAAK;QAEd,cAAc,CAAC,MAAM;YACnB,KAAK,GAAG,MAAM,CAAC,OAAO,KAAK,OAAO,CAAC;YACnC,eAAe,GAAG,cAAc,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACnD,CAAC;QAED,SAAS,CAAC,IAAY,EAAE,EAAU;YAChC,oBAAoB;YACpB,IAAI,aAAa,CAAC,EAAE,CAAC,EAAE,CAAC;gBACtB,OAAO,IAAI,CAAC;YACd,CAAC;YAED,gDAAgD;YAChD,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,eAAe,CAAC,UAAU,CAAC,EAAE,CAAC;gBACrD,OAAO,IAAI,CAAC;YACd,CAAC;YAED,qBAAqB;YACrB,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,CAAC,CAAC;YAEvD,+CAA+C;YAC/C,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;gBACnB,OAAO,IAAI,CAAC;YACd,CAAC;YAED,2BAA2B;YAC3B,IAAI,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;YAC5B,IAAI,KAAK,IAAI,eAAe,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,CAAC;gBACjE,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;YACvC,CAAC;YAED,OAAO;gBACL,IAAI,EAAE,SAAS;gBACf,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,SAAS;aAC7B,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AASD,+BAA+B;AAC/B,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE1D,oCAAoC;AACpC,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzD,wDAAwD;AACxD,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,sBAAsB,GAKvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,YAAY,EACZ,cAAc,GAIf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,eAAe,EACf,uBAAuB,GAExB,MAAM,wBAAwB,CAAC"}