@svadmin/core 0.0.6 → 0.3.0

package/src/toast.svelte.ts

@@ -1,12 +1,14 @@
 // Toast notification system — Svelte 5 runes-based
 
-export type ToastType = 'success' | 'error' | 'info' | 'warning';
+export type ToastType = 'success' | 'error' | 'info' | 'warning' | 'undoable';
 
 export interface Toast {
   id: number;
   type: ToastType;
   message: string;
   duration: number;
+  onUndo?: () => void;
+  onTimeout?: () => void;
 }
 
 let nextId = 0;
@@ -16,10 +18,10 @@ export function getToasts(): Toast[] {
   return toasts;
 }
 
-export function addToast(type: ToastType, message: string, duration = 3000): void {
+export function addToast(type: ToastType, message: string, duration = 3000, options?: { onUndo?: () => void, onTimeout?: () => void }): void {
   const id = nextId++;
-  toasts = [...toasts, { id, type, message, duration }];
-  if (duration > 0) {
+  toasts = [...toasts, { id, type, message, duration, ...options }];
+  if (duration > 0 && type !== 'undoable') {
     setTimeout(() => removeToast(id), duration);
   }
 }
@@ -34,4 +36,6 @@ export const toast = {
   error: (msg: string, duration?: number) => addToast('error', msg, duration ?? 5000),
   info: (msg: string, duration?: number) => addToast('info', msg, duration),
   warning: (msg: string, duration?: number) => addToast('warning', msg, duration ?? 4000),
+  undoable: (msg: string, duration: number, onUndo: () => void, onTimeout: () => void) => 
+    addToast('undoable', msg, duration, { onUndo, onTimeout }),
 };

package/src/types.ts

@@ -1,4 +1,31 @@
-// Core type definitions — 100% Refine-compatible DataProvider + AuthProvider + Providers
+// Core type definitions — DataProvider + AuthProvider + Providers
+
+// ─── HttpError ─────────────────────────────────────────────────
+
+export type ValidationErrors = Record<string, string | string[]>;
+
+export class HttpError extends Error {
+  statusCode: number;
+  errors?: ValidationErrors;
+
+  constructor(message: string, statusCode: number, errors?: ValidationErrors) {
+    super(message);
+    this.name = 'HttpError';
+    this.statusCode = statusCode;
+    this.errors = errors;
+  }
+}
+
+export class UndoError extends Error {
+  constructor() {
+    super('Mutation undone');
+    this.name = 'UndoError';
+  }
+}
+
+// ─── Base Types ───────────────────────────────────────────────
+
+export type BaseRecord = Record<string, unknown>;
 
 // ─── DataProvider ─────────────────────────────────────────────
 
@@ -13,12 +40,25 @@ export interface Sort {
   order: 'asc' | 'desc';
 }
 
+export type CrudOperator =
+  | 'eq' | 'ne' | 'lt' | 'gt' | 'lte' | 'gte'
+  | 'contains' | 'ncontains'
+  | 'startswith' | 'endswith'
+  | 'in' | 'nin'
+  | 'null' | 'nnull'
+  | 'between' | 'nbetween';
+
 export interface Filter {
   field: string;
-  operator: 'eq' | 'ne' | 'lt' | 'gt' | 'lte' | 'gte' | 'contains' | 'in' | 'null' | 'between';
+  operator: CrudOperator;
   value: unknown;
 }
 
+export interface LogicalFilter {
+  operator: 'or' | 'and';
+  value: Filter[];
+}
+
 export interface GetListParams {
   resource: string;
   pagination?: Pagination;
@@ -27,8 +67,8 @@ export interface GetListParams {
   meta?: Record<string, unknown>;
 }
 
-export interface GetListResult<T = Record<string, unknown>> {
-  data: T[];
+export interface GetListResult<TData extends BaseRecord = BaseRecord> {
+  data: TData[];
   total: number;
 }
 
@@ -38,8 +78,8 @@ export interface GetOneParams {
   meta?: Record<string, unknown>;
 }
 
-export interface GetOneResult<T = Record<string, unknown>> {
-  data: T;
+export interface GetOneResult<TData extends BaseRecord = BaseRecord> {
+  data: TData;
 }
 
 export interface GetManyParams {
@@ -48,78 +88,78 @@ export interface GetManyParams {
   meta?: Record<string, unknown>;
 }
 
-export interface GetManyResult<T = Record<string, unknown>> {
-  data: T[];
+export interface GetManyResult<TData extends BaseRecord = BaseRecord> {
+  data: TData[];
 }
 
-export interface CreateParams {
+export interface CreateParams<TVariables = unknown> {
   resource: string;
-  variables: Record<string, unknown>;
+  variables: TVariables;
   meta?: Record<string, unknown>;
 }
 
-export interface CreateResult<T = Record<string, unknown>> {
-  data: T;
+export interface CreateResult<TData extends BaseRecord = BaseRecord> {
+  data: TData;
 }
 
-export interface CreateManyParams {
+export interface CreateManyParams<TVariables = unknown> {
   resource: string;
-  variables: Record<string, unknown>[];
+  variables: TVariables[];
   meta?: Record<string, unknown>;
 }
 
-export interface CreateManyResult<T = Record<string, unknown>> {
-  data: T[];
+export interface CreateManyResult<TData extends BaseRecord = BaseRecord> {
+  data: TData[];
 }
 
-export interface UpdateParams {
+export interface UpdateParams<TVariables = unknown> {
   resource: string;
   id: string | number;
-  variables: Record<string, unknown>;
+  variables: TVariables;
   meta?: Record<string, unknown>;
 }
 
-export interface UpdateResult<T = Record<string, unknown>> {
-  data: T;
+export interface UpdateResult<TData extends BaseRecord = BaseRecord> {
+  data: TData;
 }
 
-export interface UpdateManyParams {
+export interface UpdateManyParams<TVariables = unknown> {
   resource: string;
   ids: (string | number)[];
-  variables: Record<string, unknown>;
+  variables: TVariables;
   meta?: Record<string, unknown>;
 }
 
-export interface UpdateManyResult<T = Record<string, unknown>> {
-  data: T[];
+export interface UpdateManyResult<TData extends BaseRecord = BaseRecord> {
+  data: TData[];
 }
 
-export interface DeleteParams {
+export interface DeleteParams<TVariables = unknown> {
   resource: string;
   id: string | number;
-  variables?: Record<string, unknown>;
+  variables?: TVariables;
   meta?: Record<string, unknown>;
 }
 
-export interface DeleteResult<T = Record<string, unknown>> {
-  data: T;
+export interface DeleteResult<TData extends BaseRecord = BaseRecord> {
+  data: TData;
 }
 
-export interface DeleteManyParams {
+export interface DeleteManyParams<TVariables = unknown> {
   resource: string;
   ids: (string | number)[];
-  variables?: Record<string, unknown>;
+  variables?: TVariables;
   meta?: Record<string, unknown>;
 }
 
-export interface DeleteManyResult<T = Record<string, unknown>> {
-  data: T[];
+export interface DeleteManyResult<TData extends BaseRecord = BaseRecord> {
+  data: TData[];
 }
 
-export interface CustomParams {
+export interface CustomParams<TVariables = unknown> {
   url: string;
   method: 'get' | 'post' | 'put' | 'patch' | 'delete';
-  payload?: Record<string, unknown>;
+  payload?: TVariables;
   query?: Record<string, unknown>;
   headers?: Record<string, string>;
   sorters?: Sort[];
@@ -127,27 +167,27 @@ export interface CustomParams {
   meta?: Record<string, unknown>;
 }
 
-export interface CustomResult<T = unknown> {
-  data: T;
+export interface CustomResult<TData = unknown> {
+  data: TData;
 }
 
 export interface DataProvider {
   // Required methods
-  getList: <T = Record<string, unknown>>(params: GetListParams) => Promise<GetListResult<T>>;
-  getOne: <T = Record<string, unknown>>(params: GetOneParams) => Promise<GetOneResult<T>>;
-  create: <T = Record<string, unknown>>(params: CreateParams) => Promise<CreateResult<T>>;
-  update: <T = Record<string, unknown>>(params: UpdateParams) => Promise<UpdateResult<T>>;
-  deleteOne: <T = Record<string, unknown>>(params: DeleteParams) => Promise<DeleteResult<T>>;
+  getList: <TData extends BaseRecord = BaseRecord>(params: GetListParams) => Promise<GetListResult<TData>>;
+  getOne: <TData extends BaseRecord = BaseRecord>(params: GetOneParams) => Promise<GetOneResult<TData>>;
+  create: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: CreateParams<TVariables>) => Promise<CreateResult<TData>>;
+  update: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: UpdateParams<TVariables>) => Promise<UpdateResult<TData>>;
+  deleteOne: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: DeleteParams<TVariables>) => Promise<DeleteResult<TData>>;
   getApiUrl: () => string;
 
   // Optional bulk methods
-  getMany?: <T = Record<string, unknown>>(params: GetManyParams) => Promise<GetManyResult<T>>;
-  createMany?: <T = Record<string, unknown>>(params: CreateManyParams) => Promise<CreateManyResult<T>>;
-  updateMany?: <T = Record<string, unknown>>(params: UpdateManyParams) => Promise<UpdateManyResult<T>>;
-  deleteMany?: <T = Record<string, unknown>>(params: DeleteManyParams) => Promise<DeleteManyResult<T>>;
+  getMany?: <TData extends BaseRecord = BaseRecord>(params: GetManyParams) => Promise<GetManyResult<TData>>;
+  createMany?: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: CreateManyParams<TVariables>) => Promise<CreateManyResult<TData>>;
+  updateMany?: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: UpdateManyParams<TVariables>) => Promise<UpdateManyResult<TData>>;
+  deleteMany?: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: DeleteManyParams<TVariables>) => Promise<DeleteManyResult<TData>>;
 
   // Optional custom method
-  custom?: <T = unknown>(params: CustomParams) => Promise<CustomResult<T>>;
+  custom?: <TData = unknown, TVariables = unknown>(params: CustomParams<TVariables>) => Promise<CustomResult<TData>>;
 }
 
 // ─── AuthProvider ─────────────────────────────────────────────
@@ -200,6 +240,8 @@ export type MutationMode = 'pessimistic' | 'optimistic' | 'undoable';
 
 export interface ResourceDefinition {
   name: string;
+  /** Unique identifier — use when multiple resources share the same `name` but target different DataProviders */
+  identifier?: string;
   label: string;
   icon?: string;
   primaryKey?: string;
@@ -210,7 +252,10 @@ export interface ResourceDefinition {
   canEdit?: boolean;
   canDelete?: boolean;
   canShow?: boolean;
-  meta?: Record<string, unknown>;
+  showInMenu?: boolean;
+  parentName?: string;
+  menuOrder?: number;
+  meta?: Record<string, unknown> & { dataProviderName?: string; parent?: string };
 }
 
 export interface FieldDefinition {
@@ -236,3 +281,35 @@ export interface FieldDefinition {
   // Validation
   validate?: (value: unknown) => string | null;
 }
+
+// ─── Resource Type Registry ───────────────────────────────────
+
+/**
+ * Extend this interface via declaration merging to register resource types.
+ * When registered, all hooks automatically infer data types from resource names.
+ *
+ * @example
+ * ```ts
+ * declare module '@svadmin/core' {
+ *   interface ResourceTypeMap {
+ *     users: { id: string; name: string; email: string }
+ *     posts: { id: string; title: string; content: string }
+ *   }
+ * }
+ *
+ * // Now hooks auto-infer:
+ * const list = useList({ resource: 'users' })
+ * // list.data → { id: string; name: string; email: string }[]
+ * ```
+ */
+export interface ResourceTypeMap {}
+
+/** When ResourceTypeMap is empty → string (backward compatible); otherwise → registered keys */
+export type KnownResources = keyof ResourceTypeMap extends never
+  ? string
+  : Extract<keyof ResourceTypeMap, string>
+
+/** Infer data type from resource name. Falls back to Record<string, unknown> for unregistered resources */
+export type InferData<R extends string> = R extends keyof ResourceTypeMap
+  ? ResourceTypeMap[R]
+  : Record<string, unknown>

package/src/unsaved-changes.svelte.ts

@@ -0,0 +1,62 @@
+// UnsavedChangesNotifier — warns user before leaving page with unsaved changes
+// Svelte 5 component using runes
+
+import { onDestroy, onMount } from 'svelte';
+
+let warnWhenUnsavedChanges = $state(false);
+
+/**
+ * Call this to mark the form as dirty (has unsaved changes).
+ * When set to true, navigating away or closing the tab will trigger a warning.
+ */
+export function setUnsavedChanges(dirty: boolean) {
+  warnWhenUnsavedChanges = dirty;
+}
+
+export function getUnsavedChanges(): boolean {
+  return warnWhenUnsavedChanges;
+}
+
+const beforeUnloadHandler = (e: BeforeUnloadEvent) => {
+  if (warnWhenUnsavedChanges) {
+    e.preventDefault();
+    // Modern browsers ignore custom messages but require returnValue to be set
+    e.returnValue = '';
+    return '';
+  }
+};
+
+/**
+ * Initialize the UnsavedChangesNotifier.
+ * Call this in your root layout or AdminApp component.
+ * It handles both browser tab close and in-app navigation.
+ */
+export function initUnsavedChangesNotifier() {
+  if (typeof window === 'undefined') return;
+
+  window.addEventListener('beforeunload', beforeUnloadHandler);
+
+  // For hash-based navigation, intercept hashchange
+  const hashChangeHandler = (e: HashChangeEvent) => {
+    if (warnWhenUnsavedChanges) {
+      const confirmed = confirm('You have unsaved changes. Are you sure you want to leave?');
+      if (!confirmed) {
+        e.preventDefault();
+        // Restore original hash
+        if (e.oldURL) {
+          const oldHash = new URL(e.oldURL).hash;
+          history.replaceState(null, '', oldHash || '#');
+        }
+      } else {
+        warnWhenUnsavedChanges = false;
+      }
+    }
+  };
+
+  window.addEventListener('hashchange', hashChangeHandler);
+
+  return () => {
+    window.removeEventListener('beforeunload', beforeUnloadHandler);
+    window.removeEventListener('hashchange', hashChangeHandler);
+  };
+}

package/src/url-sync.ts

@@ -1,14 +1,18 @@
 // URL state sync — sync pagination/sort/filters with hash params
 
+import type { Filter } from './types';
+
 export interface URLState {
   page?: number;
   pageSize?: number;
   sortField?: string;
   sortOrder?: 'asc' | 'desc';
   search?: string;
+  filters?: Filter[];
 }
 
 export function readURLState(): URLState {
+  if (typeof window === 'undefined') return {};
   const hash = window.location.hash;
   const queryIdx = hash.indexOf('?');
   if (queryIdx === -1) return {};
@@ -31,10 +35,18 @@ export function readURLState(): URLState {
   const search = params.get('q');
   if (search) state.search = search;
 
+  const filtersRaw = params.get('filters');
+  if (filtersRaw) {
+    try {
+      state.filters = JSON.parse(filtersRaw);
+    } catch { /* ignore invalid json */ }
+  }
+
   return state;
 }
 
 export function writeURLState(state: URLState): void {
+  if (typeof window === 'undefined') return;
   const hash = window.location.hash;
   const pathIdx = hash.indexOf('?');
   const basePath = pathIdx === -1 ? hash : hash.slice(0, pathIdx);
@@ -45,6 +57,9 @@ export function writeURLState(state: URLState): void {
   if (state.sortField) params.set('sort', state.sortField);
   if (state.sortOrder) params.set('order', state.sortOrder);
   if (state.search) params.set('q', state.search);
+  if (state.filters && state.filters.length > 0) {
+    params.set('filters', JSON.stringify(state.filters));
+  }
 
   const qs = params.toString();
   const newHash = qs ? `${basePath}?${qs}` : basePath;

package/src/useParsed.ts

@@ -40,9 +40,46 @@ export function useParsed(): ParsedRoute {
     const segments = pathname.split('/').filter(Boolean);
     if (segments.length === 0) return result;
 
-    // First segment is typically the resource name
+    // Find the rightmost segment that matches a known resource name
     const resourceNames = resources.map(r => r.name);
-    if (resourceNames.includes(segments[0])) {
+    let resourceIndex = -1;
+    for (let i = segments.length - 1; i >= 0; i--) {
+      if (resourceNames.includes(segments[i])) {
+        resourceIndex = i;
+        break;
+      }
+    }
+
+    if (resourceIndex !== -1) {
+      result.resource = segments[resourceIndex];
+
+      // Add parent path params based on `<parentResource>/<parentId>` structure
+      for (let i = 0; i < resourceIndex; i += 2) {
+        if (segments[i] && segments[i + 1]) {
+          const parentName = segments[i];
+          const singular = parentName.endsWith('s') ? parentName.slice(0, -1) : parentName;
+          result.params[`${singular}Id`] = segments[i + 1];
+        }
+      }
+
+      const restSegments = segments.slice(resourceIndex + 1);
+      if (restSegments.length === 0) {
+        result.action = 'list';
+      } else if (restSegments[0] === 'create') {
+        result.action = 'create';
+      } else if (restSegments[0] === 'edit' && restSegments[1]) {
+        result.action = 'edit';
+        result.id = restSegments[1];
+      } else if (restSegments[0] === 'show' && restSegments[1]) {
+        result.action = 'show';
+        result.id = restSegments[1];
+      } else if (restSegments[0]) {
+        // Legacy: /:resource/:id
+        result.action = 'show';
+        result.id = restSegments[0];
+      }
+    } else {
+      // Fallback if resource definitions are not loaded yet
       result.resource = segments[0];
 
       if (segments.length === 1) {
@@ -56,7 +93,6 @@ export function useParsed(): ParsedRoute {
         result.action = 'show';
         result.id = segments[2];
       } else if (segments[1]) {
-        // Legacy: /:resource/:id
         result.action = 'show';
         result.id = segments[1];
       }

package/src/useStepsForm.svelte.ts

@@ -0,0 +1,71 @@
+import { useForm } from './form-hooks.svelte';
+import type { UseFormOptions, UseFormResult } from './form-hooks.svelte';
+import type { BaseRecord, HttpError } from './types';
+
+export interface UseStepsFormOptions<
+  TQueryFnData extends BaseRecord = BaseRecord,
+  TError = HttpError,
+  TVariables = Record<string, unknown>,
+  TData extends BaseRecord = TQueryFnData
+> extends UseFormOptions<TQueryFnData, TError, TVariables, TData> {
+  /** Default step index. Starts at 0. */
+  defaultStep?: number;
+  /** Validate the form when navigating back? */
+  isBackValidate?: boolean;
+}
+
+export interface UseStepsFormResult<
+  TQueryFnData extends BaseRecord = BaseRecord,
+  TError = HttpError,
+  TVariables = Record<string, unknown>,
+  TData extends BaseRecord = TQueryFnData
+> extends UseFormResult<TQueryFnData, TError, TVariables, TData> {
+  currentStep: number;
+  gotoStep: (step: number) => void;
+  next: () => void;
+  prev: () => void;
+}
+
+/**
+ * useStepsForm
+ * Extends `useForm` with step navigation state (currentStep, next, prev, gotoStep).
+ */
+export function useStepsForm<
+  TQueryFnData extends BaseRecord = BaseRecord,
+  TError = HttpError,
+  TVariables = Record<string, unknown>,
+  TData extends BaseRecord = TQueryFnData
+>(options: UseStepsFormOptions<TQueryFnData, TError, TVariables, TData> = {} as any): UseStepsFormResult<TQueryFnData, TError, TVariables, TData> {
+  const form = useForm<TQueryFnData, TError, TVariables, TData>(options);
+  
+  let currentStep = $state(options.defaultStep ?? 0);
+  
+  function gotoStep(step: number) {
+    currentStep = Math.max(0, step);
+  }
+  
+  function next() {
+    gotoStep(currentStep + 1);
+  }
+  
+  function prev() {
+    if (currentStep > 0) {
+      gotoStep(currentStep - 1);
+    }
+  }
+
+  // Inject stepping features into the returned useForm object while preserving its reactive getters.
+  const result = form as unknown as UseStepsFormResult<TQueryFnData, TError, TVariables, TData>;
+  
+  Object.defineProperty(result, 'currentStep', {
+    get: () => currentStep,
+    enumerable: true,
+    configurable: true
+  });
+  
+  result.gotoStep = gotoStep;
+  result.next = next;
+  result.prev = prev;
+
+  return result;
+}