@svadmin/lite 0.3.12 → 0.3.14

package/dist/components/pages/LiteEditPage.svelte

@@ -20,23 +20,25 @@
     record,
     errors = {},
     basePath = '/lite',
-    canDelete = true,
-    canShow = true,
+    canDelete,
+    canShow,
   }: Props = $props();
 
   let pk = $derived(resource.primaryKey ?? 'id');
   let idStr = $derived(String(record[pk]));
+  const showDelete = $derived(canDelete ?? resource.canDelete !== false);
+  const showView = $derived(canShow ?? resource.canShow !== false);
 </script>
 
 <div class="lite-page">
   <div class="lite-page-header">
     <h1 class="lite-page-title">{t('common.edit') || 'Edit'} {resource.label || resource.name} #{idStr}</h1>
     <div class="lite-page-actions">
-      {#if canShow}
+      {#if showView}
         <LiteShowButton resource={resource.name} recordItemId={idStr} {basePath} />
       {/if}
       <LiteListButton resource={resource.name} {basePath} />
-      {#if canDelete}
+      {#if showDelete}
         <LiteDeleteButton resource={resource.name} recordItemId={idStr} redirectUrl={`${basePath}/${resource.name}`} {basePath} />
       {/if}
     </div>

package/dist/components/pages/LiteListPage.svelte

@@ -17,6 +17,7 @@
     currentSearch?: string;
     basePath?: string;
     canCreate?: boolean;
+    canShow?: boolean;
     canEdit?: boolean;
     canDelete?: boolean;
   }
@@ -30,17 +31,23 @@
     currentOrder = 'asc',
     currentSearch,
     basePath = '/lite',
-    canCreate = true,
-    canEdit = true,
-    canDelete = true,
+    canCreate,
+    canShow,
+    canEdit,
+    canDelete,
   }: Props = $props();
+
+  const showCreate = $derived(canCreate ?? resource.canCreate !== false);
+  const showView = $derived(canShow ?? resource.canShow !== false);
+  const showEdit = $derived(canEdit ?? resource.canEdit !== false);
+  const showDelete = $derived(canDelete ?? resource.canDelete !== false);
 </script>
 
 <div class="lite-page">
   <div class="lite-page-header">
     <h1 class="lite-page-title">{resource.label || resource.name} {t('common.list') || 'List'}</h1>
     <div class="lite-page-actions">
-      {#if canCreate}
+      {#if showCreate}
         <LiteCreateButton resource={resource.name} {basePath} />
       {/if}
       <LiteRefreshButton hideText />
@@ -62,8 +69,9 @@
       {currentOrder}
       {currentSearch}
       {basePath}
-      {canEdit}
-      {canDelete}
+      canShow={showView}
+      canEdit={showEdit}
+      canDelete={showDelete}
     />
     
     {#if total > pagination.perPage}

package/dist/components/pages/LiteListPage.svelte.d.ts

@@ -12,6 +12,7 @@ interface Props {
     currentSearch?: string;
     basePath?: string;
     canCreate?: boolean;
+    canShow?: boolean;
     canEdit?: boolean;
     canDelete?: boolean;
 }

package/dist/components/pages/LiteShowPage.svelte

@@ -18,12 +18,14 @@
     resource,
     record,
     basePath = '/lite',
-    canEdit = true,
-    canDelete = true,
+    canEdit,
+    canDelete,
   }: Props = $props();
 
   let pk = $derived(resource.primaryKey ?? 'id');
   let idStr = $derived(String(record[pk]));
+  const showEdit = $derived(canEdit ?? resource.canEdit !== false);
+  const showDelete = $derived(canDelete ?? resource.canDelete !== false);
   
   const showFields = $derived(
     resource.fields.filter(f => f.showInShow !== false)
@@ -34,11 +36,11 @@
   <div class="lite-page-header">
     <h1 class="lite-page-title">{t('common.show') || 'Show'} {resource.label || resource.name} #{idStr}</h1>
     <div class="lite-page-actions">
-      {#if canEdit}
+      {#if showEdit}
         <LiteEditButton resource={resource.name} recordItemId={idStr} {basePath} />
       {/if}
       <LiteListButton resource={resource.name} {basePath} />
-      {#if canDelete}
+      {#if showDelete}
         <LiteDeleteButton resource={resource.name} recordItemId={idStr} redirectUrl={`${basePath}/${resource.name}`} {basePath} />
       {/if}
     </div>

package/dist/components/widgets/LiteAnomalyBadge.svelte

@@ -20,7 +20,11 @@
     lowerIsBetter = false,
   }: Props = $props();
 
-  const diff = $derived(baseline === 0 ? 0 : (value - baseline) / Math.abs(baseline));
+  const diff = $derived(
+    baseline === 0
+      ? value === 0 ? 0 : value > 0 ? Infinity : -Infinity
+      : (value - baseline) / Math.abs(baseline),
+  );
   const isAnomaly = $derived(Math.abs(diff) >= threshold);
   const isGood = $derived(!isAnomaly ? null : (lowerIsBetter ? diff < 0 : diff > 0));
   const percentLabel = $derived(`${Math.abs(diff * 100).toFixed(1)}%`);

package/dist/index.js

@@ -2,7 +2,7 @@
 // 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 (use with sveltekit-superforms)
+// Schema generator (used by Lite actions; also reusable by other Zod consumers)
 export { fieldsToZodSchema, resourceToZodSchema, fieldToInputType, fieldToPlaceholder, } from './schema-generator';
 // UI Components (use in +page.svelte with csr = false)
 export { default as LiteLayout } from './components/LiteLayout.svelte';

package/dist/lite.css

@@ -802,7 +802,8 @@ textarea.lite-input {
   .lite-search,
   .lite-pagination,
   .lite-btn,
-  .lite-confirm {
+  .lite-confirm,
+  .lite-confirm-details {
     display: none !important;
   }
   .lite-main {

package/dist/menu-visibility.d.ts

@@ -0,0 +1,4 @@
+import type { MenuItem, ResourceDefinition } from '@svadmin/core';
+export type MenuAccessCheck = (resource: string, action: string) => boolean;
+export declare function filterVisibleResources(resources: ResourceDefinition[], canAccess?: MenuAccessCheck): ResourceDefinition[];
+export declare function filterVisibleMenu(menuEntries: MenuItem[], canAccess?: MenuAccessCheck): MenuItem[];

package/dist/menu-visibility.js

@@ -0,0 +1,34 @@
+function passesMenuAccess(resource, action, canAccess) {
+    if (!canAccess)
+        return true;
+    try {
+        return canAccess(resource, action);
+    }
+    catch {
+        // Permission callbacks fail closed so an evaluator error cannot expose navigation.
+        return false;
+    }
+}
+export function filterVisibleResources(resources, canAccess) {
+    return resources.filter((resource) => resource.showInMenu !== false
+        && passesMenuAccess(resource.name, 'list', canAccess));
+}
+export function filterVisibleMenu(menuEntries, canAccess) {
+    const visibleEntries = [];
+    for (const menuEntry of menuEntries) {
+        if (menuEntry.meta?.hidden)
+            continue;
+        if (menuEntry.meta?.resource
+            && !passesMenuAccess(menuEntry.meta.resource, menuEntry.meta.action ?? 'list', canAccess)) {
+            continue;
+        }
+        const visibleChildren = menuEntry.children
+            ? filterVisibleMenu(menuEntry.children, canAccess)
+            : undefined;
+        if (!menuEntry.href && menuEntry.children && menuEntry.children.length > 0
+            && visibleChildren?.length === 0)
+            continue;
+        visibleEntries.push({ ...menuEntry, ...(visibleChildren ? { children: visibleChildren } : {}) });
+    }
+    return visibleEntries;
+}

package/dist/schema-generator.d.ts

@@ -2,7 +2,7 @@
  * @svadmin/lite — Schema Generator
  *
  * Auto-generates Zod schemas from @svadmin/core FieldDefinitions.
- * Used with sveltekit-superforms for server-side form validation.
+ * Used by the Lite server actions and compatible with other Zod consumers.
  */
 import { z } from 'zod';
 import type { FieldDefinition, ResourceDefinition } from '@svadmin/core';

package/dist/schema-generator.js

@@ -2,15 +2,23 @@
  * @svadmin/lite — Schema Generator
  *
  * Auto-generates Zod schemas from @svadmin/core FieldDefinitions.
- * Used with sveltekit-superforms for server-side form validation.
+ * Used by the Lite server actions and compatible with other Zod consumers.
  */
 import { z } from 'zod';
+import { parseExplicitBoolean } from './value-normalization';
 function isNativeFile(value) {
     return typeof File !== 'undefined' && value instanceof File;
 }
 function isNonEmptyNativeFile(value) {
     return isNativeFile(value) && value.size > 0 && value.name !== '';
 }
+function normalizeSingleUpload(submittedUpload) {
+    if (submittedUpload === undefined || submittedUpload === null || submittedUpload === '')
+        return undefined;
+    if (isNativeFile(submittedUpload) && !isNonEmptyNativeFile(submittedUpload))
+        return undefined;
+    return submittedUpload;
+}
 function hasRequiredValue(value) {
     if (value === undefined || value === null)
         return false;
@@ -22,6 +30,17 @@ 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();
@@ -33,6 +52,32 @@ function numberFieldToZod(field) {
         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`,
@@ -40,36 +85,44 @@ function singleFileFieldToZod(field, options) {
     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((value) => {
-        if (value === undefined || value === null || value === '')
-            return undefined;
-        if (isNativeFile(value) && !isNonEmptyNativeFile(value))
-            return undefined;
-        return value;
-    }, targetSchema);
+    return z.preprocess(normalizeSingleUpload, targetSchema);
 }
-function multipleFilesFieldToZod(field, options) {
-    const fileSchema = z.custom(isNonEmptyNativeFile, {
-        message: `${field.label} contains an empty or invalid file`,
-    });
-    const filesSchema = z.array(fileSchema).min(1, `${field.label} must contain at least one file`);
-    const referencesSchema = z.array(z.string().trim().min(1, `${field.label} contains an empty file reference`)).min(1, `${field.label} must contain at least one file`);
-    const uploadSchema = options.allowReference ? z.union([filesSchema, referencesSchema]) : filesSchema;
-    const targetSchema = options.required ? uploadSchema : uploadSchema.optional();
-    return z.preprocess((value) => {
-        if (value === undefined || value === null || value === '')
-            return undefined;
-        if (!Array.isArray(value))
-            return value;
-        const invalidEntries = value.filter((entry) => !isNativeFile(entry) && typeof entry !== 'string');
-        if (invalidEntries.length > 0)
-            return value;
-        const uploadedFiles = value.filter(isNonEmptyNativeFile);
-        if (uploadedFiles.length > 0)
-            return uploadedFiles;
-        const references = value.filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
-        return references.length > 0 ? references : undefined;
-    }, 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 === '')
+        return undefined;
+    const entries = Array.isArray(submittedImages) ? submittedImages : [submittedImages];
+    const normalized = entries.flatMap((entry) => {
+        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.
@@ -80,8 +133,7 @@ function fieldToZod(field, mode, withinArray = false) {
         case 'number':
             return numberFieldToZod(field);
         case 'boolean':
-            schema = z.coerce.boolean();
-            break;
+            return booleanFieldToZod(field);
         case 'email':
             schema = z.string().email(`${field.label} must be a valid email`);
             break;
@@ -92,20 +144,18 @@ function fieldToZod(field, mode, withinArray = false) {
             schema = z.string().refine((v) => !v || !isNaN(Date.parse(v)), { message: `${field.label} must be a valid date` });
             break;
         case 'select':
-            if (field.options?.length) {
-                schema = z.enum(field.options.map((o) => String(o.value)), { message: `${field.label} must be one of the options` });
-            }
-            else {
-                schema = z.string();
-            }
+            schema = singleOptionFieldToZod(field);
             break;
         case 'multiselect':
-            schema = z.array(z.string()).default([]);
+            schema = multipleOptionFieldToZod(field);
+            break;
+        case 'relation':
+            schema = field.options?.length ? singleOptionFieldToZod(field) : z.string();
             break;
         case 'array': {
             const shape = {};
             for (const subField of field.subFields ?? []) {
-                shape[subField.key] = fieldToZod(subField, mode, true);
+                shape[subField.key] = applyCustomValidation(fieldToZod(subField, mode, true), subField);
             }
             const arraySchema = z.array(z.object(shape));
             return field.required
@@ -120,6 +170,7 @@ function fieldToZod(field, mode, withinArray = false) {
             break;
         case 'textarea':
         case 'richtext':
+        case 'markdown':
             schema = z.string().max(50000, `${field.label} is too long`);
             break;
         case 'json':
@@ -139,16 +190,22 @@ function fieldToZod(field, mode, withinArray = false) {
             schema = z.string().regex(/^[+\d\s()-]*$/, `${field.label} must be a valid phone number`);
             break;
         case 'file':
-        case 'image':
             return singleFileFieldToZod(field, {
                 required: field.required === true && (mode === 'create' || withinArray),
                 allowReference: mode === 'edit' && withinArray,
             });
-        case 'images':
-            return multipleFilesFieldToZod(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;
+        }
         default:
             schema = z.string();
     }
@@ -177,7 +234,7 @@ export function fieldsToZodSchema(fields, mode = 'create') {
             continue;
         if (mode === 'edit' && field.showInEdit === false)
             continue;
-        shape[field.key] = fieldToZod(field, mode);
+        shape[field.key] = applyCustomValidation(fieldToZod(field, mode), field);
     }
     return z.object(shape);
 }
@@ -186,7 +243,8 @@ export function fieldsToZodSchema(fields, mode = 'create') {
  * Convenience wrapper around fieldsToZodSchema.
  */
 export function resourceToZodSchema(resource, mode = 'create') {
-    return fieldsToZodSchema(resource.fields, mode);
+    const primaryKey = resource.primaryKey ?? 'id';
+    return fieldsToZodSchema(resource.fields.filter((field) => field.key !== primaryKey), mode);
 }
 /**
  * Determine a conservative HTML input type for server-rendered forms.
@@ -201,13 +259,16 @@ export function fieldToInputType(field) {
         case 'boolean': return 'checkbox';
         case 'date': return 'text';
         case 'textarea':
-        case 'richtext': return '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 'image':
-        case 'images':
         case 'file': return 'file';
+        case 'password': return 'password';
         default: return 'text';
     }
 }

package/dist/server-adapter.d.ts

@@ -16,6 +16,14 @@ export interface ListLoaderResult {
     sort?: string;
     order?: 'asc' | 'desc';
     search?: string;
+    /** Aliases consumed directly by LiteListPage. */
+    pagination: {
+        page: number;
+        perPage: number;
+    };
+    currentSort?: string;
+    currentOrder?: 'asc' | 'desc';
+    currentSearch?: string;
     resource: ResourceDefinition;
 }
 /**
@@ -43,6 +51,11 @@ export declare function createCrudActions(dp: DataProvider, resource: ResourceDe
         error: string;
         values: Record<string, unknown>;
         errors: Record<string, string[]>;
+    } | {
+        success: boolean;
+        error: string;
+        id?: undefined;
+        values?: undefined;
     } | {
         success: boolean;
         id: unknown;
@@ -59,6 +72,10 @@ export declare function createCrudActions(dp: DataProvider, resource: ResourceDe
         error: string;
         values: Record<string, unknown>;
         errors: Record<string, string[]>;
+    } | {
+        success: boolean;
+        error: string;
+        values?: undefined;
     } | {
         success: boolean;
         error?: undefined;
@@ -70,10 +87,10 @@ export declare function createCrudActions(dp: DataProvider, resource: ResourceDe
     }>;
     delete: ({ request }: RequestEvent) => Promise<{
         success: boolean;
-        error?: undefined;
+        error: string;
     } | {
         success: boolean;
-        error: string;
+        error?: undefined;
     }>;
 };
 /**
@@ -85,15 +102,47 @@ export declare function createAuthGuard(authProvider: AuthProvider, loginPath?:
     resolve: (event: RequestEvent) => Promise<Response>;
 }) => Promise<Response>;
 /**
- * Creates login/logout form actions using AuthProvider.
+ * Creates the form actions used by all exported Lite authentication pages.
  */
 export declare function createAuthActions(authProvider: AuthProvider): {
-    login: ({ request, cookies }: RequestEvent) => Promise<{
+    login: ({ request, cookies, url }: RequestEvent) => Promise<{
         success: boolean;
         error: string;
     }>;
     logout: ({ cookies }: RequestEvent) => Promise<{
         success: boolean;
+        error: string;
+    } | {
+        success: boolean;
+        error?: undefined;
+    }>;
+    register: ({ request }: RequestEvent) => Promise<{
+        success: boolean;
+        error: string;
+    } | {
+        success: boolean;
+        error?: undefined;
+    }>;
+    forgot_password: ({ request }: RequestEvent) => Promise<{
+        success: boolean;
+        error: string;
+    } | {
+        success: boolean;
+        error?: undefined;
+    }>;
+    update_password: ({ request }: RequestEvent) => Promise<{
+        success: boolean;
+        error: string;
+    } | {
+        success: boolean;
+        error?: undefined;
+    }>;
+    update_profile: ({ request }: RequestEvent) => Promise<{
+        success: boolean;
+        error: string;
+    } | {
+        success: boolean;
+        error?: undefined;
     }>;
 };
 /**