@svadmin/core 0.22.0 → 0.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "author": "zuohuadong",
   "repository": {
     "type": "git",

package/src/auth-hooks.svelte.ts

@@ -242,6 +242,14 @@ export function usePermissions<T = unknown>() {
     fetch();
   }
 
+  const hasFn = (perm: string): boolean => {
+    if (!permissions) return false;
+    if (Array.isArray(permissions)) return permissions.includes(perm);
+    if (permissions instanceof Set) return (permissions as Set<string>).has(perm);
+    if (typeof permissions === 'object') return !!(permissions as Record<string, boolean>)[perm];
+    return false;
+  };
+
   return {
     get isLoading() { return isLoading; },
     get error() { return error; },
@@ -250,18 +258,10 @@ export function usePermissions<T = unknown>() {
     refetch: fetch,
 
     /** Check if a specific permission string exists */
-    has(perm: string): boolean {
-      if (!permissions) return false;
-      if (Array.isArray(permissions)) return permissions.includes(perm);
-      if (permissions instanceof Set) return (permissions as Set<string>).has(perm);
-      if (typeof permissions === 'object') return !!(permissions as Record<string, boolean>)[perm];
-      return false;
-    },
+    has: hasFn,
 
     /** Check resource:action style permission */
-    can(resource: string, action: string): boolean {
-      return this.has(`${resource}:${action}`);
-    },
+    can: (resource: string, action: string): boolean => hasFn(`${resource}:${action}`),
   };
 }
 

package/src/context.svelte.ts

@@ -68,8 +68,8 @@ function isDataProvider(value: unknown): value is DataProvider {
 
 let authProvider = $state<AuthProvider | null>(null);
 
-export function setAuthProvider(provider: AuthProvider): void {
-  authProvider = provider;
+export function setAuthProvider(provider: AuthProvider | null | undefined): void {
+  authProvider = provider || null;
 }
 
 export function getAuthProvider(): AuthProvider;

package/src/data-transfer.svelte.ts

@@ -120,15 +120,20 @@ export function useImport<TData = Record<string, unknown>>(options: UseImportOpt
     const errored: { request: unknown; error: unknown }[] = [];
 
     try {
-      const text = await info.file.text();
-      const lines = text.split('\n').filter(l => l.trim() !== '');
-      if (lines.length < 2) return;
+      let text = await info.file.text();
+      // Strip BOM
+      if (text.charCodeAt(0) === 0xFEFF) {
+        text = text.slice(1);
+      }
+
+      const rows = parseCSV(text);
+      if (rows.length < 2) return;
 
-      const headers = parseCSVLine(lines[0]);
+      const headers = rows[0];
       const records: Record<string, unknown>[] = [];
 
-      for (let i = 1; i < lines.length; i++) {
-        const values = parseCSVLine(lines[i]);
+      for (let i = 1; i < rows.length; i++) {
+        const values = rows[i];
         const record: Record<string, unknown> = {};
         headers.forEach((h, idx) => { record[h] = values[idx] ?? ''; });
         records.push(options.mapData ? (options.mapData(record) as unknown as Record<string, unknown>) : record);
@@ -151,18 +156,23 @@ export function useImport<TData = Record<string, unknown>>(options: UseImportOpt
       } else {
         for (let i = 0; i < records.length; i += batchSize) {
           const batch = records.slice(i, i + batchSize);
-          try {
-            if (provider.createMany) {
+          if (provider.createMany) {
+            try {
               const res = await provider.createMany({ resource, variables: batch, meta: options.meta });
               succeeded.push(res);
-            } else {
-              for (const record of batch) {
+            } catch (error) {
+              errored.push({ request: batch, error });
+            }
+          } else {
+            // Fallback: loop internal items inside batch securely instead of breaking whole batch
+            for (const record of batch) {
+              try {
                 const res = await provider.create({ resource, variables: record, meta: options.meta });
                 succeeded.push(res);
+              } catch (error) {
+                errored.push({ request: record, error });
               }
             }
-          } catch (error) {
-            errored.push({ request: batch, error });
           }
           processed += batch.length;
           options.onProgress?.({ totalAmount: records.length, processedAmount: processed });
@@ -184,34 +194,53 @@ export function useImport<TData = Record<string, unknown>>(options: UseImportOpt
   };
 }
 
-/** Parse a single CSV line respecting quoted fields */
-function parseCSVLine(line: string): string[] {
-  const result: string[] = [];
-  let current = '';
+/** Parse full CSV text respecting quoted multi-line fields */
+function parseCSV(text: string): string[][] {
+  const rows: string[][] = [];
+  let currentRow: string[] = [];
+  let currentVal = '';
   let inQuotes = false;
 
-  for (let i = 0; i < line.length; i++) {
-    const ch = line[i];
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
     if (inQuotes) {
-      if (ch === '"' && line[i + 1] === '"') {
-        current += '"';
-        i++;
-      } else if (ch === '"') {
-        inQuotes = false;
+      if (ch === '"') {
+        if (i + 1 < text.length && text[i + 1] === '"') {
+          currentVal += '"';
+          i++; // skip escaped quote
+        } else {
+          inQuotes = false;
+        }
       } else {
-        current += ch;
+        currentVal += ch;
       }
     } else {
       if (ch === '"') {
         inQuotes = true;
       } else if (ch === ',') {
-        result.push(current.trim());
-        current = '';
+        currentRow.push(currentVal.trim());
+        currentVal = '';
+      } else if (ch === '\n' || ch === '\r') {
+        currentRow.push(currentVal.trim());
+        if (currentRow.some(v => v !== '')) {
+          rows.push(currentRow);
+        }
+        currentRow = [];
+        currentVal = '';
+        if (ch === '\r' && i + 1 < text.length && text[i + 1] === '\n') {
+          i++; // consume \n of \r\n
+        }
       } else {
-        current += ch;
+        currentVal += ch;
       }
     }
   }
-  result.push(current.trim());
-  return result;
+  
+  if (currentVal || currentRow.length > 0) {
+    currentRow.push(currentVal.trim());
+    if (currentRow.some(v => v !== '')) {
+      rows.push(currentRow);
+    }
+  }
+  return rows;
 }

package/src/form-hooks.svelte.ts

@@ -275,6 +275,14 @@ export function useForm<
   let queryInitializedId: string | number | undefined = undefined;
   {
     $effect.pre(() => {
+      // Discard previous fetch lock and default when switched strictly back to create
+      if (action === 'create' && currentId === undefined && queryInitializedId !== undefined) {
+        queryInitializedId = undefined;
+        const def = (options.defaultValues ?? {}) as TVariables;
+        values = { ...def };
+        initialValues = { ...def };
+        return;
+      }
       if (queryInitializedId === currentId) return;
       const data = query.data as Record<string, unknown> | undefined;
       const pk = getResource(resource).primaryKey ?? 'id';

package/src/hooks.svelte.ts

@@ -23,10 +23,10 @@ export type { OvertimeResult, OvertimeOptions, NotificationConfig } from './hook
 
 import { createQuery, createInfiniteQuery, createMutation, useQueryClient } from '@tanstack/svelte-query';
 import { getAdminOptions } from './options.svelte';
-import { getDataProviderForResource, getDataProvider } from './context.svelte';
+import { getDataProviderForResource, getDataProvider, getLiveProvider } from './context.svelte';
 import { useParsed } from './useParsed.svelte';
-import { createOvertimeTracker, fireSuccessNotification, fireErrorNotification } from './hook-utils.svelte';
-import type { NotificationConfig, OvertimeOptions } from './hook-utils.svelte';
+import { createOvertimeTracker, createLiveSubscription, fireSuccessNotification, fireErrorNotification } from './hook-utils.svelte';
+import type { NotificationConfig, OvertimeOptions, LiveSubscriptionParams } from './hook-utils.svelte';
 import type { BaseRecord, HttpError, Pagination, Sort, Filter, DataProvider, KnownResources } from './types';
 import type { LiveMode, LiveEvent } from './live.svelte';
 import { useList } from './query-hooks.svelte';
@@ -52,13 +52,13 @@ export interface UseInfiniteListOptions<TData extends BaseRecord = BaseRecord, T
 
 export function useInfiniteList<TData extends BaseRecord = BaseRecord, TError = HttpError>(options: UseInfiniteListOptions<TData, TError> = {}) {
   const parsed = useParsed();
-  const resource = options.resource ?? parsed.resource ?? '';
   const adminOptions = getAdminOptions();
 
   const query = createInfiniteQuery<{ data: TData[]; total: number }, TError>(() => {
+    const resource = options.resource ?? parsed.resource ?? '';
     const provider = getDataProviderForResource(resource, options.dataProviderName);
     return {
-    queryKey: [resource, 'infiniteList', options.sorters, options.filters, options.meta],
+    queryKey: [resource, 'infiniteList', options.pagination?.pageSize, options.sorters, options.filters, options.meta],
     queryFn: async ({ pageParam = 1 }) => {
       const result = await provider.getList<TData>({
         resource,
@@ -82,6 +82,25 @@ export function useInfiniteList<TData extends BaseRecord = BaseRecord, TError =
 
   const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
 
+  createLiveSubscription((): LiveSubscriptionParams => ({
+    resource: options.resource ?? parsed.resource ?? '',
+    liveProvider: getLiveProvider(),
+    liveMode: options.liveMode ?? adminOptions.liveMode,
+    onLiveEvent: (e: LiveEvent) => {
+      options.onLiveEvent?.(e);
+      adminOptions.onLiveEvent?.(e);
+    },
+    enabled: options.queryOptions?.enabled ?? true,
+  }));
+
+  $effect(() => {
+    if (query.isSuccess && options.successNotification) {
+      fireSuccessNotification(options.successNotification, '', query.data, undefined, options.resource ?? parsed.resource ?? '');
+    } else if (query.isError) {
+      fireErrorNotification(options.errorNotification, 'Fetch failed', query.error);
+    }
+  });
+
   return { query, get overtime() { return overtime; } };
 }
 

package/src/i18n.svelte.ts

@@ -4,6 +4,15 @@
 
 const locales: Record<string, Record<string, string>> = {
   'zh-CN': {
+    'common.list': '列表',
+    'common.prev': '上一页',
+    'common.pageOf': '第 {page} 页，共 {total} 页',
+    'common.areYouSure': '确认操作？',
+    'common.backToList': '返回列表',
+    'common.refresh': '刷新',
+    'common.importData': '导入数据',
+    'common.upload': '上传',
+    'common.returnHome': '返回首页',
     // Common
     'common.save': '保存',
     'common.cancel': '取消',
@@ -242,6 +251,15 @@ const locales: Record<string, Record<string, string>> = {
     'profile.updatePassword': '更新密码',
   },
   'en': {
+    'common.list': 'List',
+    'common.prev': 'Prev',
+    'common.pageOf': 'Page {page} of {total}',
+    'common.areYouSure': 'Are you sure?',
+    'common.backToList': 'Back to List',
+    'common.refresh': 'Refresh',
+    'common.importData': 'Import data',
+    'common.upload': 'Upload',
+    'common.returnHome': 'Return to Home',
     // Common
     'common.save': 'Save',
     'common.cancel': 'Cancel',

package/src/live-websocket.ts

@@ -27,6 +27,7 @@ export function createWebSocketLiveProvider(options: WebSocketLiveProviderOption
 
   type Callback = (event: LiveEvent) => void;
   const subscribers = new Map<string, Set<Callback>>();
+  const lastParams = new Map<string, Record<string, unknown> | undefined>();
   let ws: WebSocket | null = null;
   let reconnectAttempts = 0;
   let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
@@ -51,6 +52,14 @@ export function createWebSocketLiveProvider(options: WebSocketLiveProviderOption
       status = 'connected';
       reconnectAttempts = 0;
       options.onOpen?.();
+      
+      // Resend subscriptions upon reconnects
+      for (const [res, callbacks] of subscribers.entries()) {
+        if (callbacks.size > 0) {
+          const liveParams = lastParams.get(res);
+          ws?.send(JSON.stringify({ type: 'SUBSCRIBE', resource: res, liveParams }));
+        }
+      }
     };
 
     ws.onmessage = (msgEvent) => {
@@ -107,22 +116,31 @@ export function createWebSocketLiveProvider(options: WebSocketLiveProviderOption
 
 
   return {
-    subscribe({ resource, callback }) {
+    subscribe({ resource, liveParams, callback }) {
       if (!subscribers.has(resource)) {
         subscribers.set(resource, new Set());
       }
       subscribers.get(resource)!.add(callback);
+      lastParams.set(resource, liveParams);
 
       // Ensure connection is open
       if (status === 'disconnected' && typeof WebSocket !== 'undefined') {
         connect();
+      } else if (status === 'connected' && ws && ws.readyState === WebSocket.OPEN) {
+        // If already connected, dispatch subscription payload dynamically
+        ws.send(JSON.stringify({ type: 'SUBSCRIBE', resource, liveParams }));
       }
 
       return () => {
         const callbacks = subscribers.get(resource);
         if (callbacks) {
           callbacks.delete(callback);
-          if (callbacks.size === 0) subscribers.delete(resource);
+          if (callbacks.size === 0) {
+            subscribers.delete(resource);
+            if (status === 'connected' && ws && ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'UNSUBSCRIBE', resource }));
+            }
+          }
         }
         // Auto-disconnect if no subscribers left
         if (subscribers.size === 0) disconnect();

package/src/query-hooks.svelte.ts

@@ -41,6 +41,8 @@ function extendQuery<Q extends object, E extends Record<string, unknown>>(
 
 // ─── useList ───────────────────────────────────────────────────
 
+export type MaybeGetter<T> = T | (() => T);
+
 export interface UseListOptions<TData extends BaseRecord = BaseRecord, TError = HttpError> {
   resource?: KnownResources;
   pagination?: Pagination;
@@ -57,51 +59,58 @@ export interface UseListOptions<TData extends BaseRecord = BaseRecord, TError =
   overtimeOptions?: OvertimeOptions;
 }
 
-export function useList<TData extends BaseRecord = BaseRecord, TError = HttpError>(options: UseListOptions<TData, TError> = {}) {
+export function useList<TData extends BaseRecord = BaseRecord, TError = HttpError>(optionsOrGetter: MaybeGetter<UseListOptions<TData, TError>> = {}) {
   const parsed = useParsed();
-  const resource = options.resource ?? parsed.resource ?? '';
   const adminOptions = getAdminOptions();
-  const provider = getDataProviderForResource(resource, options.dataProviderName);
-
-  const queryOptions = options.queryOptions;
+  
+  const getOptions = () => typeof optionsOrGetter === 'function' ? optionsOrGetter() : optionsOrGetter;
+  const getResource = () => getOptions().resource ?? parsed.resource ?? '';
 
-  const query = createQuery<GetListResult<TData>, TError>(() => ({
-    queryKey: [resource, 'list', options.pagination, options.sorters, options.filters, options.meta],
-    queryFn: async () => {
-      const result = await provider.getList<TData>({
+  const query = createQuery<GetListResult<TData>, TError>(() => {
+    const opts = getOptions();
+    const resource = getResource();
+    const provider = getDataProviderForResource(resource, opts.dataProviderName);
+    const queryOptions = opts.queryOptions;
+    
+    return {
+      queryKey: [resource, 'list', opts.pagination, opts.sorters, opts.filters, opts.meta],
+      queryFn: async () => provider.getList<TData>({
         resource,
-        pagination: options.pagination,
-        sorters: options.sorters,
-        filters: options.filters,
-        meta: options.meta,
-      });
-      return result;
-    },
-    enabled: queryOptions?.enabled ?? true,
-    staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
-    gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
-    refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
-  }));
+        pagination: opts.pagination,
+        sorters: opts.sorters,
+        filters: opts.filters,
+        meta: opts.meta,
+      }),
+      enabled: queryOptions?.enabled ?? true,
+      staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
+      gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
+      refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
+    };
+  });
 
-  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
+  const overtime = createOvertimeTracker(() => query.isLoading, typeof optionsOrGetter === 'function' ? optionsOrGetter().overtimeOptions : optionsOrGetter.overtimeOptions ?? adminOptions.overtime);
 
-  createLiveSubscription((): LiveSubscriptionParams => ({
-    resource,
-    liveProvider: getLiveProvider(),
-    liveMode: options.liveMode ?? adminOptions.liveMode,
-    onLiveEvent: (e: LiveEvent) => {
-      options.onLiveEvent?.(e);
-      adminOptions.onLiveEvent?.(e);
-    },
-    liveParams: options.liveParams,
-    enabled: queryOptions?.enabled ?? true,
-  }));
+  createLiveSubscription((): LiveSubscriptionParams => {
+    const opts = getOptions();
+    return {
+      resource: getResource(),
+      liveProvider: getLiveProvider(),
+      liveMode: opts.liveMode ?? adminOptions.liveMode,
+      onLiveEvent: (e: LiveEvent) => {
+        opts.onLiveEvent?.(e);
+        adminOptions.onLiveEvent?.(e);
+      },
+      liveParams: opts.liveParams,
+      enabled: opts.queryOptions?.enabled ?? true,
+    };
+  });
 
   $effect(() => {
-    if (query.isSuccess && options.successNotification) {
-      fireSuccessNotification(options.successNotification, '', query.data, undefined, resource);
+    const opts = getOptions();
+    if (query.isSuccess && opts.successNotification) {
+      fireSuccessNotification(opts.successNotification, '', query.data, undefined, getResource());
     } else if (query.isError) {
-      fireErrorNotification(options.errorNotification, 'Fetch failed', query.error);
+      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error);
     }
   });
 
@@ -124,38 +133,47 @@ export interface UseOneOptions<TData extends BaseRecord = BaseRecord, TError = H
   overtimeOptions?: OvertimeOptions;
 }
 
-export function useOne<TData extends BaseRecord = BaseRecord, TError = HttpError>(options: UseOneOptions<TData, TError> = {}) {
+export function useOne<TData extends BaseRecord = BaseRecord, TError = HttpError>(optionsOrGetter: MaybeGetter<UseOneOptions<TData, TError>> = {}) {
   const parsed = useParsed();
-  const resource = options.resource ?? parsed.resource ?? '';
-  const id = options.id ?? parsed.id;
   const adminOptions = getAdminOptions();
-  const provider = getDataProviderForResource(resource, options.dataProviderName);
+  
+  const getOptions = () => typeof optionsOrGetter === 'function' ? optionsOrGetter() : optionsOrGetter;
+  const getResource = () => getOptions().resource ?? parsed.resource ?? '';
+  const getId = () => getOptions().id ?? parsed.id;
 
-  const queryOptions = options.queryOptions;
+  const query = createQuery<GetOneResult<TData>, TError>(() => {
+    const opts = getOptions();
+    const resource = getResource();
+    const id = getId();
+    const provider = getDataProviderForResource(resource, opts.dataProviderName);
+    const queryOptions = opts.queryOptions;
 
-  const query = createQuery<GetOneResult<TData>, TError>(() => ({
-    queryKey: [resource, 'one', id, options.meta],
-    queryFn: async () => {
-      if (id == null) throw new Error('useOne requires an id');
-      const result = await provider.getOne<TData>({
-        resource,
-        id,
-        meta: options.meta,
-      });
-      return result;
-    },
-    enabled: (queryOptions?.enabled ?? true) && id != null,
-    staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
-    gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
-  }));
+    return {
+      queryKey: [resource, 'one', id, opts.meta],
+      queryFn: async () => {
+        if (id == null) throw new Error('useOne requires an id');
+        const result = await provider.getOne<TData>({
+          resource,
+          id,
+          meta: opts.meta,
+        });
+        return result;
+      },
+      enabled: (queryOptions?.enabled ?? true) && id != null,
+      staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
+      gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
+      refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
+    };
+  });
 
-  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
+  const overtime = createOvertimeTracker(() => query.isLoading, typeof optionsOrGetter === 'function' ? optionsOrGetter().overtimeOptions : optionsOrGetter.overtimeOptions ?? adminOptions.overtime);
 
   $effect(() => {
-    if (query.isSuccess && options.successNotification) {
-      fireSuccessNotification(options.successNotification, '', query.data, undefined, resource);
+    const opts = getOptions();
+    if (query.isSuccess && opts.successNotification) {
+      fireSuccessNotification(opts.successNotification, '', query.data, undefined, getResource());
     } else if (query.isError) {
-      fireErrorNotification(options.errorNotification, 'Fetch failed', query.error);
+      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error);
     }
   });
 
@@ -164,17 +182,23 @@ export function useOne<TData extends BaseRecord = BaseRecord, TError = HttpError
 
 // ─── useShow ──────────────────────────────────────────────────
 export function useShow<TData extends BaseRecord = BaseRecord, TError = HttpError>(
-  options: UseOneOptions<TData, TError> = {}
+  optionsOrGetter: MaybeGetter<UseOneOptions<TData, TError>> = {}
 ) {
   const parsed = useParsed();
-  let showId = $state<string | number | undefined>(options.id ?? parsed.id);
+  const getOptions = () => typeof optionsOrGetter === 'function' ? optionsOrGetter() : optionsOrGetter;
+  
+  let _showId = $state<string | number | undefined>(undefined);
+  
+  // showId prioritizes explicit setShowId, then options.id, then URL id.
+  const showId = $derived(_showId ?? getOptions().id ?? parsed.id);
 
-  function setShowId(id: string | number) { showId = id; }
+  function setShowId(id: string | number) { _showId = id; }
 
-  const result = useOne<TData, TError>({
-    ...options,
-    get id() { return showId; },
-  });
+  // We wrap it in a getter so useOne evaluates it dynamically.
+  const result = useOne<TData, TError>(() => ({
+    ...getOptions(),
+    id: showId,
+  }));
 
   return extendQuery(result, () => ({ showId, setShowId }));
 }
@@ -195,30 +219,38 @@ export interface UseManyOptions<TData extends BaseRecord = BaseRecord, TError =
   overtimeOptions?: OvertimeOptions;
 }
 
-export function useMany<TData extends BaseRecord = BaseRecord, TError = HttpError>(options: UseManyOptions<TData, TError>) {
-  const { resource, ids, meta, dataProviderName, queryOptions } = options;
+export function useMany<TData extends BaseRecord = BaseRecord, TError = HttpError>(optionsOrGetter: MaybeGetter<UseManyOptions<TData, TError>>) {
   const adminOptions = getAdminOptions();
-  const provider = getDataProviderForResource(resource, dataProviderName);
-
-  const query = createQuery<GetManyResult<TData>, TError>(() => ({
-    queryKey: [resource, 'many', ids, meta],
-    queryFn: async () => {
-      if (!ids.length) return { data: [] };
-      if (provider.getMany) {
-        return provider.getMany<TData>({ resource, ids, meta });
-      }
-      const results = await Promise.all(ids.map(id => provider.getOne<TData>({ resource, id, meta })));
-      return { data: results.map(r => r.data) };
-    },
-    enabled: (queryOptions?.enabled ?? true) && ids.length > 0,
-    staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
-  }));
+  const getOptions = () => typeof optionsOrGetter === 'function' ? optionsOrGetter() : optionsOrGetter;
+
+  const query = createQuery<GetManyResult<TData>, TError>(() => {
+    const opts = getOptions();
+    const { resource, ids, meta, dataProviderName, queryOptions } = opts;
+    const provider = getDataProviderForResource(resource, dataProviderName);
+
+    return {
+      queryKey: [resource, 'many', ids, meta],
+      queryFn: async () => {
+        if (!ids.length) return { data: [] };
+        if (provider.getMany) {
+          return provider.getMany<TData>({ resource, ids, meta });
+        }
+        const results = await Promise.all(ids.map(id => provider.getOne<TData>({ resource, id, meta })));
+        return { data: results.map(r => r.data) };
+      },
+      enabled: (queryOptions?.enabled ?? true) && ids.length > 0,
+      staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
+      gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
+      refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
+    };
+  });
 
-  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
+  const overtime = createOvertimeTracker(() => query.isLoading, typeof optionsOrGetter === 'function' ? optionsOrGetter().overtimeOptions : optionsOrGetter.overtimeOptions ?? adminOptions.overtime);
 
   $effect(() => {
-    if (query.isSuccess && options.successNotification) fireSuccessNotification(options.successNotification, '', query.data, undefined, resource);
-    else if (query.isError) fireErrorNotification(options.errorNotification, 'Fetch failed', query.error);
+    const opts = getOptions();
+    if (query.isSuccess && opts.successNotification) fireSuccessNotification(opts.successNotification, '', query.data, undefined, opts.resource);
+    else if (query.isError) fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error);
   });
 
   return extendQuery(query, () => ({ overtime }));

package/src/routing-hooks.svelte.ts

@@ -87,11 +87,11 @@ export function useNavigation() {
   const parsed = useParsed();
 
   return {
-    create: (resource?: string) => go({ type: 'push', resource: resource ?? parsed.resource, action: 'create' }),
-    edit: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resource, action: 'edit', id: id ?? parsed.id }),
-    clone: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resource, action: 'clone', id: id ?? parsed.id }),
-    show: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resource, action: 'show', id: id ?? parsed.id }),
-    list: (resource?: string) => go({ type: 'push', resource: resource ?? parsed.resource, action: 'list' }),
+    create: (resource?: string) => go({ type: 'push', resource: resource ?? parsed.resourcePath ?? parsed.resource, action: 'create' }),
+    edit: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resourcePath ?? parsed.resource, action: 'edit', id: id ?? parsed.id }),
+    clone: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resourcePath ?? parsed.resource, action: 'clone', id: id ?? parsed.id }),
+    show: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resourcePath ?? parsed.resource, action: 'show', id: id ?? parsed.id }),
+    list: (resource?: string) => go({ type: 'push', resource: resource ?? parsed.resourcePath ?? parsed.resource, action: 'list' }),
     push: (url: string) => go({ to: url, type: 'push' }),
     replace: (url: string) => go({ to: url, type: 'replace' }),
     goBack: useBack(),

package/src/table-hooks.svelte.ts

@@ -2,7 +2,7 @@ import { useParsed } from './useParsed.svelte';
 import { useList } from './query-hooks.svelte';
 import { readURLState, writeURLState } from './url-sync';
 import type { Pagination, Sort, Filter, BaseRecord, HttpError, KnownResources, GetListResult } from './types';
-import type { UseListOptions } from './query-hooks.svelte';
+import type { UseListOptions, MaybeGetter } from './query-hooks.svelte';
 
 export type FilterSetMode = 'merge' | 'replace';
 
@@ -27,24 +27,27 @@ export function useTable<
   TQueryFnData extends BaseRecord = BaseRecord,
   TError = HttpError,
   TSearchVariables = Record<string, unknown>
->(options: UseTableOptions<TQueryFnData, TError, TSearchVariables> = {}) {
+>(optionsOrGetter: MaybeGetter<UseTableOptions<TQueryFnData, TError, TSearchVariables>> = {}) {
+  const getOptions = () => typeof optionsOrGetter === 'function' ? optionsOrGetter() : optionsOrGetter;
   const parsed = useParsed();
-  const resource = options.resource ?? parsed.resource ?? '';
-  const { meta, syncWithLocation = false, dataProviderName, pagination: _p, sorters: _s, filters: _f, ...restOptions } = options;
   
-  const paginationMode = options.pagination?.mode ?? 'server';
-  const sortersMode = options.sorters?.mode ?? 'server';
-  const filtersMode = options.filters?.mode ?? 'server';
-  const filterDefaultBehavior = options.filters?.defaultBehavior ?? 'replace';
+  // Use a local derived to compute these since they are used to initialize state
+  // Even if options change, init values are only used once, which makes sense for initial state
+  const initialOpts = getOptions();
+  
+  const paginationMode = $derived(getOptions().pagination?.mode ?? 'server');
+  const sortersMode = $derived(getOptions().sorters?.mode ?? 'server');
+  const filtersMode = $derived(getOptions().filters?.mode ?? 'server');
+  const filterDefaultBehavior = $derived(getOptions().filters?.defaultBehavior ?? 'replace');
 
-  const permanentSorters = options.sorters?.permanent ?? [];
-  const permanentFilters = options.filters?.permanent ?? [];
+  const permanentSorters = $derived(getOptions().sorters?.permanent ?? []);
+  const permanentFilters = $derived(getOptions().filters?.permanent ?? []);
 
-  let initPagination = options.pagination ?? { current: 1, pageSize: 10 };
-  let initSorters = options.sorters?.initial ?? [];
-  let initFilters = options.filters?.initial ?? [];
+  let initPagination = initialOpts.pagination ?? { current: 1, pageSize: 10 };
+  let initSorters = initialOpts.sorters?.initial ?? [];
+  let initFilters = initialOpts.filters?.initial ?? [];
 
-  if (syncWithLocation && typeof window !== 'undefined') {
+  if (initialOpts.syncWithLocation && typeof window !== 'undefined') {
     const urlState = readURLState();
     if (urlState.page || urlState.pageSize) {
       initPagination = {
@@ -73,14 +76,18 @@ export function useTable<
     ? pagination
     : { current: 1, pageSize: 999999, mode: paginationMode as 'client' | 'off' });
 
-  const tableQueryInfo = useList<TQueryFnData, TError>({
-    resource,
-    get pagination() { return queryPagination; },
-    get sorters() { return querySorters; },
-    get filters() { return queryFilters; },
-    meta,
-    dataProviderName,
-    ...restOptions
+  const tableQueryInfo = useList<TQueryFnData, TError>(() => {
+    const currentOpts = getOptions();
+    const { meta, syncWithLocation, dataProviderName, pagination: _p, sorters: _s, filters: _f, ...restOptions } = currentOpts;
+    return {
+      resource: currentOpts.resource ?? parsed.resource ?? '',
+      pagination: queryPagination,
+      sorters: querySorters,
+      filters: queryFilters,
+      meta,
+      dataProviderName,
+      ...restOptions
+    };
   });
 
   const query = tableQueryInfo;
@@ -110,7 +117,7 @@ export function useTable<
   function setPage(page: number) { pagination = { ...pagination, current: page }; }
   function setPageSize(size: number) { pagination = { ...pagination, pageSize: size, current: 1 }; }
 
-  if (syncWithLocation && typeof window !== 'undefined') {
+  if (initialOpts.syncWithLocation && typeof window !== 'undefined') {
     $effect(() => {
       writeURLState({
         page: pagination.current,

package/src/theme.svelte.ts

@@ -5,7 +5,7 @@
 //   - 'dark-first': adds 'light' class for light mode (dark-first)
 
 export type ThemeMode = 'light' | 'dark' | 'system';
-export type ColorTheme = 'blue' | 'green' | 'rose' | 'orange' | 'violet' | 'zinc';
+export type ColorTheme = 'blue' | 'green' | 'rose' | 'orange' | 'violet' | 'neutral';
 
 /** Controls how the theme class is applied to <html> */
 export type ThemeStrategy = 'standard' | 'dark-first';

package/src/useCan.ts

@@ -1,7 +1,7 @@
 // useCan — reactive permission check hook with TanStack Query integration
 
 import { createQuery } from '@tanstack/svelte-query';
-import { canAccessAsync } from './permissions';
+import { canAccessAsync, getAccessControlProvider } from './permissions';
 import type { Action, CanResult } from './permissions';
 
 export interface UseCanOptions {
@@ -42,7 +42,11 @@ export function useCan(options: () => UseCanOptions): UseCanResult {
   });
 
   return {
-    get allowed() { return (query.data as CanResult | undefined)?.can ?? true; },
+    get allowed() { 
+      const p = getAccessControlProvider();
+      if (!p) return true;
+      return (query.data as CanResult | undefined)?.can ?? false; 
+    },
     get reason() { return (query.data as CanResult | undefined)?.reason; },
     get isLoading() { return query.isLoading; },
   };

package/src/useParsed.svelte.ts

@@ -5,6 +5,7 @@ import { getResources } from './context.svelte';
 
 interface ParsedRoute {
   resource?: string;
+  resourcePath?: string;
   action?: 'list' | 'create' | 'edit' | 'show' | 'clone';
   id?: string;
   params: Record<string, string>;
@@ -60,6 +61,7 @@ export function useParsed(): ParsedRoute {
 
     if (resourceIndex !== -1) {
       result.resource = segments[resourceIndex];
+      result.resourcePath = segments.slice(0, resourceIndex + 1).join('/');
 
       // Add parent path params based on `<parentResource>/<parentId>` structure
       for (let i = 0; i < resourceIndex; i += 2) {
@@ -92,6 +94,7 @@ export function useParsed(): ParsedRoute {
     } else {
       // Fallback if resource definitions are not loaded yet
       result.resource = segments[0];
+      result.resourcePath = segments[0];
 
       if (segments.length === 1) {
         result.action = 'list';
@@ -117,6 +120,7 @@ export function useParsed(): ParsedRoute {
 
   return {
     get resource() { return parsed.resource; },
+    get resourcePath() { return parsed.resourcePath; },
     get action() { return parsed.action; },
     get id() { return parsed.id; },
     get params() { return parsed.params; },

package/src/useStepsForm.svelte.ts

@@ -7,6 +7,8 @@ export interface UseStepsFormOptions<
   TData extends BaseRecord = BaseRecord,
   TError = HttpError,
 > extends UseFormOptions<TVariables, TData, TError> {
+  /** Total number of steps. Defaults to 1 */
+  stepsCount?: number;
   /** Default step index. Starts at 0. */
   defaultStep?: number;
   /** Validate the form when navigating back? */
@@ -17,15 +19,20 @@ export interface UseStepsFormReturn<
   TVariables extends Record<string, unknown> = Record<string, unknown>,
   TData extends BaseRecord = BaseRecord,
 > extends UseFormReturn<TVariables, TData> {
-  currentStep: number;
-  gotoStep: (step: number) => void;
-  next: () => void;
-  prev: () => void;
+  steps: {
+    currentStep: number;
+    totalSteps: number;
+    canGoNext: boolean;
+    canGoPrev: boolean;
+    gotoStep: (step: number) => void;
+    nextStep: () => void;
+    prevStep: () => void;
+  };
 }
 
 /**
  * useStepsForm
- * Extends `useForm` with step navigation state (currentStep, next, prev, gotoStep).
+ * Extends `useForm` with a nested `steps` object tracking navigation state.
  */
 export function useStepsForm<
   TVariables extends Record<string, unknown> = Record<string, unknown>,
@@ -35,33 +42,36 @@ export function useStepsForm<
   const form = useForm<TVariables, TData, TError>(options);
 
   let currentStep = $state(options.defaultStep ?? 0);
+  const totalSteps = options.stepsCount ?? 1;
 
   function gotoStep(step: number) {
-    currentStep = Math.max(0, step);
+    currentStep = Math.max(0, Math.min(step, totalSteps - 1));
   }
 
-  function next() {
-    gotoStep(currentStep + 1);
+  function nextStep() {
+    if (currentStep < totalSteps - 1) gotoStep(currentStep + 1);
   }
 
-  function prev() {
-    if (currentStep > 0) {
-      gotoStep(currentStep - 1);
-    }
+  function prevStep() {
+    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 UseStepsFormReturn<TVariables, TData>;
 
-  Object.defineProperty(result, 'currentStep', {
-    get: () => currentStep,
-    enumerable: true,
-    configurable: true
-  });
+  const steps = {
+    get currentStep() { return currentStep; },
+    get totalSteps() { return totalSteps; },
+    get canGoNext() { return currentStep < totalSteps - 1; },
+    get canGoPrev() { return currentStep > 0; },
+    gotoStep,
+    nextStep,
+    prevStep,
+  };
 
-  result.gotoStep = gotoStep;
-  result.next = next;
-  result.prev = prev;
+  Object.defineProperty(result, 'steps', {
+    get: () => steps,
+    enumerable: true
+  });
 
   return result;
 }