@svadmin/lite 0.3.26 → 0.5.0

package/README.md

@@ -218,7 +218,7 @@ export const handle = createLegacyRedirectHook('/lite');
 | `createAuthGuard(authProvider)` | Server hook for authentication |
 | `createAuthActions(authProvider)` | Login/logout actions plus optional provider-delegating account actions |
 | `createLegacyRedirectHook()` | Auto-redirect IE11 to `/lite/` |
-| `fieldsToZodSchema(fields)` | Generate the Zod schema used by Lite actions or other Zod consumers |
+| `fieldsToTypeBoxSchema(fields)` | Generate the TypeBox schema used by Lite actions or other consumers (with `fieldsToZodSchema` alias) |
 
 ## CSS
 

package/dist/components/LiteForm.svelte

@@ -2,7 +2,7 @@
   /**
    * LiteForm — Server-rendered form driven by FieldDefinitions.
    * Uses a native <form> with method="POST" for no-JavaScript submission.
-   * Uses the generated Zod schema for server-side validation.
+   * Uses the generated TypeBox schema for server-side validation.
    */
   import type { FieldDefinition, ResourceDefinition } from '@svadmin/core';
   import { t } from '@svadmin/core/i18n';

package/dist/components/LiteForm.svelte.d.ts

@@ -1,7 +1,7 @@
 /**
    * LiteForm — Server-rendered form driven by FieldDefinitions.
    * Uses a native <form> with method="POST" for no-JavaScript submission.
-   * Uses the generated Zod schema for server-side validation.
+   * Uses the generated TypeBox schema for server-side validation.
    */
 import type { FieldDefinition, ResourceDefinition } from '@svadmin/core';
 interface Props {

package/dist/components/LiteShowField.svelte

@@ -5,7 +5,7 @@
   */
   import type { FieldDefinition } from '@svadmin/core';
   import { toSafeHref, toSafeText } from '../security';
-  import { isExplicitBooleanTrue } from '../value-normalization';
+  import { isExplicitBooleanTrue, getStatusBadgeClass } from '../value-normalization';
   import LiteMediaThumbnail from './LiteMediaThumbnail.svelte';
 
   interface Props {
@@ -60,6 +60,8 @@
   {/each}
 {:else if field.type === 'json' && value}
   <pre style="margin:0;font-size:12px;background:#f8fafc;padding:12px;border-radius:6px;border:1px solid #e2e8f0;overflow-x:auto;">{typeof value === 'string' ? value : JSON.stringify(value, null, 2)}</pre>
+{:else if field.type === "select" && field.options}
+  <span class={getStatusBadgeClass(value)}>{formatValue(value, field)}</span>
 {:else}
   {formatValue(value, field)}
 {/if}

package/dist/components/LiteTable.svelte

@@ -5,7 +5,7 @@
    */
   import type { ResourceDefinition, FieldDefinition } from '@svadmin/core';
   import { t } from '@svadmin/core/i18n';
-  import { isExplicitBooleanTrue } from '../value-normalization';
+  import { isExplicitBooleanTrue, getStatusBadgeClass } from '../value-normalization';
   import { liteFragmentId } from '../fragment-id';
 
   interface Props {
@@ -104,7 +104,7 @@
                 <span class="lite-badge">{tag}</span>
               {/each}
             {:else if field.type === 'select' && field.options}
-              <span class="lite-badge">{formatValue(record[field.key], field)}</span>
+              <span class={getStatusBadgeClass(record[field.key])}>{formatValue(record[field.key], field)}</span>
             {:else}
               {formatValue(record[field.key], field)}
             {/if}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { createListLoader, createDetailLoader, createCrudActions, createAuthGuard, createAuthActions, createLegacyRedirectHook, isLegacyBrowser, } from './server-adapter';
 export type { ListLoaderResult } from './server-adapter';
-export { fieldsToZodSchema, resourceToZodSchema, fieldToInputType, fieldToPlaceholder, } from './schema-generator';
+export { fieldsToTypeBoxSchema, resourceToTypeBoxSchema, fieldsToZodSchema, resourceToZodSchema, fieldToInputType, fieldToPlaceholder, } from './schema-generator';
+export { getStatusBadgeClass, parseExplicitBoolean, isExplicitBooleanTrue } from './value-normalization';
 export { default as LiteLayout } from './components/LiteLayout.svelte';
 export { default as LiteTable } from './components/LiteTable.svelte';
 export { default as LitePagination } from './components/LitePagination.svelte';

package/dist/index.js

@@ -2,9 +2,10 @@
 // Server-rendered by default, with optional progressive enhancement.
 // Server utilities (use in +page.server.ts / hooks.server.ts)
 export { createListLoader, createDetailLoader, createCrudActions, createAuthGuard, createAuthActions, createLegacyRedirectHook, isLegacyBrowser, } from './server-adapter';
-// Schema generator (used by Lite actions; also reusable by other Zod consumers)
-export { fieldsToZodSchema, resourceToZodSchema, fieldToInputType, fieldToPlaceholder, } from './schema-generator';
+// Schema generator (TypeBox schemas used by Lite actions and client forms)
+export { fieldsToTypeBoxSchema, resourceToTypeBoxSchema, fieldsToZodSchema, resourceToZodSchema, fieldToInputType, fieldToPlaceholder, } from './schema-generator';
 // UI Components (use in +page.svelte with csr = false)
+export { getStatusBadgeClass, parseExplicitBoolean, isExplicitBooleanTrue } from './value-normalization';
 export { default as LiteLayout } from './components/LiteLayout.svelte';
 export { default as LiteTable } from './components/LiteTable.svelte';
 export { default as LitePagination } from './components/LitePagination.svelte';

package/dist/lite.css

@@ -791,6 +791,36 @@ textarea.lite-input {
   border-color: #fecaca;
 }
 
+.lite-badge-info {
+  background: #eff6ff;
+  color: #1d4ed8;
+  border-color: #bfdbfe;
+}
+
+.lite-badge-indigo {
+  background: #eef2ff;
+  color: #4338ca;
+  border-color: #c7d2fe;
+}
+
+.lite-filter-bar {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+}
+.lite-filter-bar > * + * {
+  margin-left: 8px;
+}
+
+.lite-batch-bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 16px;
+  background: #f8fafc;
+  border-top: 1px solid #e2e8f0;
+}
+
 .lite-badge-warning {
   background: #fffbeb;
   color: #92400e;

package/dist/schema-generator.d.ts

@@ -1,26 +1,62 @@
 /**
  * @svadmin/lite — Schema Generator
  *
- * Auto-generates Zod schemas from @svadmin/core FieldDefinitions.
- * Used by the Lite server actions and compatible with other Zod consumers.
+ * Auto-generates TypeBox schemas from @svadmin/core FieldDefinitions.
+ * Used by Lite server actions and high-speed JIT form validation.
  */
-import { z } from 'zod';
-import type { FieldDefinition, ResourceDefinition } from '@svadmin/core';
+import { type TObject } from "@sinclair/typebox";
+import type { FieldDefinition, ResourceDefinition } from "@svadmin/core";
+export interface SchemaValidationIssue {
+    path: (string | number)[];
+    message: string;
+}
+export type SchemaValidationResult<T = Record<string, unknown>> = {
+    success: true;
+    data: T;
+    error?: never;
+} | {
+    success: false;
+    error: {
+        issues: SchemaValidationIssue[];
+    };
+    data?: never;
+};
+export type TypeBoxEnhancedSchema<T = Record<string, unknown>> = TObject & {
+    parse: (values: unknown) => T;
+    safeParse: (values: unknown) => SchemaValidationResult<T>;
+    Check: (values: unknown) => boolean;
+    "~standard": {
+        version: 1;
+        vendor: "svadmin";
+        validate: (values: unknown) => {
+            value: T;
+        } | {
+            issues: Array<{
+                message: string;
+                path?: (string | number)[];
+            }>;
+        };
+    };
+};
 /**
- * Generate a Zod object schema from a ResourceDefinition's fields.
- * Only includes fields that are relevant for form rendering.
- *
- * @param mode - 'create' | 'edit' to filter fields by showInCreate / showInEdit
+ * Generate a TypeBox object schema from a list of FieldDefinitions.
+ */
+export declare function fieldsToTypeBoxSchema(fields: FieldDefinition[], mode?: "create" | "edit"): TypeBoxEnhancedSchema;
+/**
+ * Generate a TypeBox schema from a ResourceDefinition.
+ * Convenience wrapper around fieldsToTypeBoxSchema.
+ */
+export declare function resourceToTypeBoxSchema(resource: ResourceDefinition, mode?: "create" | "edit"): TypeBoxEnhancedSchema;
+/**
+ * Backward compatibility alias for fieldsToTypeBoxSchema
  */
-export declare function fieldsToZodSchema(fields: FieldDefinition[], mode?: 'create' | 'edit'): z.ZodObject<Record<string, z.ZodTypeAny>>;
+export declare const fieldsToZodSchema: typeof fieldsToTypeBoxSchema;
 /**
- * Generate a Zod schema from a ResourceDefinition.
- * Convenience wrapper around fieldsToZodSchema.
+ * Backward compatibility alias for resourceToTypeBoxSchema
  */
-export declare function resourceToZodSchema(resource: ResourceDefinition, mode?: 'create' | 'edit'): z.ZodObject<Record<string, z.ZodTypeAny>>;
+export declare const resourceToZodSchema: typeof resourceToTypeBoxSchema;
 /**
  * Determine a conservative HTML input type for server-rendered forms.
- * Text fallbacks avoid inconsistent native validation and date widgets.
  */
 export declare function fieldToInputType(field: FieldDefinition): string;
 /**

package/dist/schema-generator.js

@@ -1,19 +1,19 @@
 /**
  * @svadmin/lite — Schema Generator
  *
- * Auto-generates Zod schemas from @svadmin/core FieldDefinitions.
- * Used by the Lite server actions and compatible with other Zod consumers.
+ * Auto-generates TypeBox schemas from @svadmin/core FieldDefinitions.
+ * Used by Lite server actions and high-speed JIT form validation.
  */
-import { z } from 'zod';
-import { parseExplicitBoolean } from './value-normalization';
+import { Type } from "@sinclair/typebox";
+import { parseExplicitBoolean } from "./value-normalization";
 function isNativeFile(value) {
-    return typeof File !== 'undefined' && value instanceof File;
+    return typeof File !== "undefined" && value instanceof File;
 }
 function isNonEmptyNativeFile(value) {
-    return isNativeFile(value) && value.size > 0 && value.name !== '';
+    return isNativeFile(value) && value.size > 0 && value.name !== "";
 }
 function normalizeSingleUpload(submittedUpload) {
-    if (submittedUpload === undefined || submittedUpload === null || submittedUpload === '')
+    if (submittedUpload === undefined || submittedUpload === null || submittedUpload === "")
         return undefined;
     if (isNativeFile(submittedUpload) && !isNonEmptyNativeFile(submittedUpload))
         return undefined;
@@ -22,7 +22,7 @@ function normalizeSingleUpload(submittedUpload) {
 function hasRequiredValue(value) {
     if (value === undefined || value === null)
         return false;
-    if (typeof value === 'string')
+    if (typeof value === "string")
         return value.trim().length > 0;
     if (Array.isArray(value))
         return value.length > 0;
@@ -30,246 +30,428 @@ function hasRequiredValue(value) {
         return isNonEmptyNativeFile(value);
     return true;
 }
-function applyCustomValidation(schema, field) {
-    if (!field.validate)
-        return schema;
-    return schema.superRefine((parsedFieldValue, context) => {
-        if (parsedFieldValue === undefined || parsedFieldValue === null || parsedFieldValue === '')
-            return;
-        const message = field.validate?.(parsedFieldValue);
-        if (message)
-            context.addIssue({ code: 'custom', message });
-    });
-}
-function numberFieldToZod(field) {
-    const numberSchema = z.coerce.number({ message: `${field.label} must be a number` });
-    const targetSchema = field.required ? numberSchema : numberSchema.optional();
-    return z.preprocess((value) => {
-        if (value === undefined || value === null)
-            return undefined;
-        if (typeof value === 'string' && value.trim() === '')
-            return undefined;
-        return value;
-    }, targetSchema);
-}
-function booleanFieldToZod(field) {
-    const booleanSchema = z.boolean();
-    const targetSchema = field.required ? booleanSchema : booleanSchema.optional();
-    return z.preprocess((rawBoolean) => {
-        if (rawBoolean === undefined || rawBoolean === null || rawBoolean === '')
-            return undefined;
-        return parseExplicitBoolean(rawBoolean) ?? rawBoolean;
-    }, targetSchema);
-}
 function restoreOptionValue(field, submittedOption) {
     const option = field.options?.find((candidate) => String(candidate.value) === String(submittedOption));
     return option?.value ?? submittedOption;
 }
-function optionValueSchema(field) {
-    const options = field.options ?? [];
-    return z.union([z.string(), z.number()]).refine((parsedOption) => options.length === 0
-        || options.some((option) => Object.is(option.value, parsedOption)), { message: `${field.label} must be one of the options` });
-}
-function singleOptionFieldToZod(field) {
-    return z.preprocess((submittedOption) => restoreOptionValue(field, submittedOption), optionValueSchema(field));
-}
-function multipleOptionFieldToZod(field) {
-    return z.preprocess((submittedOptions) => Array.isArray(submittedOptions)
-        ? submittedOptions.map((submittedOption) => restoreOptionValue(field, submittedOption))
-        : submittedOptions, z.array(optionValueSchema(field)).default([]));
-}
-function singleFileFieldToZod(field, options) {
-    const fileSchema = z.custom(isNonEmptyNativeFile, {
-        message: `${field.label} must be a non-empty file`,
-    });
-    const referenceSchema = z.string().trim().min(1, `${field.label} must reference an existing file`);
-    const uploadSchema = options.allowReference ? z.union([fileSchema, referenceSchema]) : fileSchema;
-    const targetSchema = options.required ? uploadSchema : uploadSchema.optional();
-    return z.preprocess(normalizeSingleUpload, targetSchema);
-}
-function imageFieldSchemas(field) {
-    const imageSchema = z.union([
-        z.string().trim().min(1, `${field.label} must reference an image`),
-        z.custom(isNonEmptyNativeFile, {
-            message: `${field.label} must reference an image or contain a non-empty file`,
-        }),
-    ]);
-    return {
-        required: z.preprocess(normalizeSingleUpload, imageSchema),
-        optional: z.preprocess(normalizeSingleUpload, imageSchema.optional()),
-    };
-}
 function normalizeImageEntries(submittedImages) {
-    if (submittedImages === undefined || submittedImages === null || submittedImages === '')
+    if (submittedImages === undefined || submittedImages === null || submittedImages === "")
         return undefined;
     const entries = Array.isArray(submittedImages) ? submittedImages : [submittedImages];
     const normalized = entries.flatMap((entry) => {
-        if (typeof entry !== 'string')
+        if (typeof entry !== "string")
             return [entry];
         return entry.split(/[\r\n]+/u).map((reference) => reference.trim()).filter(Boolean);
     }).filter((entry) => !isNativeFile(entry) || isNonEmptyNativeFile(entry));
     return normalized.length > 0 ? normalized : undefined;
 }
-function imagesFieldSchemas(field) {
-    const imageEntrySchema = z.union([
-        z.string().trim().min(1, `${field.label} contains an empty image reference`),
-        z.custom(isNonEmptyNativeFile, {
-            message: `${field.label} contains an empty or invalid file`,
-        }),
-    ]);
-    const requiredImages = z.array(imageEntrySchema)
-        .min(1, `${field.label} must contain at least one image`);
-    return {
-        required: z.preprocess(normalizeImageEntries, requiredImages),
-        optional: z.preprocess(normalizeImageEntries, z.array(imageEntrySchema).optional()),
-    };
-}
-/**
- * Convert a single FieldDefinition to its corresponding Zod type.
- */
-function fieldToZod(field, mode, withinArray = false) {
-    let schema;
+function coerceAndValidateField(field, value, mode, withinArray = false, path = [field.key]) {
+    const issues = [];
+    let coerced = value;
     switch (field.type) {
-        case 'number':
-            return numberFieldToZod(field);
-        case 'boolean':
-            return booleanFieldToZod(field);
-        case 'email':
-            schema = z.string().email(`${field.label} must be a valid email`);
+        case "number": {
+            if (coerced === undefined || coerced === null || coerced === "") {
+                coerced = undefined;
+                if (field.required) {
+                    issues.push({ path, message: `${field.label} is required` });
+                }
+            }
+            else if (typeof coerced === "string") {
+                const trimmed = coerced.trim();
+                if (trimmed === "") {
+                    coerced = undefined;
+                    if (field.required) {
+                        issues.push({ path, message: `${field.label} is required` });
+                    }
+                }
+                else {
+                    const num = Number(trimmed);
+                    if (Number.isNaN(num)) {
+                        issues.push({ path, message: `${field.label} must be a number` });
+                    }
+                    else {
+                        coerced = num;
+                    }
+                }
+            }
+            else if (typeof coerced === "number") {
+                if (Number.isNaN(coerced)) {
+                    issues.push({ path, message: `${field.label} must be a number` });
+                }
+            }
+            else {
+                issues.push({ path, message: `${field.label} must be a number` });
+            }
             break;
-        case 'url':
-            schema = z.string().url(`${field.label} must be a valid URL`);
+        }
+        case "boolean": {
+            if (coerced === undefined || coerced === null || coerced === "") {
+                coerced = field.required ? false : undefined;
+                if (field.required && coerced === undefined) {
+                    issues.push({ path, message: `${field.label} is required` });
+                }
+            }
+            else if (typeof coerced === "boolean") {
+                // ok
+            }
+            else if (typeof coerced === "string") {
+                const parsed = parseExplicitBoolean(coerced);
+                if (parsed === undefined) {
+                    issues.push({ path, message: `${field.label} must be a boolean` });
+                }
+                else {
+                    coerced = parsed;
+                }
+            }
+            else if (typeof coerced === "number") {
+                if (coerced === 1)
+                    coerced = true;
+                else if (coerced === 0)
+                    coerced = false;
+                else
+                    issues.push({ path, message: `${field.label} must be a boolean` });
+            }
+            else {
+                issues.push({ path, message: `${field.label} must be a boolean` });
+            }
             break;
-        case 'date':
-            schema = z.string().refine((v) => !v || !isNaN(Date.parse(v)), { message: `${field.label} must be a valid date` });
+        }
+        case "email": {
+            if (typeof coerced === "string" && coerced.length > 0) {
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                if (!emailRegex.test(coerced)) {
+                    issues.push({ path, message: `${field.label} must be a valid email` });
+                }
+            }
             break;
-        case 'select':
-            schema = singleOptionFieldToZod(field);
+        }
+        case "url": {
+            if (typeof coerced === "string" && coerced.length > 0) {
+                try {
+                    new URL(coerced);
+                }
+                catch {
+                    issues.push({ path, message: `${field.label} must be a valid URL` });
+                }
+            }
             break;
-        case 'multiselect':
-            schema = multipleOptionFieldToZod(field);
+        }
+        case "date": {
+            if (typeof coerced === "string" && coerced.length > 0) {
+                if (Number.isNaN(Date.parse(coerced))) {
+                    issues.push({ path, message: `${field.label} must be a valid date` });
+                }
+            }
             break;
-        case 'relation':
-            schema = field.options?.length ? singleOptionFieldToZod(field) : z.string();
+        }
+        case "select": {
+            if (coerced !== undefined && coerced !== null && coerced !== "") {
+                coerced = restoreOptionValue(field, coerced);
+                const options = field.options ?? [];
+                if (options.length > 0 && !options.some((opt) => Object.is(opt.value, coerced))) {
+                    issues.push({ path, message: `${field.label} must be one of the options` });
+                }
+            }
             break;
-        case 'array': {
-            const shape = {};
-            for (const subField of field.subFields ?? []) {
-                shape[subField.key] = applyCustomValidation(fieldToZod(subField, mode, true), subField);
+        }
+        case "multiselect": {
+            if (Array.isArray(coerced)) {
+                coerced = coerced.map((item) => restoreOptionValue(field, item));
+                const options = field.options ?? [];
+                if (options.length > 0) {
+                    for (const item of coerced) {
+                        if (!options.some((opt) => Object.is(opt.value, item))) {
+                            issues.push({ path, message: `${field.label} must be one of the options` });
+                            break;
+                        }
+                    }
+                }
+            }
+            else if (coerced === undefined || coerced === null || coerced === "") {
+                coerced = [];
             }
-            const arraySchema = z.array(z.object(shape));
-            return field.required
-                ? arraySchema.min(1, `${field.label} must contain at least one item`)
-                : arraySchema.optional().or(z.literal(''));
+            break;
         }
-        case 'tags':
-            schema = z.union([
-                z.array(z.string()),
-                z.string().transform((value) => value ? value.split(',').map((tag) => tag.trim()).filter(Boolean) : []),
-            ]);
+        case "relation": {
+            if (field.options?.length && coerced !== undefined && coerced !== null && coerced !== "") {
+                coerced = restoreOptionValue(field, coerced);
+                if (!field.options.some((opt) => Object.is(opt.value, coerced))) {
+                    issues.push({ path, message: `${field.label} must be one of the options` });
+                }
+            }
             break;
-        case 'textarea':
-        case 'richtext':
-        case 'markdown':
-            schema = z.string().max(50000, `${field.label} is too long`);
+        }
+        case "array": {
+            if (Array.isArray(coerced)) {
+                if (field.required && coerced.length === 0) {
+                    issues.push({ path, message: `${field.label} must contain at least one item` });
+                }
+                else {
+                    const processedRows = [];
+                    for (let r = 0; r < coerced.length; r++) {
+                        const row = coerced[r];
+                        if (typeof row !== "object" || row === null) {
+                            issues.push({ path: [...path, r], message: "Row must be an object" });
+                            continue;
+                        }
+                        const rowObj = row;
+                        const processedRow = {};
+                        for (const subField of field.subFields ?? []) {
+                            const subRes = coerceAndValidateField(subField, rowObj[subField.key], mode, true, [...path, r, subField.key]);
+                            issues.push(...subRes.issues);
+                            if (subRes.value !== undefined) {
+                                processedRow[subField.key] = subRes.value;
+                            }
+                        }
+                        processedRows.push(processedRow);
+                    }
+                    coerced = processedRows;
+                }
+            }
+            else if (coerced === undefined || coerced === null || coerced === "") {
+                if (field.required) {
+                    issues.push({ path, message: `${field.label} must contain at least one item` });
+                }
+                else {
+                    coerced = [];
+                }
+            }
+            else {
+                issues.push({ path, message: `${field.label} must be an array` });
+            }
+            break;
+        }
+        case "tags": {
+            if (typeof coerced === "string") {
+                coerced = coerced ? coerced.split(",").map((tag) => tag.trim()).filter(Boolean) : [];
+            }
+            else if (!Array.isArray(coerced)) {
+                coerced = [];
+            }
+            break;
+        }
+        case "textarea":
+        case "richtext":
+        case "markdown": {
+            if (typeof coerced === "string" && coerced.length > 50000) {
+                issues.push({ path, message: `${field.label} is too long` });
+            }
             break;
-        case 'json':
-            schema = z.unknown().transform((value, context) => {
-                if (typeof value !== 'string')
-                    return value;
+        }
+        case "json": {
+            if (typeof coerced === "string") {
                 try {
-                    return JSON.parse(value);
+                    coerced = JSON.parse(coerced);
                 }
                 catch {
-                    context.addIssue({ code: 'custom', message: `${field.label} must be valid JSON` });
-                    return z.NEVER;
+                    issues.push({ path, message: `${field.label} must be valid JSON` });
+                }
+            }
+            break;
+        }
+        case "phone": {
+            if (typeof coerced === "string" && coerced.length > 0) {
+                if (!/^[+\d\s()-]*$/.test(coerced)) {
+                    issues.push({ path, message: `${field.label} must be a valid phone number` });
+                }
+            }
+            break;
+        }
+        case "file": {
+            coerced = normalizeSingleUpload(coerced);
+            const isFile = isNonEmptyNativeFile(coerced);
+            const isStringRef = typeof coerced === "string" && coerced.trim().length > 0;
+            const isRequired = field.required === true && (mode === "create" || withinArray);
+            const allowRef = withinArray && mode === "edit";
+            if (isRequired) {
+                if (!isFile && (!allowRef || !isStringRef)) {
+                    issues.push({ path, message: `${field.label} must be a non-empty file` });
+                }
+            }
+            else if (coerced !== undefined) {
+                if (!isFile && (!allowRef || !isStringRef)) {
+                    issues.push({ path, message: `${field.label} must be a non-empty file` });
                 }
-            });
+            }
             break;
-        case 'phone':
-            schema = z.string().regex(/^[+\d\s()-]*$/, `${field.label} must be a valid phone number`);
+        }
+        case "image": {
+            coerced = normalizeSingleUpload(coerced);
+            const isFile = isNonEmptyNativeFile(coerced);
+            const isStringRef = typeof coerced === "string" && coerced.trim().length > 0;
+            const isRequired = field.required === true;
+            if (isRequired) {
+                if (mode === "create" || withinArray) {
+                    if (!isFile && !isStringRef) {
+                        issues.push({ path, message: `${field.label} must reference an image or contain a non-empty file` });
+                    }
+                }
+                else if (mode === "edit") {
+                    if (coerced !== undefined && !isFile && !isStringRef) {
+                        issues.push({ path, message: `${field.label} must reference an image or contain a non-empty file` });
+                    }
+                }
+            }
             break;
-        case 'file':
-            return singleFileFieldToZod(field, {
-                required: field.required === true && (mode === 'create' || withinArray),
-                allowReference: mode === 'edit' && withinArray,
-            });
-        case 'image': {
-            const imageSchemas = imageFieldSchemas(field);
-            return field.required === true && (mode === 'create' || withinArray)
-                ? imageSchemas.required
-                : imageSchemas.optional;
         }
-        case 'images': {
-            const imagesSchemas = imagesFieldSchemas(field);
-            return field.required === true && (mode === 'create' || withinArray)
-                ? imagesSchemas.required
-                : imagesSchemas.optional;
+        case "images": {
+            coerced = normalizeImageEntries(coerced);
+            const isRequired = field.required === true;
+            const entries = Array.isArray(coerced) ? coerced : (coerced ? [coerced] : []);
+            if (isRequired && (mode === "create" || withinArray)) {
+                if (entries.length === 0) {
+                    issues.push({ path, message: `${field.label} must contain at least one image` });
+                }
+            }
+            break;
         }
         default:
-            schema = z.string();
+            break;
     }
-    // Enforce meaningful values for required fields, including nested array rows.
-    if (field.required) {
-        schema = schema.refine(hasRequiredValue, { message: `${field.label} is required` });
+    // Check required
+    if (field.type !== "number" && field.type !== "boolean" && field.type !== "array" && field.type !== "file" && field.type !== "image" && field.type !== "images") {
+        if (field.required && !hasRequiredValue(coerced)) {
+            issues.push({ path, message: `${field.label} is required` });
+        }
     }
-    else {
-        schema = schema.optional().or(z.literal(''));
+    // Custom validate
+    if (field.validate && issues.length === 0 && coerced !== undefined && coerced !== null && coerced !== "") {
+        const customMessage = field.validate(coerced);
+        if (customMessage) {
+            issues.push({ path, message: customMessage });
+        }
     }
-    return schema;
+    return { value: coerced, issues };
 }
 /**
- * Generate a Zod object schema from a ResourceDefinition's fields.
- * Only includes fields that are relevant for form rendering.
- *
- * @param mode - 'create' | 'edit' to filter fields by showInCreate / showInEdit
+ * Generate a TypeBox object schema from a list of FieldDefinitions.
  */
-export function fieldsToZodSchema(fields, mode = 'create') {
+export function fieldsToTypeBoxSchema(fields, mode = "create") {
     const shape = {};
+    const activeFields = [];
     for (const field of fields) {
-        // Skip fields not shown in forms
         if (field.showInForm === false)
             continue;
-        if (mode === 'create' && field.showInCreate === false)
+        if (mode === "create" && field.showInCreate === false)
             continue;
-        if (mode === 'edit' && field.showInEdit === false)
+        if (mode === "edit" && field.showInEdit === false)
             continue;
-        shape[field.key] = applyCustomValidation(fieldToZod(field, mode), field);
+        activeFields.push(field);
+        switch (field.type) {
+            case "number":
+                shape[field.key] = field.required ? Type.Number() : Type.Optional(Type.Number());
+                break;
+            case "boolean":
+                shape[field.key] = field.required ? Type.Boolean() : Type.Optional(Type.Boolean());
+                break;
+            case "array":
+                shape[field.key] = field.required ? Type.Array(Type.Any(), { minItems: 1 }) : Type.Optional(Type.Array(Type.Any()));
+                break;
+            default:
+                shape[field.key] = field.required ? Type.Any() : Type.Optional(Type.Any());
+                break;
+        }
     }
-    return z.object(shape);
+    const baseSchema = Type.Object(shape, { additionalProperties: true });
+    const safeParse = (values) => {
+        if (typeof values !== "object" || values === null) {
+            return {
+                success: false,
+                error: { issues: [{ path: ["_root"], message: "Values must be an object" }] },
+            };
+        }
+        const input = values;
+        const resultData = {};
+        const allIssues = [];
+        for (const field of activeFields) {
+            const val = input[field.key];
+            const fieldRes = coerceAndValidateField(field, val, mode, false, [field.key]);
+            allIssues.push(...fieldRes.issues);
+            if (fieldRes.value !== undefined) {
+                resultData[field.key] = fieldRes.value;
+            }
+        }
+        if (allIssues.length > 0) {
+            return {
+                success: false,
+                error: { issues: allIssues },
+            };
+        }
+        return {
+            success: true,
+            data: resultData,
+        };
+    };
+    const parse = (values) => {
+        const res = safeParse(values);
+        if (!res.success) {
+            const err = new Error(res.error?.issues[0]?.message || "Validation failed");
+            err.issues = res.error?.issues ?? [];
+            throw err;
+        }
+        return res.data ?? {};
+    };
+    return Object.assign(baseSchema, {
+        parse,
+        safeParse,
+        Check: (val) => safeParse(val).success,
+        "~standard": {
+            version: 1,
+            vendor: "svadmin",
+            validate: (val) => {
+                const res = safeParse(val);
+                if (res.success) {
+                    return { value: res.data ?? {} };
+                }
+                return {
+                    issues: (res.error?.issues ?? []).map((iss) => ({
+                        message: iss.message,
+                        path: iss.path,
+                    })),
+                };
+            },
+        },
+    });
 }
 /**
- * Generate a Zod schema from a ResourceDefinition.
- * Convenience wrapper around fieldsToZodSchema.
+ * Generate a TypeBox schema from a ResourceDefinition.
+ * Convenience wrapper around fieldsToTypeBoxSchema.
  */
-export function resourceToZodSchema(resource, mode = 'create') {
-    const primaryKey = resource.primaryKey ?? 'id';
-    return fieldsToZodSchema(resource.fields.filter((field) => field.key !== primaryKey), mode);
+export function resourceToTypeBoxSchema(resource, mode = "create") {
+    const primaryKey = resource.primaryKey ?? "id";
+    return fieldsToTypeBoxSchema(resource.fields.filter((field) => field.key !== primaryKey), mode);
 }
+/**
+ * Backward compatibility alias for fieldsToTypeBoxSchema
+ */
+export const fieldsToZodSchema = fieldsToTypeBoxSchema;
+/**
+ * Backward compatibility alias for resourceToTypeBoxSchema
+ */
+export const resourceToZodSchema = resourceToTypeBoxSchema;
 /**
  * Determine a conservative HTML input type for server-rendered forms.
- * Text fallbacks avoid inconsistent native validation and date widgets.
  */
 export function fieldToInputType(field) {
     switch (field.type) {
-        case 'number': return 'text';
-        case 'email': return 'text';
-        case 'url': return 'text';
-        case 'phone': return 'tel';
-        case 'boolean': return 'checkbox';
-        case 'date': return 'text';
-        case 'textarea':
-        case 'richtext':
-        case 'markdown':
-        case 'images': return 'textarea';
-        case 'json': return 'textarea';
-        case 'select':
-        case 'multiselect': return 'select';
-        case 'relation': return field.options?.length ? 'select' : 'text';
-        case 'array': return 'text';
-        case 'file': return 'file';
-        case 'password': return 'password';
-        default: return 'text';
+        case "number": return "text";
+        case "email": return "text";
+        case "url": return "text";
+        case "phone": return "tel";
+        case "boolean": return "checkbox";
+        case "date": return "text";
+        case "textarea":
+        case "richtext":
+        case "markdown":
+        case "images": return "textarea";
+        case "json": return "textarea";
+        case "select":
+        case "multiselect": return "select";
+        case "relation": return field.options?.length ? "select" : "text";
+        case "array": return "text";
+        case "file": return "file";
+        case "password": return "password";
+        default: return "text";
     }
 }
 /**
@@ -277,11 +459,11 @@ export function fieldToInputType(field) {
  */
 export function fieldToPlaceholder(field) {
     switch (field.type) {
-        case 'date': return 'YYYY-MM-DD';
-        case 'email': return 'user@example.com';
-        case 'url': return 'https://example.com';
-        case 'phone': return '+1 (555) 000-0000';
-        case 'number': return '0';
-        default: return '';
+        case "date": return "YYYY-MM-DD";
+        case "email": return "user@example.com";
+        case "url": return "https://example.com";
+        case "phone": return "+1 (555) 000-0000";
+        case "number": return "0";
+        default: return "";
     }
 }

package/dist/server-adapter.d.ts

@@ -92,6 +92,13 @@ export declare function createCrudActions(dp: DataProvider, resource: ResourceDe
         success: boolean;
         error?: undefined;
     }>;
+    batchDelete: ({ request }: RequestEvent) => Promise<{
+        success: boolean;
+        error: string;
+    } | {
+        success: boolean;
+        error?: undefined;
+    }>;
 };
 /**
  * Creates a SvelteKit server hook that checks auth via AuthProvider

package/dist/server-adapter.js

@@ -1,5 +1,5 @@
 import { redirect, isRedirect } from '@sveltejs/kit';
-import { resourceToZodSchema } from './schema-generator';
+import { resourceToTypeBoxSchema } from './schema-generator';
 import { parseExplicitBoolean } from './value-normalization';
 function listRequestState(url, resource) {
     const requestedPage = Number(url.searchParams.get('page'));
@@ -19,19 +19,35 @@ function listRequestState(url, resource) {
         : resource.defaultSort?.order ?? 'asc';
     return { page, pageSize, sort, order, search: url.searchParams.get('q') ?? undefined };
 }
-function listSearchFilters(resource, search) {
-    if (!search)
-        return [];
-    const fieldFilters = resource.fields
-        .filter((field) => field.searchable)
-        .map((field) => ({
-        field: field.key,
-        operator: 'contains',
-        value: search,
-    }));
-    if (fieldFilters.length === 1)
-        return fieldFilters;
-    return fieldFilters.length > 1 ? [{ operator: 'or', value: fieldFilters }] : [];
+function listRequestFilters(resource, url) {
+    const filters = [];
+    const search = url.searchParams.get('q') ?? undefined;
+    if (search) {
+        const searchFilters = resource.fields
+            .filter((field) => field.searchable)
+            .map((field) => ({
+            field: field.key,
+            operator: 'contains',
+            value: search,
+        }));
+        if (searchFilters.length === 1) {
+            filters.push(searchFilters[0]);
+        }
+        else if (searchFilters.length > 1) {
+            filters.push({ operator: 'or', value: searchFilters });
+        }
+    }
+    for (const field of resource.fields) {
+        const rawVal = url.searchParams.get(`filter_${field.key}`) ?? (field.key !== 'q' && field.key !== 'sort' && field.key !== 'order' && field.key !== 'page' ? url.searchParams.get(field.key) : null);
+        if (rawVal != null && rawVal.trim() !== '') {
+            filters.push({
+                field: field.key,
+                operator: 'eq',
+                value: field.type === 'number' && !Number.isNaN(Number(rawVal)) ? Number(rawVal) : rawVal,
+            });
+        }
+    }
+    return filters;
 }
 /**
  * Creates a SvelteKit `load` function that fetches a resource list
@@ -45,7 +61,7 @@ export function createListLoader(dp, resource) {
             resource: resource.name,
             pagination: { current: page, pageSize },
             sorters,
-            filters: listSearchFilters(resource, search),
+            filters: listRequestFilters(resource, url),
         });
         return {
             records: listResponse.data,
@@ -155,6 +171,32 @@ export function createCrudActions(dp, resource) {
                 return { success: false, error: 'Delete failed' };
             }
         },
+        batchDelete: async ({ request }) => {
+            if (resource.canDelete === false) {
+                return { success: false, error: 'Delete is disabled for this resource' };
+            }
+            const formData = await request.formData();
+            const ids = formData.getAll('ids').map(v => String(v).trim()).filter(Boolean);
+            if (ids.length === 0)
+                return { success: false, error: 'No records selected' };
+            const redirectTo = toSafeLocalRedirect(formData.get('redirect'));
+            try {
+                if (dp.deleteMany) {
+                    await dp.deleteMany({ resource: resource.name, ids });
+                }
+                else {
+                    await Promise.all(ids.map(id => dp.deleteOne({ resource: resource.name, id })));
+                }
+                if (redirectTo)
+                    throw redirect(303, redirectTo);
+                return { success: true };
+            }
+            catch (caughtError) {
+                if (isRedirect(caughtError))
+                    throw caughtError;
+                return { success: false, error: 'Batch delete failed' };
+            }
+        },
     };
 }
 // ─── Auth Helpers ─────────────────────────────────────────────
@@ -374,7 +416,7 @@ function formatValidationErrors(issues) {
     return errors;
 }
 function validateFormVariables(resource, mode, values) {
-    const result = resourceToZodSchema(resource, mode).safeParse(values);
+    const result = resourceToTypeBoxSchema(resource, mode).safeParse(values);
     if (result.success)
         return { success: true, data: result.data };
     return {
@@ -471,7 +513,7 @@ function formDataToObject(formData, fields) {
                     obj[field.key] = strRaw ? JSON.parse(strRaw) : null;
                 }
                 catch {
-                    obj[field.key] = strRaw; // Let Zod handle validation errors
+                    obj[field.key] = strRaw; // Let TypeBox handle validation errors
                 }
                 break;
             default:

package/dist/value-normalization.d.ts

@@ -1,2 +1,3 @@
 export declare function parseExplicitBoolean(rawBoolean: unknown): boolean | undefined;
 export declare function isExplicitBooleanTrue(rawBoolean: unknown): boolean;
+export declare function getStatusBadgeClass(value: unknown): string;

package/dist/value-normalization.js

@@ -19,3 +19,21 @@ export function parseExplicitBoolean(rawBoolean) {
 export function isExplicitBooleanTrue(rawBoolean) {
     return parseExplicitBoolean(rawBoolean) === true;
 }
+export function getStatusBadgeClass(value) {
+    if (typeof value !== "string")
+        return "lite-badge";
+    const v = value.toLowerCase().trim();
+    if (["active", "completed", "published", "delivered", "paid", "approved", "success", "in_stock", "healthy"].includes(v)) {
+        return "lite-badge lite-badge-success";
+    }
+    if (["draft", "pending", "processing", "in_transit", "review", "waiting", "warning", "low_stock"].includes(v)) {
+        return "lite-badge lite-badge-warning";
+    }
+    if (["cancelled", "rejected", "failed", "suspended", "inactive", "banned", "error", "out_of_stock", "closed"].includes(v)) {
+        return "lite-badge lite-badge-danger";
+    }
+    if (["shipped", "submitted", "open", "new", "admin", "verified"].includes(v)) {
+        return "lite-badge lite-badge-info";
+    }
+    return "lite-badge";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/lite",
-  "version": "0.3.26",
+  "version": "0.5.0",
   "description": "SSR-first lightweight admin UI for @svadmin with optional progressive enhancement",
   "type": "module",
   "sideEffects": [
@@ -48,22 +48,22 @@
     }
   },
   "peerDependencies": {
-    "svelte": "^5.56.8",
-    "@svadmin/core": ">=0.34.2 <0.43.0",
-    "@sveltejs/kit": "^2.70.2"
+    "svelte": "^5.56.10",
+    "@svadmin/core": ">=0.34.2 <0.46.0",
+    "@sveltejs/kit": "^2.70.3"
   },
   "dependencies": {
-    "@lucide/svelte": "^1.31.0",
-    "zod": "^4.4.3"
+    "@lucide/svelte": "^1.35.0",
+    "@sinclair/typebox": "^0.34.52"
   },
   "devDependencies": {
     "@types/bun": "^1.4.0",
-    "@happy-dom/global-registrator": "^20.11.2",
+    "@happy-dom/global-registrator": "^20.11.12",
     "@sveltejs/vite-plugin-svelte": "^7.3.0",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/svelte": "^5.4.2",
-    "happy-dom": "^20.11.2",
-    "vitest": "^4.1.10"
+    "happy-dom": "^20.11.12",
+    "vitest": "^4.1.11"
   },
   "scripts": {
     "build": "node ../../node_modules/@sveltejs/package/svelte-package.js -i src -o dist && bun ../../scripts/copy-package-assets.ts static/enhance.js dist/enhance.js",