dalila 1.5.0 → 1.5.2

package/dist/core/index.d.ts

@@ -4,7 +4,6 @@ export * from "./watch.js";
 export * from "./when.js";
 export * from "./match.js";
 export * from "./for.js";
-export * from "./virtual.js";
 export * from "./html.js";
 export * from "./dev.js";
 export * from "./key.js";

package/dist/core/index.js

@@ -4,7 +4,6 @@ export * from "./watch.js";
 export * from "./when.js";
 export * from "./match.js";
 export * from "./for.js";
-export * from "./virtual.js";
 export * from "./html.js";
 export * from "./dev.js";
 export * from "./key.js";

package/dist/index.d.ts

@@ -2,4 +2,3 @@ export * from "./core/index.js";
 export * from "./context/index.js";
 export * from "./router/index.js";
 export * from "./runtime/index.js";
-export * from "./form/index.js";

package/dist/index.js

@@ -2,4 +2,3 @@ export * from "./core/index.js";
 export * from "./context/index.js";
 export * from "./router/index.js";
 export * from "./runtime/index.js";
-export * from "./form/index.js";

package/dist/router/route-tables.d.ts

@@ -1,5 +1,5 @@
 import type { Scope } from '../core/scope.js';
-import type { Rule } from '../form/index.js';
+import type { Rule } from './validation.js';
 /** Options for programmatic navigation. */
 export interface NavigateOptions {
     replace?: boolean;
@@ -22,7 +22,7 @@ export type RouteQueryValues = Record<string, string | string[]>;
 export type RouteParamValidationValue = RouteParamValue | undefined;
 export type RouteQueryValidationSchema = Record<string, Array<Rule<RouteQueryValue, RouteQueryValues>>>;
 export type RouteParamsValidationSchema = Record<string, Array<Rule<RouteParamValidationValue, RouteParamsValues>>>;
-/** Schema for params/query validation (uses same rule format as dalila/form). */
+/** Schema for params/query validation (router built-in rule format). */
 export interface RouteValidationConfig {
     query?: RouteQueryValidationSchema;
     params?: RouteParamsValidationSchema;

package/dist/router/router.js

@@ -1,6 +1,6 @@
 import { signal } from '../core/signal.js';
 import { createScope, withScope, withScopeAsync } from '../core/scope.js';
-import { normalizeRules, validateValue } from '../form/index.js';
+import { normalizeRules, validateValue } from './validation.js';
 import { compileRoutes, findCompiledRouteStackResult, normalizePath } from './route-tables.js';
 /** Singleton reference to the most recently created router. */
 let currentRouter = null;

package/dist/router/validation.d.ts

@@ -0,0 +1,9 @@
+export type RuleFn<TValue = unknown, TValues = Record<string, unknown>> = (value: TValue, values: TValues) => string | boolean | null | undefined;
+export interface RuleConfig<TValue = unknown, TValues = Record<string, unknown>> {
+    rule: string | RuleFn<TValue, TValues>;
+    value?: unknown;
+    message?: string;
+}
+export type Rule<TValue = unknown, TValues = Record<string, unknown>> = string | RuleFn<TValue, TValues> | RuleConfig<TValue, TValues>;
+export declare function normalizeRules<TValue = unknown, TValues = Record<string, unknown>>(rules: Array<Rule<TValue, TValues>>, _field?: string): Array<RuleFn<TValue, TValues>>;
+export declare function validateValue<TValue = unknown, TValues = Record<string, unknown>>(value: TValue, values: TValues, validators: Array<RuleFn<TValue, TValues>>, _field?: string): string | null;

package/dist/router/validation.js

@@ -0,0 +1,178 @@
+function hasValue(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value === 'string')
+        return value.trim().length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    return true;
+}
+function toLength(value) {
+    if (typeof value === 'string' || Array.isArray(value))
+        return value.length;
+    if (typeof value === 'number')
+        return value;
+    return null;
+}
+function toNumericOrLength(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed.length === 0)
+            return 0;
+        const numeric = Number(trimmed);
+        if (Number.isFinite(numeric))
+            return numeric;
+        return value.length;
+    }
+    if (Array.isArray(value)) {
+        return value.length;
+    }
+    return null;
+}
+function toNumber(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function parseRuleName(input) {
+    const separator = input.indexOf(':');
+    if (separator === -1) {
+        return { name: input.trim(), arg: undefined };
+    }
+    return {
+        name: input.slice(0, separator).trim(),
+        arg: input.slice(separator + 1).trim()
+    };
+}
+function normalizeInValues(value) {
+    if (Array.isArray(value))
+        return value.map(v => String(v));
+    if (typeof value === 'string')
+        return value.split(',').map(v => v.trim()).filter(Boolean);
+    return [];
+}
+function buildBuiltinRule(name, rawArg, message) {
+    const fail = (fallback) => message ?? fallback;
+    switch (name) {
+        case 'required':
+            return value => (hasValue(value) ? undefined : fail('This field is required.'));
+        case 'min': {
+            const min = toNumber(rawArg);
+            if (min === null)
+                return () => undefined;
+            return value => {
+                const size = toNumericOrLength(value);
+                if (size === null)
+                    return undefined;
+                return size >= min ? undefined : fail(`Must be at least ${min}.`);
+            };
+        }
+        case 'max': {
+            const max = toNumber(rawArg);
+            if (max === null)
+                return () => undefined;
+            return value => {
+                const size = toNumericOrLength(value);
+                if (size === null)
+                    return undefined;
+                return size <= max ? undefined : fail(`Must be at most ${max}.`);
+            };
+        }
+        case 'pattern': {
+            const pattern = typeof rawArg === 'string' ? rawArg : String(rawArg ?? '');
+            if (!pattern)
+                return () => undefined;
+            let regex;
+            try {
+                regex = new RegExp(pattern);
+            }
+            catch {
+                return () => undefined;
+            }
+            return value => {
+                if (value === undefined || value === null)
+                    return undefined;
+                return regex.test(String(value)) ? undefined : fail('Invalid format.');
+            };
+        }
+        case 'email': {
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            return value => {
+                if (value === undefined || value === null || value === '')
+                    return undefined;
+                return emailRegex.test(String(value)) ? undefined : fail('Invalid email.');
+            };
+        }
+        case 'in': {
+            const allowed = normalizeInValues(rawArg);
+            if (allowed.length === 0)
+                return () => undefined;
+            return value => {
+                if (value === undefined || value === null)
+                    return undefined;
+                return allowed.includes(String(value)) ? undefined : fail(`Must be one of: ${allowed.join(', ')}.`);
+            };
+        }
+        default:
+            return () => undefined;
+    }
+}
+export function normalizeRules(rules, _field) {
+    const normalized = [];
+    for (const rule of rules) {
+        if (typeof rule === 'function') {
+            normalized.push(rule);
+            continue;
+        }
+        if (typeof rule === 'string') {
+            const { name, arg } = parseRuleName(rule);
+            if (!name)
+                continue;
+            normalized.push(buildBuiltinRule(name, arg));
+            continue;
+        }
+        if (!rule || typeof rule !== 'object') {
+            continue;
+        }
+        if (typeof rule.rule === 'function') {
+            const fn = rule.rule;
+            normalized.push((value, values) => {
+                const result = fn(value, values);
+                if (result === true || result === undefined || result === null)
+                    return undefined;
+                if (result === false)
+                    return rule.message ?? 'Invalid value.';
+                return typeof result === 'string' ? result : undefined;
+            });
+            continue;
+        }
+        if (typeof rule.rule === 'string') {
+            normalized.push(buildBuiltinRule(rule.rule, rule.value, rule.message));
+        }
+    }
+    return normalized;
+}
+export function validateValue(value, values, validators, _field) {
+    for (const validator of validators) {
+        const result = validator(value, values);
+        if (result === true || result === undefined || result === null) {
+            continue;
+        }
+        if (result === false) {
+            return 'Invalid value.';
+        }
+        if (typeof result === 'string') {
+            const message = result.trim();
+            if (message)
+                return message;
+        }
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dalila",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "DOM-first reactive framework based on signals",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -30,10 +30,6 @@
       "types": "./dist/runtime/index.d.ts",
       "default": "./dist/runtime/index.js"
     },
-    "./form": {
-      "types": "./dist/form/index.d.ts",
-      "default": "./dist/form/index.js"
-    },
     "./router": {
       "types": "./dist/router/index.d.ts",
       "default": "./dist/router/index.js"

package/scripts/dev-server.cjs

@@ -287,7 +287,6 @@ function injectBindings(html, requestPath) {
         "dalila/core": "${dalilaPath}/core/index.js",
         "dalila/context": "${dalilaPath}/context/index.js",
         "dalila/context/raw": "${dalilaPath}/context/raw.js",
-        "dalila/form": "${dalilaPath}/form/index.js",
         "dalila/runtime": "${dalilaPath}/runtime/index.js",
         "dalila/router": "${dalilaPath}/router/index.js",
         "@/": "/src/"