npm - ladrillosjs - Versions diffs - 2.0.0-rc.6 → 2.0.0 - Mend

ladrillosjs 2.0.0-rc.6 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/README.md +171 -16
package/dist/core/cache/expressionCache.d.ts +5 -70
package/dist/core/component/loader.d.ts +1 -1
package/dist/core/configure.d.ts +24 -0
package/dist/core/diff/listDiff.d.ts +16 -0
package/dist/core/html/controlTagEscape.d.ts +47 -0
package/dist/core/js/moduleExecutor.d.ts +19 -0
package/dist/core/js/scriptParser.d.ts +35 -1
package/dist/core.d.ts +2 -2
package/dist/core.dev.js +12 -0
package/dist/core.dev.js.map +1 -0
package/dist/core.js +2 -2
package/dist/core.js.map +1 -1
package/dist/events.dev.js +2 -0
package/dist/events.js +1 -2
package/dist/index.d.ts +2 -2
package/dist/index.dev.js +22 -0
package/dist/index.dev.js.map +1 -0
package/dist/index.js +2 -2
package/dist/index.js.map +1 -1
package/dist/lazy.dev.js +2 -0
package/dist/lazy.js +1 -2
package/dist/shared-CMbR-Hhy.js +3 -0
package/dist/shared-CMbR-Hhy.js.map +1 -0
package/dist/shared-DqWGO1vN.js +2 -0
package/dist/shared-DqWGO1vN.js.map +1 -0
package/dist/shared-R1SSiaIW.dev.js +6785 -0
package/dist/shared-R1SSiaIW.dev.js.map +1 -0
package/dist/shared-Sk_U4mcq.dev.js +161 -0
package/dist/shared-Sk_U4mcq.dev.js.map +1 -0
package/dist/types/index.d.ts +6 -0
package/dist/utils/devWarnings.d.ts +24 -3
package/dist/utils/directives.d.ts +10 -0
package/dist/utils/jsevents.d.ts +5 -0
package/dist/utils/sandbox.d.ts +11 -0
package/dist/utils/stateTransform.d.ts +58 -0
package/package.json +23 -9
package/dist/core/reactivity/dependencyTracker.d.ts +0 -120
package/dist/events.js.map +0 -1
package/dist/lazy.js.map +0 -1
package/dist/shared-7ZWfGAEo.js +0 -2
package/dist/shared-7ZWfGAEo.js.map +0 -1
package/dist/shared-CM0Gy9QI.js +0 -2
package/dist/shared-CM0Gy9QI.js.map +0 -1
package/dist/shared-DGGk2qBc.js +0 -2
package/dist/shared-DGGk2qBc.js.map +0 -1

package/README.md CHANGED Viewed

@@ -26,14 +26,16 @@
 - [Quick Start](#-quick-start)
 - [Installation](#-installation)
 - [Core Concepts](#-core-concepts)
-- [Directives](#-directives)
+- [Built-in Elements & Directives](#-built-in-elements--directives)
 - [Event Bus](#-event-bus)
 - [Element References](#-element-references)
 - [Lazy Loading](#-lazy-loading)
 - [API Reference](#-api-reference)
 - [Using with Vite](#-using-with-vite)
-- [Browser Support](#-browser-support)
+- [Benchmarks](#-benchmarks)
 - [Examples](#-examples)
+- [Documentation](#-documentation)
+- [Security & Trust Model](#-security--trust-model)
 - [Contributing](#-contributing)
 - [License](#-license)
@@ -41,16 +43,7 @@
 ## 🚀 Quick Start
-### 1. Add the Script
-```html
-<script type="module">
-  import ladrillosjs from "https://cdn.jsdelivr.net/npm/ladrillosjs@2/dist/index.js";
-  window.ladrillosjs = ladrillosjs;
-</script>
-```
-### 2. Create a Component
+### 1. Create a Component
 Save this as `counter.html`:
@@ -86,7 +79,10 @@ Save this as `counter.html`:
 </style>
 ```
-### 3. Use It
+### 2. Register and Use It
+In your `index.html`, import LadrillosJS from the CDN, register the
+component, and drop the tag anywhere on the page:
 ```html
 <!DOCTYPE html>
@@ -103,8 +99,21 @@ Save this as `counter.html`:
 </html>
 ```
+### 3. Serve It
+Components are fetched over HTTP, so serve the folder with any static server
+(opening the file directly via `file://` won't work — browsers block `fetch`
+from local files):
+```bash
+npx serve          # or: python -m http.server 8080
+```
 That's it! Your reactive component is ready. 🎉
+> 📚 **Want more?** The [full documentation](docs/README.md) covers every
+> feature step by step, from your first component to building a design system.
 ---
 ## 📦 Installation
@@ -205,6 +214,20 @@ Attach events directly in HTML with inline expressions or function calls:
 <form onsubmit="handleSubmit(event)">...</form>
 ```
+Or use the `$on:` directive with **modifiers** — dot-separated flags for
+common patterns like `preventDefault`, key filtering, and modifier keys:
+```html
+<form $on:submit.prevent="handleSubmit()">...</form>
+<input $on:keyup.enter="search()" />
+<textarea $on:keydown.ctrl.s.prevent="save()"></textarea>
+<div $on:click.self="closeModal()">...</div>
+<button $on:click.once="trackFirstClick()">Buy</button>
+```
+See the [Event Modifiers reference](docs/20-event-modifiers.md) for every
+modifier and combination.
 ### Two-Way Binding
 Use `$bind` to sync form inputs with state:
@@ -325,6 +348,8 @@ Use `<lazy>` to defer rendering until a trigger fires (viewport, idle, delay, in
 | `<lazy>`            | Defer rendering          | `<lazy idle><analytics-pixel /></lazy>`                |
 | `$bind`             | Two-way binding          | `<input $bind="email" />`                              |
 | `$ref`              | Element reference        | `<input $ref="inputEl" />`                             |
+| `$on:` + modifiers  | Events with modifiers    | `<form $on:submit.prevent="save()">`                   |
+| `$no:bind`          | Escape `{}` binding      | `<code $no:bind>{literal}</code>`                      |
 ---
@@ -530,10 +555,45 @@ import { configure } from "ladrillosjs";
 configure({
   cacheSize: 50, // Component LRU cache size (default: 25)
-  onError: (err) => telemetry.capture(err), // Custom error handler
+  onError: (err, context) => telemetry.capture(err, { context }),
+  delegateLoopEvents: true, // Opt-in loop event delegation (default: false)
 });
 ```
+Development builds include actionable `LJSxxx` diagnostics with component and
+file context, a suggested fix, and a link to the
+[error reference](docs/21-error-handling.md). Vite and other bundlers that
+honor the `development` package condition select this build automatically. To
+select it explicitly, import from `ladrillosjs/dev` (or
+`ladrillosjs/core/dev`). Production builds retain coded errors but remove
+development-only warnings.
+The `onError` callback is also suitable for telemetry. Coded framework errors
+are instances of `LadrillosError` and expose `code`, `docsUrl`, `hint`,
+`componentContext`, and the original `cause`.
+#### `delegateLoopEvents`
+By default every handler inside a `<for>` row gets its own listener. With
+`delegateLoopEvents: true`, eligible handlers share **one listener per event
+type** on the loop's container — thousands of rows, a handful of listeners.
+Templates and handler code don't change at all, and render performance is
+the same either way; enable it when listener count itself matters (very
+large lists, memory-constrained devices, many handlers per row).
+Fine print:
+- Non-bubbling events (`focus`, `blur`, `mouseenter`, …) and handlers using
+  the `.self`, `.capture`, `.once`, or `.passive` modifiers automatically
+  keep per-element listeners. `.stop`, `.prevent`, and key/system modifiers
+  work identically in both modes.
+- `event.currentTarget` inside a delegated handler is the list container,
+  not the row element (`event.target` is unaffected).
+- If you manually attach your own listener on an element inside a row and
+  call `stopPropagation()`, delegated handlers above it won't fire.
+- Call `configure()` before your components render; already-rendered loops
+  keep the mode they were created with.
 ### Event Bus
 | Function                   | Description                         |
@@ -575,6 +635,54 @@ See the [samples/](samples/) directory for complete examples:
 ---
+## 📊 Benchmarks
+A [js-framework-benchmark](https://github.com/krausest/js-framework-benchmark)–style
+suite lives in [benchmarks/](benchmarks/). It renders the same keyed
+1,000-row list in LadrillosJS, React 18 (keyed, memoized rows — the
+idiomatic fast path), and hand-optimized vanilla JS, and measures each
+operation from invocation until the live DOM reflects the change.
+Medians of 10 runs, headless Chromium on an Apple M5 Pro,
+`ladrillosjs@2.0.0-beta.11`:
+| Operation | LadrillosJS | React 18.3 (keyed, memoized rows) | Vanilla JS (hand-optimized) |
+|---|---:|---:|---:|
+| create 1,000 rows | **3.7 ms** | 4.1 ms | 1.8 ms |
+| replace all 1,000 rows | **4.1 ms** | 7 ms | 2 ms |
+| partial update (every 10th of 1,000) | 1.1 ms | 1.2 ms | 0.2 ms |
+| select row | 0.7 ms | 0.4 ms | 0 ms |
+| swap 2 rows | **1.1 ms** | 3.3 ms | 0.1 ms |
+| remove row | 1 ms | 1 ms | 0 ms |
+| append 1,000 to 1,000 rows | **3.8 ms** | 4.3 ms | 1.3 ms |
+| clear 1,000 rows | **1.3 ms** | 5.1 ms | 0.8 ms |
+| create 10,000 rows | **28.9 ms** | 218.3 ms | 13 ms |
+| **JS payload (min+gzip)** | **25.9 KB** | **47 KB** | ~1 KB |
+| JS heap after 1,000 rows | 2.4 MB | 6.2 MB | 1.3 MB |
+**How to read this honestly:**
+- Every operation lands well within a single 60 fps frame (16.7 ms):
+  updates on a 1,000-row list take about a millisecond, and bulk creation
+  of 1,000 rows is under 5 ms.
+- LadrillosJS beats React on bulk creation (and by 7× on 10,000 rows),
+  full replaces, row swaps, and clearing, while shipping **half the JS**
+  and using **~60% less memory** for the same UI.
+- React 18 remains faster on single-row selection, and partial updates
+  are a tie. We publish these numbers to track and improve them — not to
+  claim LadrillosJS wins everything.
+- Vanilla JS is the baseline.
+Reproduce it yourself (no benchmark numbers should be trusted otherwise):
+```bash
+cd benchmarks && npm install && npm run bench
+```
+Methodology, fairness notes, and raw samples: [benchmarks/README.md](benchmarks/README.md)
+and [benchmarks/results.json](benchmarks/results.json).
+---
 ## 📚 Examples
 ### Todo List
@@ -591,9 +699,9 @@ A complete CRUD example combining all directives:
   <ul>
     <for each="todo in todos" key="todo.id">
       <li>
-        <input type="checkbox" onclick="toggleTodo({todo.id})" />
+        <input type="checkbox" onclick="toggleTodo(todo.id)" />
         <span class="{todo.completed ? 'done' : ''}">{todo.text}</span>
-        <button onclick="removeTodo({todo.id})">🗑️</button>
+        <button onclick="removeTodo(todo.id)">🗑️</button>
       </li>
     </for>
   </ul>
@@ -633,6 +741,52 @@ A complete CRUD example combining all directives:
 ---
+## 📚 Documentation
+Full guides live in the [docs/](docs/README.md) folder:
+| Start here | Reference | Advanced |
+| ---------- | --------- | -------- |
+| [Quick Start](docs/01-quick-start.md) | [Built-in Elements & Directives](docs/06-directives.md) | [Event Bus](docs/12-event-bus.md) |
+| [Installation](docs/02-installation.md) | [Event Modifiers (`$on:`)](docs/20-event-modifiers.md) | [Lazy Loading](docs/13-lazy-loading.md) |
+| [Components](docs/03-components.md) | [Conditionals & Loops](docs/07-conditionals.md) | [Shadow DOM](docs/14-shadow-dom.md) |
+| [Reactivity](docs/04-reactivity.md) | [Two-Way Binding](docs/09-two-way-binding.md) | [Design System Guide](docs/19-design-system.md) |
+Upgrading from v1? See the [Migration Guide](docs/17-migration-v1-to-v2.md).
+Using TypeScript? See the [TypeScript guide](docs/18-typescript.md).
+---
+## 🔒 Security & Trust Model
+**Component HTML is trusted code. Treat a `.html` component the same way you'd
+treat a `.js` file you `import`.**
+LadrillosJS runs the `<script>` in each component, evaluates your `{expression}`
+bindings, and compiles your inline event handlers as JavaScript with full access
+to the page (`window`, `document`, `fetch`, `localStorage`, …). This is by design
+— it's what lets components feel like plain HTML + JS with no build step, exactly
+like the template in a Vue single-file component or a Svelte `.svelte` file. It
+also means the framework is **not** a sandbox: you should only register and run
+component files that you wrote or otherwise trust.
+Practical guidance:
+- ✅ **Do** author your own components and load them from your own origin.
+- ❌ **Don't** fetch and register component HTML from untrusted third parties, or
+  build component files by concatenating user input into a template — that's
+  equivalent to running arbitrary code from that source.
+- ✅ **Dynamic *data* is fine.** Rendering untrusted **data** — API responses,
+  user comments, list items — through bindings and `<for>` loops is safe: values
+  are set via `textContent`/`setAttribute` and passed to event handlers as
+  arguments, never executed as code. (Interpolating into `innerHTML` yourself, or
+  into a `<script>`/handler you assemble by hand, is not — same rule as above.)
+In short: untrusted **data** through LadrillosJS's bindings is safe; untrusted
+**templates/scripts** are not, because those *are* your application code.
+---
 ## 🤝 Contributing
 Contributions are welcome! Here's how you can help:
@@ -651,6 +805,7 @@ cd LadrillosJS
 npm install
 npm run dev        # Watch mode for development
 npm run build      # Build for production
+npm test           # Unit tests (Vitest)
 ```
 ---

package/dist/core/cache/expressionCache.d.ts CHANGED Viewed

@@ -1,33 +1,11 @@
 /**
- * Expression Cache
+ * Variable Regex Cache
  *
- * Caches compiled expression evaluators to avoid repeated Function() construction.
- *
- * Creating functions via new Function() is expensive:
- * - Parsing the function body
- * - JIT compilation
- * - Memory allocation
- *
- * By caching the compiled functions, we only pay this cost once per unique expression.
- */
-type ExpressionEvaluator = (context: Record<string, unknown>) => unknown;
-/**
- * Gets or creates a cached expression evaluator.
- *
- * @param expression - The expression to compile (e.g., "count + 1")
- * @param contextKeys - Variable names available in scope
- * @returns A function that evaluates the expression against a context
- *
- * @example
- * const evaluate = getCachedEvaluator("count * 2", ["count"]);
- * const result = evaluate({ count: 5 }); // 10
+ * Building a `RegExp` is comparatively expensive, and the reactivity layer
+ * checks the same variable names against many binding expressions when working
+ * out which bindings depend on which state keys. Caching the compiled regex per
+ * variable name avoids recreating it on every check.
  */
-export declare function getCachedEvaluator(expression: string, contextKeys: string[]): ExpressionEvaluator;
-/**
- * Clears all expression caches.
- * Useful for testing or when context shape changes dramatically.
- */
-export declare function clearExpressionCache(): void;
 /**
  * Gets or creates a cached regex for variable boundary matching.
  *
@@ -35,46 +13,3 @@ export declare function clearExpressionCache(): void;
  * @returns A regex that matches the variable as a whole word
  */
 export declare function getCachedVariableRegex(variableName: string): RegExp;
-/**
- * Cached check if an expression depends on a variable.
- *
- * @param expression - The expression to check
- * @param variableName - The variable to look for
- * @returns true if the expression references the variable
- */
-export declare function expressionDependsOnCached(expression: string, variableName: string): boolean;
-/**
- * Gets or creates a cached path array from a dot-notation string.
- *
- * @param pathString - The dot-notation path (e.g., "person.address.city")
- * @returns Array of path segments
- *
- * @example
- * getCachedPath("person.name") // ["person", "name"]
- */
-export declare function getCachedPath(pathString: string): readonly string[];
-/**
- * Resolves a value from an object using a cached path.
- *
- * @param obj - The object to read from
- * @param pathString - Dot-notation path
- * @returns The value at the path, or undefined
- *
- * @example
- * getByPath({ person: { name: "John" } }, "person.name") // "John"
- */
-export declare function getByPath(obj: Record<string, unknown>, pathString: string): unknown;
-/**
- * Sets a value on an object using a cached path.
- *
- * @param obj - The object to write to
- * @param pathString - Dot-notation path
- * @param value - The value to set
- *
- * @example
- * const obj = { person: { name: "John" } };
- * setByPath(obj, "person.name", "Jane");
- * // obj.person.name === "Jane"
- */
-export declare function setByPath(obj: Record<string, unknown>, pathString: string, value: unknown): void;
-export {};

package/dist/core/component/loader.d.ts CHANGED Viewed

@@ -7,4 +7,4 @@ export interface FetchComponentResult {
     /** The actual resolved path (may differ from input for folder-as-component) */
     resolvedPath: string;
 }
-export declare function fetchComponentSource(path: string): Promise<FetchComponentResult | undefined>;
+export declare function fetchComponentSource(path: string): Promise<FetchComponentResult>;

package/dist/core/configure.d.ts CHANGED Viewed

@@ -18,7 +18,31 @@ export interface LadrillosConfig {
      * });
      */
     onError?: LadrillosErrorHandler | null;
+    /**
+     * Opt-in event delegation for `<for>` loop rows. When enabled, eligible
+     * inline handlers (onclick, $on:… on bubbling events) inside loop rows
+     * share ONE listener per event type on the loop's container instead of
+     * one listener per element — faster bulk row creation and less memory on
+     * large lists. Handler code and template syntax are unchanged.
+     *
+     * Two observable differences versus direct listeners:
+     *   1. `event.currentTarget` inside a loop handler is the list container,
+     *      not the row element (`event.target` is unaffected).
+     *   2. A manual `stopPropagation()` call from a listener you attach
+     *      yourself between the row and the container stops delegated
+     *      handlers from firing.
+     *
+     * Non-bubbling events (focus, blur, mouseenter, …) and handlers using
+     * the `.self`, `.capture`, `.once`, or `.passive` modifiers automatically
+     * keep per-element listeners.
+     *
+     * Set this before components render; templates already rendered keep the
+     * mode they were created with. Defaults to false.
+     */
+    delegateLoopEvents?: boolean;
 }
+/** Whether opt-in loop event delegation is active (see LadrillosConfig). */
+export declare function isLoopDelegationEnabled(): boolean;
 /**
  * Configure framework-level options.
  *

package/dist/core/diff/listDiff.d.ts CHANGED Viewed

@@ -57,6 +57,22 @@ export declare function diffKeyed<T>(oldItems: T[], newItems: T[], getKey: (item
  * @returns Array of operations
  */
 export declare function diffUnkeyed<T>(oldLength: number, newLength: number, newItems: T[]): DiffOperation[];
+/**
+ * Computes the set of positions that form the longest increasing subsequence
+ * of `source`, ignoring entries whose value is < 0 (used to mark brand-new
+ * items that must always be (re)inserted).
+ *
+ * The loop renderer uses this to decide which reused elements are already in
+ * correct relative DOM order and can therefore stay put — only the remaining
+ * elements need to be moved. This turns an in-order content update into zero
+ * DOM moves and minimizes moves for partial reorders.
+ *
+ * Runs in O(n log n) using patience sorting with predecessor links.
+ *
+ * @param source - For each new position, the element's previous index, or -1 if new
+ * @returns Set of new-position indices that should NOT be moved
+ */
+export declare function getStableIndices(source: number[]): Set<number>;
 /**
  * Creates a key getter function from a key expression.
  *

package/dist/core/html/controlTagEscape.d.ts ADDED Viewed

@@ -0,0 +1,47 @@
+/**
+ * Table-safe parsing for built-in control elements.
+ *
+ * The HTML parser's table insertion modes foster-parent anything that is
+ * not valid table content out of `<table>`/`<thead>`/`<tbody>`/`<tr>`.
+ * Built-in control elements (`<for>`, `<if>`, `<else-if>`, `<else>`,
+ * `<show>`) are unknown to the parser, so markup like
+ *
+ *   <table><tbody>
+ *     <for each="row in rows" key="row.id">
+ *       <tr><td>{row.id}</td></tr>
+ *     </for>
+ *   </tbody></table>
+ *
+ * gets mangled BEFORE the framework ever sees the tree: `<for>` is
+ * hoisted out of the table and the raw `<tr>` template is left behind,
+ * un-bound. This applies to every parse entry point — `DOMParser` and
+ * `template.innerHTML` alike.
+ *
+ * `<template>` elements, however, ARE valid anywhere inside a table, and
+ * their content model is parsed leniently (a bare `<tr>` or `<td>` inside
+ * template content survives). So before parsing we rewrite control tags to
+ * `<template data-l-ctrl="…">` placeholders at the string level, and after
+ * parsing we rebuild the real control elements with DOM APIs — which the
+ * parser's content rules cannot touch.
+ */
+/**
+ * Rewrites control-element tags to `<template data-l-ctrl="…">`
+ * placeholders so the HTML parser cannot foster-parent them out of table
+ * contexts. Must be paired with {@link restoreControlTags} on the parsed
+ * tree.
+ */
+export declare function escapeControlTags(html: string): string;
+/**
+ * Rebuilds real control elements from the placeholders produced by
+ * {@link escapeControlTags}. Runs until no placeholder remains: restoring
+ * an outer placeholder moves its (previously inert) template content into
+ * the live tree, exposing any nested placeholders to the next iteration.
+ * User-authored `<template>` elements are recursed into so control tags
+ * inside their inert content are restored as well.
+ */
+export declare function restoreControlTags(root: ParentNode): void;
+/**
+ * Returns true when the element is a restored control element
+ * (`<for>`, `<if>`, `<else-if>`, `<else>`, `<show>`).
+ */
+export declare function isControlElement(el: Element): boolean;

package/dist/core/js/moduleExecutor.d.ts CHANGED Viewed

@@ -20,6 +20,25 @@ export declare function rewriteImports(code: string, baseUrl: string): string;
  * @returns Promise that resolves when the module has executed
  */
 export declare function executeModuleScript(script: ScriptElement, componentUrl: string, componentId?: string): Promise<unknown>;
+/**
+ * Transforms import statements to wrap imported values in reactive proxies.
+ * This enables imported arrays to trigger UI updates when mutated.
+ *
+ * Transforms:
+ *   import { foo, bar } from "./module.js";
+ *
+ * Into:
+ *   import { foo as __raw_foo, bar as __raw_bar } from "./module.js";
+ *   const foo = __wrapReactiveArray(__raw_foo, __ladrillos_componentId, "foo");
+ *   const bar = __wrapReactiveArray(__raw_bar, __ladrillos_componentId, "bar");
+ *
+ * @param code - The module code with imports
+ * @returns Transformed code with reactive import wrapping
+ *
+ * Exported for tests (the blob-URL execution path can't run under Node).
+ */
+export declare function transformImportsForReactivity(code: string): string;
+export declare function generateHelperInjectionCode(componentId?: string, componentUrl?: string, exclude?: ReadonlySet<string>): string;
 /**
  * Executes an external module script.
  * For external scripts, we fetch the content, auto-export all declarations,

package/dist/core/js/scriptParser.d.ts CHANGED Viewed

@@ -31,6 +31,8 @@ export declare function applyBindingsDeferred(host: HTMLElement | ShadowRoot, bi
  * Extracts function definitions from script content.
  * These will be re-created in the event handler context with current state values.
  *
+ * Memoized: the output is a pure function of (content, skipFunctions).
+ *
  * @param content - The script content to extract functions from
  * @param skipFunctions - Function names to skip (already in state as reactive functions)
  */
@@ -44,9 +46,41 @@ export declare function extractFunctionDefinitions(content: string, skipFunction
  * Exported so webcomponent.ts can use it for observedAttributes.
  */
 export declare function extractVariableNames(content: string): string[];
+/**
+ * A pass-scoped evaluator bound to one context object, produced by
+ * `DirectiveEvaluator.forContext`. Callable as `(expr) => unknown`; the
+ * optional members let hot loops skip per-eval overhead (see
+ * `createContextEvaluator` for the mode semantics).
+ */
+export interface BoundEvaluator {
+    (expr: string): unknown;
+    /**
+     * Refill argument slots from the context: the volatile slots in static
+     * mode, all slots in legacy mode. Static-mode callers MUST call this
+     * after mutating a volatile context value.
+     */
+    refresh?: () => void;
+    /** Compiled Function for `expr` under this key set, or null on a syntax error. */
+    compile?: (expr: string) => Function | null;
+    /** Invoke a Function from `compile` against the current argument slots. */
+    invoke?: (fn: Function, expr: string) => unknown;
+    /** Key-set signature; compiled Functions are only valid for a matching sig. */
+    sig?: string;
+}
+/**
+ * Directive-facing expression evaluator. Callable as
+ * `(expr, context) => unknown`; `forContext` additionally builds a
+ * pass-scoped fast evaluator bound to one context object (see
+ * `createContextEvaluator`) whose key set must not change for the
+ * lifetime of the returned function.
+ */
+export interface DirectiveEvaluator {
+    (expr: string, context: Record<string, unknown>): unknown;
+    forContext(context: Record<string, unknown>, volatileKeys?: readonly string[]): BoundEvaluator;
+}
 /**
  * Creates and returns an expression evaluator function for use by directives.
  * This allows directives to evaluate expressions like "item.name" or "count > 5"
  * in the context of the component's state.
  */
-export declare function createExpressionEvaluator(): (expr: string, context: Record<string, unknown>) => unknown;
+export declare function createExpressionEvaluator(): DirectiveEvaluator;

package/dist/core.d.ts CHANGED Viewed

@@ -1,10 +1,10 @@
 import { ComponentConfig, RegisterComponentsResult } from './core/ladrillos';
 import { registerComponent, registerComponents, $use } from './core/helpers/frameworkHelpers';
 import { configure, LadrillosConfig } from './core/configure';
-import { ErrorCode, LadrillosErrorHandler } from './utils/devWarnings';
+import { ErrorCode, LadrillosError, LadrillosErrorHandler } from './utils/devWarnings';
 export type { ComponentConfig, RegisterComponentsResult, LadrillosConfig, LadrillosErrorHandler, };
 export type { LadrillosComponent } from './types';
-export { ErrorCode };
+export { ErrorCode, LadrillosError };
 export { registerComponent, registerComponents, $use, configure };
 declare const _default: {
     registerComponent: (name: string, path: string, useShadowDOM?: boolean, lazy?: boolean | import('.').LazyStrategy) => Promise<void>;

package/dist/core.dev.js ADDED Viewed

@@ -0,0 +1,12 @@
+import { d as ErrorCode, f as LadrillosError, h as registerComponents, i as configure, m as registerComponent, p as $use } from "./shared-R1SSiaIW.dev.js";
+//#region src/core.ts
+var core_default = {
+	registerComponent,
+	registerComponents,
+	$use,
+	configure
+};
+//#endregion
+export { $use, ErrorCode, LadrillosError, configure, core_default as default, registerComponent, registerComponents };
+//# sourceMappingURL=core.dev.js.map

package/dist/core.dev.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"core.dev.js","names":[],"sources":["../src/core.ts"],"sourcesContent":["/**\r\n * LadrillosJS Core - Minimal bundle\r\n *\r\n * This is the core module containing only essential functionality.\r\n * Use this for the smallest possible bundle size.\r\n *\r\n * @example\r\n * ```ts\r\n * import { registerComponent } from 'ladrillosjs/core';\r\n * ```\r\n *\r\n * For additional features, import from:\r\n * - 'ladrillosjs/lazy' - Lazy loading strategies\r\n * - 'ladrillosjs/events' - Event bus for cross-component communication\r\n */\r\n\r\nimport { ComponentConfig, RegisterComponentsResult } from \"./core/ladrillos\";\r\nimport\r\n {\r\n registerComponent,\r\n registerComponents,\r\n $use,\r\n } from \"./core/helpers/frameworkHelpers\";\r\nimport { configure, LadrillosConfig } from \"./core/configure\";\r\nimport\r\n {\r\n ErrorCode,\r\n LadrillosError,\r\n type LadrillosErrorHandler,\r\n } from \"./utils/devWarnings\";\r\n\r\n// Export public types\r\nexport type {\r\n ComponentConfig,\r\n RegisterComponentsResult,\r\n LadrillosConfig,\r\n LadrillosErrorHandler,\r\n};\r\nexport type { LadrillosComponent } from \"./types\";\r\n\r\n// Export error code enum\r\nexport { ErrorCode, LadrillosError };\r\n\r\n// Public exports\r\nexport { registerComponent, registerComponents, $use, configure };\r\n\r\n// Default export for CDN usage\r\nexport default {\r\n registerComponent,\r\n registerComponents,\r\n $use,\r\n configure,\r\n};\r\n"],"mappings":";;AA+CA,IAAA,eAAe;CACb;CACA;CACA;CACA;AACF"}

package/dist/core.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{$ as r,r as s,e}from"./shared-CM0Gy9QI.js";import{E as o}from"./shared-CM0Gy9QI.js";import{c as a}from"./shared-7ZWfGAEo.js";const t={registerComponent:e,registerComponents:s,$use:r,configure:a};export{r as $use,o as ErrorCode,a as configure,t as default,e as registerComponent,s as registerComponents};
-//# sourceMappingURL=core.js.map
+import{d as s,f as e,h as a,i as r,m as o,p as t}from"./shared-CMbR-Hhy.js";var i={registerComponent:o,registerComponents:a,$use:t,configure:r};export{t as $use,s as ErrorCode,e as LadrillosError,r as configure,i as default,o as registerComponent,a as registerComponents};
+//# sourceMappingURL=core.js.map

package/dist/core.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"core.js","sources":["../src/core.ts"],"sourcesContent":["/*\r\n LadrillosJS Core - Minimal bundle\r\n \r\n This is the core module containing only essential functionality.\r\n * Use this for the smallest possible bundle size.\r\n \r\n @example\r\n * ```ts\r\n * import { registerComponent } from 'ladrillosjs/core';\r\n * ```\r\n \r\n For additional features, import from:\r\n * - 'ladrillosjs/lazy' - Lazy loading strategies\r\n * - 'ladrillosjs/events' - Event bus for cross-component communication\r\n */\r\n\r\nimport { ComponentConfig, RegisterComponentsResult } from \"./core/ladrillos\";\r\nimport {\r\n registerComponent,\r\n registerComponents,\r\n $use,\r\n} from \"./core/helpers/frameworkHelpers\";\r\nimport { configure, LadrillosConfig } from \"./core/configure\";\r\nimport { ErrorCode, type LadrillosErrorHandler } from \"./utils/devWarnings\";\r\n\r\n// Export public types\r\nexport type {\r\n ComponentConfig,\r\n RegisterComponentsResult,\r\n LadrillosConfig,\r\n LadrillosErrorHandler,\r\n};\r\nexport type { LadrillosComponent } from \"./types\";\r\n\r\n// Export error code enum\r\nexport { ErrorCode };\r\n\r\n// Public exports\r\nexport { registerComponent, registerComponents, $use, configure };\r\n\r\n// Default export for CDN usage\r\nexport default {\r\n registerComponent,\r\n registerComponents,\r\n $use,\r\n configure,\r\n};\r\n"],"~~names":["core","registerComponent","registerComponents","$use","configure"],"~~mappings":"~~oIAyCA~~,~~MAAAA~~,EAAe,~~CACbC~~,~~oBACAC~~,~~qBACAC~~,~~OACAC~~"}
1	+ {"version":3,"file":"core.js","names":[],"sources":["../src/core.ts"],"sourcesContent":["/*\r\n LadrillosJS Core - Minimal bundle\r\n \r\n This is the core module containing only essential functionality.\r\n * Use this for the smallest possible bundle size.\r\n \r\n @example\r\n * ```ts\r\n * import { registerComponent } from 'ladrillosjs/core';\r\n * ```\r\n \r\n For additional features, import from:\r\n * - 'ladrillosjs/lazy' - Lazy loading strategies\r\n * - 'ladrillosjs/events' - Event bus for cross-component communication\r\n */\r\n\r\nimport { ComponentConfig, RegisterComponentsResult } from \"./core/ladrillos\";\r\nimport\r\n {\r\n registerComponent,\r\n registerComponents,\r\n $use,\r\n } from \"./core/helpers/frameworkHelpers\";\r\nimport { configure, LadrillosConfig } from \"./core/configure\";\r\nimport\r\n {\r\n ErrorCode,\r\n LadrillosError,\r\n type LadrillosErrorHandler,\r\n } from \"./utils/devWarnings\";\r\n\r\n// Export public types\r\nexport type {\r\n ComponentConfig,\r\n RegisterComponentsResult,\r\n LadrillosConfig,\r\n LadrillosErrorHandler,\r\n};\r\nexport type { LadrillosComponent } from \"./types\";\r\n\r\n// Export error code enum\r\nexport { ErrorCode, LadrillosError };\r\n\r\n// Public exports\r\nexport { registerComponent, registerComponents, $use, configure };\r\n\r\n// Default export for CDN usage\r\nexport default {\r\n registerComponent,\r\n registerComponents,\r\n $use,\r\n configure,\r\n};\r\n"],"mappings":"4EA+CA,IAAA,EAAe,CACb,oBACA,qBACA,OACA"}

package/dist/events.dev.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { n as $listen, t as $emit } from "./shared-Sk_U4mcq.dev.js";
2	+ export { $emit, $listen };

package/dist/events.js CHANGED Viewed

@@ -1,2 +1 @@
-import{a as s,$ as e}from"./shared-DGGk2qBc.js";export{s as $emit,e as $listen};
-//# sourceMappingURL=events.js.map
+import{n as r,t as s}from"./shared-DqWGO1vN.js";export{s as $emit,r as $listen};

package/dist/index.d.ts CHANGED Viewed

@@ -2,11 +2,11 @@ import { ComponentConfig, RegisterComponentsResult } from './core/ladrillos';
 import { registerComponent, registerComponents, $use } from './core/helpers/frameworkHelpers';
 import { $emit, $listen, EventCallback } from './core/events/eventBus';
 import { configure, LadrillosConfig } from './core/configure';
-import { ErrorCode, LadrillosErrorHandler } from './utils/devWarnings';
+import { ErrorCode, LadrillosError, LadrillosErrorHandler } from './utils/devWarnings';
 import { LazyStrategy, lazyOnIdle, lazyOnVisible, lazyOnMedia, lazyOnInteraction, lazyOnDelay } from './core/lazy';
 export type { ComponentConfig, RegisterComponentsResult, EventCallback, LazyStrategy, LadrillosConfig, LadrillosErrorHandler, };
 export type { LadrillosComponent } from './types';
-export { ErrorCode };
+export { ErrorCode, LadrillosError };
 export { lazyOnIdle, lazyOnVisible, lazyOnMedia, lazyOnInteraction, lazyOnDelay, };
 export declare const loadLazyComponent: (name: string) => Promise<import('./types').LadrillosComponent | undefined>;
 export { configure };

package/dist/index.dev.js ADDED Viewed

@@ -0,0 +1,22 @@
+import { c as lazyOnInteraction, d as ErrorCode, f as LadrillosError, h as registerComponents, i as configure, l as lazyOnMedia, m as registerComponent, o as lazyOnDelay, p as $use, s as lazyOnIdle, t as ladrillos, u as lazyOnVisible } from "./shared-R1SSiaIW.dev.js";
+import { n as $listen, t as $emit } from "./shared-Sk_U4mcq.dev.js";
+//#region src/index.ts
+var loadLazyComponent = (name) => ladrillos.loadLazyComponent(name);
+var src_default = {
+	registerComponent,
+	registerComponents,
+	$use,
+	$emit,
+	$listen,
+	loadLazyComponent,
+	configure,
+	lazyOnIdle,
+	lazyOnVisible,
+	lazyOnMedia,
+	lazyOnInteraction,
+	lazyOnDelay
+};
+//#endregion
+export { $emit, $listen, $use, ErrorCode, LadrillosError, configure, src_default as default, lazyOnDelay, lazyOnIdle, lazyOnInteraction, lazyOnMedia, lazyOnVisible, loadLazyComponent, registerComponent, registerComponents };
+//# sourceMappingURL=index.dev.js.map

package/dist/index.dev.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.dev.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import\r\n {\r\n ladrillos,\r\n ComponentConfig,\r\n RegisterComponentsResult,\r\n } from \"./core/ladrillos\";\r\nimport\r\n {\r\n registerComponent,\r\n registerComponents,\r\n $use,\r\n } from \"./core/helpers/frameworkHelpers\";\r\nimport { $emit, $listen, EventCallback } from \"./core/events/eventBus\";\r\nimport { configure, LadrillosConfig } from \"./core/configure\";\r\nimport\r\n {\r\n ErrorCode,\r\n LadrillosError,\r\n type LadrillosErrorHandler,\r\n } from \"./utils/devWarnings\";\r\n\r\n// Import lazy loading strategies\r\nimport\r\n {\r\n LazyStrategy,\r\n lazyOnIdle,\r\n lazyOnVisible,\r\n lazyOnMedia,\r\n lazyOnInteraction,\r\n lazyOnDelay,\r\n } from \"./core/lazy\";\r\n\r\n// Export public types\r\nexport type {\r\n ComponentConfig,\r\n RegisterComponentsResult,\r\n EventCallback,\r\n LazyStrategy,\r\n LadrillosConfig,\r\n LadrillosErrorHandler,\r\n};\r\nexport type { LadrillosComponent } from \"./types\";\r\n\r\n// Export error code enum for consumers to branch on\r\nexport { ErrorCode, LadrillosError };\r\n\r\n// Export lazy loading strategies\r\nexport\r\n{\r\n lazyOnIdle,\r\n lazyOnVisible,\r\n lazyOnMedia,\r\n lazyOnInteraction,\r\n lazyOnDelay,\r\n};\r\n\r\n// Force load a lazy component\r\nexport const loadLazyComponent = (name: string) =>\r\n ladrillos.loadLazyComponent(name);\r\n\r\n// Framework configuration\r\nexport { configure };\r\n\r\n// Component registration + $use alias + event bus helpers\r\nexport { registerComponent, registerComponents, $use, $emit, $listen };\r\n\r\n// Default export with all methods for CDN usage\r\n// This allows: ladrillosjs.registerComponent() in CDN mode\r\nexport default {\r\n registerComponent,\r\n registerComponents,\r\n $use,\r\n $emit,\r\n $listen,\r\n loadLazyComponent,\r\n configure,\r\n // Lazy loading strategies\r\n lazyOnIdle,\r\n lazyOnVisible,\r\n lazyOnMedia,\r\n lazyOnInteraction,\r\n lazyOnDelay,\r\n};\r\n"],"mappings":";;;AAyDA,IAAa,qBAAqB,SAChC,UAAU,kBAAkB,IAAI;AAUlC,IAAA,cAAe;CACb;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;AACF"}