dalila 1.9.2 → 1.9.4

package/dist/runtime/component.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Dalila Component System
+ *
+ * Declarative component definitions for use with bind().
+ * This module contains only types, defineComponent, and pure helpers —
+ * no imports from bind.ts (avoids circular dependency).
+ *
+ * @module dalila/runtime/component
+ */
+import type { Signal } from '../core/signal.js';
+export type PropConstructor = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor | FunctionConstructor;
+export interface PropDefinition {
+    type: PropConstructor;
+    required?: boolean;
+    default?: unknown;
+}
+export type PropOption = PropConstructor | PropDefinition;
+export type PropsSchema = Record<string, PropOption>;
+type InferPropType<T extends PropConstructor> = T extends StringConstructor ? string : T extends NumberConstructor ? number : T extends BooleanConstructor ? boolean : T extends ArrayConstructor ? unknown[] : T extends ObjectConstructor ? Record<string, unknown> : T extends FunctionConstructor ? Function : unknown;
+type InferPropOptionType<T extends PropOption> = T extends PropConstructor ? InferPropType<T> : T extends {
+    type: infer C extends PropConstructor;
+    default: infer D;
+} ? D extends (...args: any[]) => infer R ? R : InferPropType<C> : T extends {
+    type: infer C extends PropConstructor;
+} ? InferPropType<C> : unknown;
+export type TypedPropSignals<P extends PropsSchema> = {
+    [K in keyof P]: Signal<InferPropOptionType<P[K]>>;
+};
+/** @deprecated Use TypedPropSignals instead */
+export type PropSignals<P> = {
+    [K in keyof P]: Signal<unknown>;
+};
+export type EmitsSchema = Record<string, unknown>;
+export type RefsSchema = Record<string, Element>;
+export type TypedEmit<E extends EmitsSchema> = <K extends keyof E & string>(event: K, payload: E[K]) => void;
+export type TypedRef<R extends RefsSchema> = <K extends keyof R & string>(name: K) => R[K] | null;
+export interface TypedSetupContext<E extends EmitsSchema = EmitsSchema, R extends RefsSchema = RefsSchema> {
+    ref: TypedRef<R>;
+    refs(): Readonly<Partial<R>>;
+    emit: TypedEmit<E>;
+    onMount(fn: () => void): void;
+    onCleanup(fn: () => void): void;
+}
+/** @deprecated Use TypedSetupContext instead */
+export interface SetupContext {
+    ref(name: string): Element | null;
+    refs(): Readonly<Record<string, Element>>;
+    emit(event: string, ...args: unknown[]): void;
+    onMount(fn: () => void): void;
+    onCleanup(fn: () => void): void;
+}
+export interface ComponentDefinition<P extends PropsSchema = PropsSchema, E extends EmitsSchema = EmitsSchema, R extends RefsSchema = RefsSchema> {
+    tag: string;
+    template: string;
+    props?: P;
+    setup?: (props: TypedPropSignals<P>, ctx: TypedSetupContext<E, R>) => Record<string, unknown>;
+}
+/**
+ * Erased component handle used by bind() and mount().
+ * The generic P from defineComponent is erased here so that
+ * any Component can be stored in a Record<string, Component> registry
+ * without variance issues.
+ */
+export interface Component {
+    readonly __dalila_component: true;
+    readonly definition: ComponentDefinition<any, any, any>;
+}
+export declare function defineComponent<P extends PropsSchema = PropsSchema, E extends EmitsSchema = EmitsSchema, R extends RefsSchema = RefsSchema>(def: ComponentDefinition<P, E, R>): Component;
+export declare function isComponent(value: unknown): value is Component;
+export declare function normalizePropDef(option: PropOption): PropDefinition;
+export declare function coercePropValue(raw: string, type: PropConstructor): unknown;
+export declare function kebabToCamel(str: string): string;
+export declare function camelToKebab(str: string): string;
+export {};

package/dist/runtime/component.js

@@ -0,0 +1,40 @@
+/**
+ * Dalila Component System
+ *
+ * Declarative component definitions for use with bind().
+ * This module contains only types, defineComponent, and pure helpers —
+ * no imports from bind.ts (avoids circular dependency).
+ *
+ * @module dalila/runtime/component
+ */
+// ============================================================================
+// defineComponent
+// ============================================================================
+export function defineComponent(def) {
+    if (!def.tag || !def.tag.includes('-')) {
+        throw new Error(`[Dalila] defineComponent: tag "${def.tag}" must contain a hyphen.`);
+    }
+    return { __dalila_component: true, definition: def };
+}
+export function isComponent(value) {
+    return typeof value === 'object' && value !== null && value.__dalila_component === true;
+}
+// ============================================================================
+// Prop Helpers
+// ============================================================================
+export function normalizePropDef(option) {
+    return typeof option === 'function' ? { type: option } : option;
+}
+export function coercePropValue(raw, type) {
+    switch (type) {
+        case Number: return Number(raw);
+        case Boolean: return raw !== 'false' && raw !== '0';
+        default: return raw;
+    }
+}
+export function kebabToCamel(str) {
+    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function camelToKebab(str) {
+    return str.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
+}

package/dist/runtime/fromHtml.d.ts

@@ -9,9 +9,9 @@
  * @module dalila/runtime
  */
 import type { Scope } from '../core/scope.js';
-export interface FromHtmlOptions {
+export interface FromHtmlOptions<T extends Record<string, unknown> = Record<string, unknown>> {
     /** Bind context — keys map to {placeholder} tokens in the HTML */
-    data?: Record<string, unknown>;
+    data?: T;
     /** Child nodes to inject into [data-slot="children"] */
     children?: Node | DocumentFragment | Node[];
     /** Route scope — registers bind cleanup automatically */
@@ -32,4 +32,5 @@ export interface FromHtmlOptions {
  * const el = fromHtml('<div><div data-slot="children"></div></div>', { children });
  * ```
  */
+export declare function fromHtml<T extends Record<string, unknown>>(html: string, options: FromHtmlOptions<T>): HTMLElement;
 export declare function fromHtml(html: string, options?: FromHtmlOptions): HTMLElement;

package/dist/runtime/fromHtml.js

@@ -9,21 +9,6 @@
  * @module dalila/runtime
  */
 import { bind } from './bind.js';
-/**
- * Parse an HTML string into a bound DOM element.
- *
- * @example
- * ```ts
- * // Static HTML
- * const el = fromHtml('<div><h1>Hello</h1></div>');
- *
- * // With data binding
- * const el = fromHtml('<div>{name}</div>', { data: { name: 'Dalila' } });
- *
- * // Layout with children slot
- * const el = fromHtml('<div><div data-slot="children"></div></div>', { children });
- * ```
- */
 export function fromHtml(html, options = {}) {
     const { data, children, scope } = options;
     const template = document.createElement('template');

package/dist/runtime/index.d.ts

@@ -6,7 +6,9 @@
  *
  * @module dalila/runtime
  */
-export { bind, autoBind } from './bind.js';
-export type { BindOptions, BindContext, DisposeFunction } from './bind.js';
+export { bind, autoBind, mount, configure } from './bind.js';
+export type { BindOptions, BindContext, BindData, DisposeFunction, BindHandle } from './bind.js';
 export { fromHtml } from './fromHtml.js';
 export type { FromHtmlOptions } from './fromHtml.js';
+export { defineComponent } from './component.js';
+export type { Component, ComponentDefinition, PropsSchema, PropSignals, SetupContext, TypedPropSignals, TypedSetupContext, EmitsSchema, RefsSchema, TypedEmit, TypedRef, } from './component.js';

package/dist/runtime/index.js

@@ -6,5 +6,6 @@
  *
  * @module dalila/runtime
  */
-export { bind, autoBind } from './bind.js';
+export { bind, autoBind, mount, configure } from './bind.js';
 export { fromHtml } from './fromHtml.js';
+export { defineComponent } from './component.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dalila",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "description": "DOM-first reactive framework based on signals",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -100,7 +100,7 @@
     "build": "tsc && node scripts/ensure-cli-executable.cjs",
     "dev": "tsc --watch",
     "serve": "node scripts/dev-server.cjs",
-    "test": "npm run build && node --test",
+    "test": "npm run build && node --test --test-concurrency=1 test/*.test.js",
     "test:e2e": "npm run build && playwright test",
     "test:watch": "jest --watch",
     "clean": "rm -rf dist",

package/scripts/dev-server.cjs

@@ -718,6 +718,12 @@ const server = http.createServer((req, res) => {
   const effectivePath =
     requestPath === '/' || requestPath === '/index.html' ? defaultEntry : requestPath;
   let resolvedRequestPath = effectivePath;
+  const fetchModeHeader = req.headers['sec-fetch-mode'];
+  const fetchDestHeader = req.headers['sec-fetch-dest'];
+  const fetchMode = Array.isArray(fetchModeHeader) ? fetchModeHeader[0] : fetchModeHeader;
+  const fetchDest = Array.isArray(fetchDestHeader) ? fetchDestHeader[0] : fetchDestHeader;
+  const isNavigationRequest = fetchMode === 'navigate' || fetchDest === 'document';
+  const isScriptRequest = fetchDest === 'script';
   const fsPath = resolvePath(effectivePath);
 
   if (!fsPath) {
@@ -748,17 +754,48 @@ const server = http.createServer((req, res) => {
         return;
       }
     } else {
-      const spaFallback = resolveSpaFallbackPath(requestPath);
-      if (spaFallback) {
-        targetPath = spaFallback.fsPath;
-        resolvedRequestPath = spaFallback.requestPath;
+      // Extensionless import — try .ts, then .js
+      const tsPath = targetPath + '.ts';
+      const jsPath = targetPath + '.js';
+      if (!path.extname(targetPath) && isScriptRequest && fs.existsSync(tsPath)) {
+        targetPath = tsPath;
+      } else if (!path.extname(targetPath) && isScriptRequest && fs.existsSync(jsPath)) {
+        targetPath = jsPath;
       } else {
-        send(res, 404, 'Not Found');
-        return;
+        const spaFallback = resolveSpaFallbackPath(requestPath);
+        if (spaFallback) {
+          targetPath = spaFallback.fsPath;
+          resolvedRequestPath = spaFallback.requestPath;
+        } else {
+          send(res, 404, 'Not Found');
+          return;
+        }
       }
     }
   }
 
+  // Raw import — serve file as `export default` JS module.
+  // Triggered by ?raw suffix OR .html imported as script/module.
+  const isRawQuery = req.url && req.url.includes('?raw');
+  const isHtmlModuleImport = targetPath.endsWith('.html')
+    && isScriptRequest
+    && !isNavigationRequest;
+  if (isRawQuery || isHtmlModuleImport) {
+    fs.readFile(targetPath, 'utf8', (err, source) => {
+      if (err) {
+        send(res, err.code === 'ENOENT' ? 404 : 500, err.code === 'ENOENT' ? 'Not Found' : 'Error');
+        return;
+      }
+      const escaped = source.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+      res.writeHead(200, {
+        'Content-Type': 'text/javascript; charset=utf-8',
+        'Cache-Control': 'no-store, no-cache, must-revalidate',
+      });
+      res.end(`export default \`${escaped}\`;`);
+    });
+    return;
+  }
+
   // TypeScript transpilation (only if ts available)
   if (targetPath.endsWith('.ts') && ts) {
     fs.readFile(targetPath, 'utf8', (err, source) => {
@@ -1009,5 +1046,8 @@ setupWatcher();
 startKeepalive();
 
 server.listen(port, () => {
-  console.log(`Dalila dev server on http://localhost:${port}`);
+  console.log('');
+  console.log('  🐰 ✂️  Dalila dev server');
+  console.log(`        http://localhost:${port}`);
+  console.log('');
 });