@svadmin/core 0.3.0 → 0.5.0

package/src/permissions.ts

@@ -1,42 +1,129 @@
 // Permission / Access Control
 
+// ─── Types ────────────────────────────────────────────────────
 
-export type Action = 'list' | 'create' | 'edit' | 'delete' | 'export';
+/** Actions that can be checked for access control. Extensible via string literal union. */
+export type Action = 'list' | 'show' | 'create' | 'edit' | 'delete' | 'export' | 'field' | (string & {});
 
-export interface AccessControlResult {
+export interface CanParams {
+  resource: string;
+  action: Action;
+  params?: { id?: string | number; [key: string]: unknown };
+}
+
+export interface CanResult {
   can: boolean;
   reason?: string;
 }
 
+/** @deprecated Use `CanResult` instead */
+export type AccessControlResult = CanResult;
+
+/**
+ * Formal Access Control Provider interface.
+ * Implement this to define your authorization logic.
+ *
+ * @example
+ * ```ts
+ * const accessControlProvider: AccessControlProvider = {
+ *   can: async ({ resource, action, params }) => {
+ *     if (resource === 'users' && action === 'delete') {
+ *       return { can: false, reason: 'Cannot delete users' };
+ *     }
+ *     return { can: true };
+ *   },
+ *   options: {
+ *     buttons: { enableAccessControl: true, hideIfUnauthorized: false },
+ *   },
+ * };
+ * ```
+ */
+export interface AccessControlProvider {
+  can: (params: CanParams) => Promise<CanResult>;
+  options?: {
+    buttons?: {
+      /** Enable access control checks on CRUD buttons globally. Default: false */
+      enableAccessControl?: boolean;
+      /** Hide buttons when unauthorized instead of disabling. Default: false */
+      hideIfUnauthorized?: boolean;
+    };
+  };
+}
+
+/** @deprecated Use `AccessControlProvider['can']` instead */
 export type AccessControlFn = (
   resource: string,
   action: Action,
   params?: Record<string, unknown>,
-) => AccessControlResult | Promise<AccessControlResult>;
+) => CanResult | Promise<CanResult>;
+
+// ─── State ────────────────────────────────────────────────────
 
-let accessControlFn: AccessControlFn | null = null;
+let provider: AccessControlProvider | null = null;
+let legacyFn: AccessControlFn | null = null;
 
+// ─── API ──────────────────────────────────────────────────────
+
+/**
+ * Register an AccessControlProvider.
+ */
+export function setAccessControlProvider(p: AccessControlProvider): void {
+  provider = p;
+  legacyFn = null;
+}
+
+/**
+ * @deprecated Use `setAccessControlProvider()` with full `AccessControlProvider` interface.
+ * Legacy API preserved for backward compatibility.
+ */
 export function setAccessControl(fn: AccessControlFn): void {
-  accessControlFn = fn;
+  legacyFn = fn;
+  provider = {
+    can: async ({ resource, action, params }) => {
+      const result = fn(resource, action, params);
+      return result instanceof Promise ? result : Promise.resolve(result);
+    },
+  };
 }
 
-export function canAccess(resource: string, action: Action, params?: Record<string, unknown>): AccessControlResult {
-  if (!accessControlFn) return { can: true };
-  const result = accessControlFn(resource, action, params);
-  if (result instanceof Promise) {
-    console.warn('[permissions] canAccess called synchronously but accessControlFn returned a Promise. Defaulting to { can: true }. Use canAccessAsync() instead.');
-    return { can: true };
-  }
-  return result;
+/** Get the current AccessControlProvider (or null) */
+export function getAccessControlProvider(): AccessControlProvider | null {
+  return provider;
 }
 
-export async function canAccessAsync(resource: string, action: Action, params?: Record<string, unknown>): Promise<AccessControlResult> {
-  if (!accessControlFn) return { can: true };
-  return accessControlFn(resource, action, params);
+/** Get global button options from the AccessControlProvider */
+export function getAccessControlOptions() {
+  return provider?.options ?? {};
 }
 
-// Example usage:
-// setAccessControl((resource, action) => {
-//   if (resource === 'users' && action === 'delete') return { can: false, reason: '无权删除用户' };
-//   return { can: true };
-// });
+/**
+ * Synchronous access check. Returns `{ can: true }` if no provider/fn is set.
+ * When a legacy sync fn is registered via `setAccessControl()`, this calls it synchronously.
+ * When only a provider is registered, this warns if provider.can() returns a Promise.
+ */
+export function canAccess(resource: string, action: Action, params?: Record<string, unknown>): CanResult {
+  // Fast path: use legacy sync fn if available
+  if (legacyFn) {
+    const result = legacyFn(resource, action, params);
+    if (result instanceof Promise) {
+      console.warn('[permissions] canAccess called synchronously but accessControlFn returned a Promise. Defaulting to { can: true }. Use canAccessAsync() instead.');
+      return { can: true };
+    }
+    return result;
+  }
+  if (!provider) return { can: true };
+  // Provider path (always async) — warn
+  console.warn('[permissions] canAccess called synchronously but provider.can() returned a Promise. Defaulting to { can: true }. Use canAccessAsync() instead.');
+  return { can: true };
+}
+
+/**
+ * Async access check. Preferred over `canAccess()`.
+ */
+export async function canAccessAsync(resource: string, action: Action, params?: Record<string, unknown>): Promise<CanResult> {
+  if (legacyFn) {
+    return legacyFn(resource, action, params);
+  }
+  if (!provider) return { can: true };
+  return provider.can({ resource, action, params });
+}

package/src/query-hooks.svelte.ts

@@ -1,6 +1,6 @@
 import { createQuery, createInfiniteQuery } from '@tanstack/svelte-query';
 import { getAdminOptions } from './options';
-import { getDataProviderForResource, getDataProvider } from './context';
+import { getDataProviderForResource, getDataProvider, getLiveProvider } from './context.svelte';
 import { useParsed } from './useParsed';
 import {
   createOvertimeTracker,
@@ -64,7 +64,7 @@ export function useList<TData extends BaseRecord = BaseRecord, TError = HttpErro
 
   createLiveSubscription({
     resource,
-    liveProvider: (globalThis as any).__svadminLiveProvider, // Handle via context ideally, or skip if not needed. Wait, in live.ts we pass liveProvider. Let's fix this in hook-utils.
+    liveProvider: getLiveProvider(),
     liveMode: options.liveMode ?? adminOptions.liveMode,
     onLiveEvent: (e) => {
       options.onLiveEvent?.(e);

package/src/routing-hooks.svelte.ts

@@ -1,5 +1,5 @@
 import { currentPath, navigate } from './router';
-import { getResource, getResources, getRouterProvider } from './context';
+import { getResource, getResources, getRouterProvider } from './context.svelte';
 import { useParsed } from './useParsed';
 
 // ─── routing-hooks.svelte.ts ───────────────────────────────────

package/src/table-hooks.svelte.ts

@@ -1,7 +1,7 @@
 import { useParsed } from './useParsed';
 import { useList } from './query-hooks.svelte';
 import { readURLState, writeURLState } from './url-sync';
-import type { Pagination, Sort, Filter, BaseRecord, HttpError, KnownResources } from './types';
+import type { Pagination, Sort, Filter, BaseRecord, HttpError, KnownResources, GetListResult } from './types';
 import type { UseListOptions } from './query-hooks.svelte';
 
 export type FilterSetMode = 'merge' | 'replace';
@@ -148,15 +148,15 @@ export function useTable<
     createLinkForSyncWithLocation,
     get totalPages() {
       // ts-expect-error reactive access
-      const total = (query as any).data?.total ?? 0;
+      const total = (query.data as GetListResult<TQueryFnData> | undefined)?.total ?? 0;
       return Math.ceil(total / (pagination.pageSize ?? 10));
     },
     get current() { return pagination.current ?? 1; },
     get pageSize() { return pagination.pageSize ?? 10; },
-    get pageCount() { return Math.ceil(((query as any).data?.total ?? 0) / (pagination.pageSize ?? 10)); },
+    get pageCount() { return Math.ceil(((query.data as GetListResult<TQueryFnData> | undefined)?.total ?? 0) / (pagination.pageSize ?? 10)); },
     get clientData(): TQueryFnData[] {
       if (paginationMode !== 'client') return [];
-      const allData = ((query as any).data?.data ?? []) as TQueryFnData[];
+      const allData = ((query.data as GetListResult<TQueryFnData> | undefined)?.data ?? []) as TQueryFnData[];
       const start = ((pagination.current ?? 1) - 1) * (pagination.pageSize ?? 10);
       const end = start + (pagination.pageSize ?? 10);
       let sorted = [...allData];

package/src/table-state.svelte.ts

@@ -0,0 +1,243 @@
+// TableState — Svelte 5 Class State Pattern for table data management
+// Reactive class that encapsulates all table state with fine-grained $state/$derived
+
+import { useParsed } from './useParsed';
+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';
+
+export type FilterSetMode = 'merge' | 'replace';
+
+export interface TableStateOptions<TData extends BaseRecord = BaseRecord, TError = HttpError>
+  extends Omit<UseListOptions<TData, TError>, 'pagination' | 'sorters' | 'filters'> {
+  resource?: KnownResources;
+  pagination?: Pagination;
+  sorters?: {
+    initial?: Sort[];
+    permanent?: Sort[];
+    mode?: 'off' | 'server';
+  };
+  filters?: {
+    initial?: Filter[];
+    permanent?: Filter[];
+    mode?: 'off' | 'server';
+    defaultBehavior?: FilterSetMode;
+  };
+  syncWithLocation?: boolean;
+}
+
+/**
+ * Svelte 5 Class-based reactive table state.
+ *
+ * Usage:
+ * ```ts
+ * const table = new TableState({ resource: 'posts' });
+ * table.setPage(2);
+ * table.toggleSort('title');
+ * console.log(table.data); // reactive
+ * ```
+ */
+export class TableState<TData extends BaseRecord = BaseRecord, TError = HttpError> {
+  // ─── Reactive state ───────────────────────────────────────────
+  pagination = $state<Pagination>({ current: 1, pageSize: 10 });
+  currentSorters = $state<Sort[]>([]);
+  currentFilters = $state<Filter[]>([]);
+
+  // ─── Private config ───────────────────────────────────────────
+  private permanentSorters: Sort[];
+  private permanentFilters: Filter[];
+  private sortersMode: 'off' | 'server';
+  private filtersMode: 'off' | 'server';
+  private filterDefaultBehavior: FilterSetMode;
+  private syncWithLocation: boolean;
+  private paginationMode: string;
+
+  // ─── Query result ─────────────────────────────────────────────
+  private _queryResult;
+
+  constructor(options: TableStateOptions<TData, TError> = {}) {
+    const parsed = useParsed();
+    const resource = options.resource ?? parsed.resource ?? '';
+
+    this.permanentSorters = options.sorters?.permanent ?? [];
+    this.permanentFilters = options.filters?.permanent ?? [];
+    this.sortersMode = options.sorters?.mode ?? 'server';
+    this.filtersMode = options.filters?.mode ?? 'server';
+    this.filterDefaultBehavior = options.filters?.defaultBehavior ?? 'replace';
+    this.syncWithLocation = options.syncWithLocation ?? false;
+    this.paginationMode = options.pagination?.mode ?? 'server';
+
+    // Init from URL or defaults
+    let initPagination = options.pagination ?? { current: 1, pageSize: 10 };
+    let initSorters = options.sorters?.initial ?? [];
+    let initFilters = options.filters?.initial ?? [];
+
+    if (this.syncWithLocation && typeof window !== 'undefined') {
+      const urlState = readURLState();
+      if (urlState.page || urlState.pageSize) {
+        initPagination = {
+          current: urlState.page ?? initPagination.current,
+          pageSize: urlState.pageSize ?? initPagination.pageSize,
+        };
+      }
+      if (urlState.sortField) {
+        initSorters = [{ field: urlState.sortField, order: (urlState.sortOrder as 'asc' | 'desc') ?? 'asc' }];
+      }
+      if (urlState.filters) {
+        initFilters = urlState.filters;
+      }
+    }
+
+    this.pagination = initPagination;
+    this.currentSorters = initSorters;
+    this.currentFilters = initFilters;
+
+    // Create query
+    const { meta, syncWithLocation: _s, dataProviderName, pagination: _p, sorters: _sr, filters: _f, ...restOptions } = options;
+    this._queryResult = useList<TData, TError>({
+      resource,
+      pagination: this.queryPagination,
+      sorters: this.effectiveSorters,
+      filters: this.effectiveFilters,
+      meta,
+      dataProviderName,
+      ...restOptions,
+    });
+
+    // URL sync effect
+    if (this.syncWithLocation && typeof window !== 'undefined') {
+      $effect(() => {
+        writeURLState({
+          page: this.pagination.current,
+          pageSize: this.pagination.pageSize,
+          sortField: this.effectiveSorters[0]?.field,
+          sortOrder: this.effectiveSorters[0]?.order,
+          filters: this.effectiveFilters,
+        });
+      });
+    }
+  }
+
+  // ─── Derived state ────────────────────────────────────────────
+  get effectiveSorters() { return [...this.currentSorters, ...this.permanentSorters]; }
+  get effectiveFilters() { return [...this.currentFilters, ...this.permanentFilters]; }
+
+  private get queryPagination() {
+    return this.paginationMode === 'server'
+      ? this.pagination
+      : { current: 1, pageSize: 999999, mode: this.paginationMode as 'client' | 'off' };
+  }
+
+  /** Underlying TanStack Query result */
+  get query() { return this._queryResult.query; }
+
+  /** Table data rows */
+  get data(): TData[] { return (this.query.data as GetListResult<TData> | undefined)?.data ?? []; }
+
+  /** Total record count */
+  get total(): number { return (this.query.data as GetListResult<TData> | undefined)?.total ?? 0; }
+
+  /** Is data loading */
+  get isLoading(): boolean { return this.query.isLoading; }
+
+  /** Is data error */
+  get isError(): boolean { return this.query.isError; }
+
+  /** Error object */
+  get error(): TError | null { return this.query.error; }
+
+  /** Current page number */
+  get current(): number { return this.pagination.current ?? 1; }
+
+  /** Page size */
+  get pageSize(): number { return this.pagination.pageSize ?? 10; }
+
+  /** Total number of pages */
+  get pageCount(): number { return Math.ceil(this.total / this.pageSize); }
+
+  /** Has next page */
+  get hasNextPage(): boolean { return this.current < this.pageCount; }
+
+  /** Has previous page */
+  get hasPreviousPage(): boolean { return this.current > 1; }
+
+  // ─── Mutators ─────────────────────────────────────────────────
+  setPage(page: number) {
+    this.pagination = { ...this.pagination, current: page };
+  }
+
+  setPageSize(size: number) {
+    this.pagination = { ...this.pagination, pageSize: size, current: 1 };
+  }
+
+  nextPage() {
+    if (this.hasNextPage) this.setPage(this.current + 1);
+  }
+
+  previousPage() {
+    if (this.hasPreviousPage) this.setPage(this.current - 1);
+  }
+
+  setSorters(newSorters: Sort[]) {
+    this.currentSorters = newSorters;
+  }
+
+  toggleSort(field: string) {
+    const existing = this.currentSorters.find(s => s.field === field);
+    if (!existing) {
+      this.currentSorters = [{ field, order: 'asc' }];
+    } else if (existing.order === 'asc') {
+      this.currentSorters = [{ field, order: 'desc' }];
+    } else {
+      this.currentSorters = [];
+    }
+  }
+
+  setFilters(newFilters: Filter[], mode?: FilterSetMode) {
+    const behavior = mode ?? this.filterDefaultBehavior;
+    if (behavior === 'merge') {
+      const merged = [...this.currentFilters];
+      for (const nf of newFilters) {
+        const idx = merged.findIndex(f => f.field === nf.field && f.operator === nf.operator);
+        if (idx >= 0) {
+          if (nf.value === undefined || nf.value === null || nf.value === '') merged.splice(idx, 1);
+          else merged[idx] = nf;
+        } else if (nf.value !== undefined && nf.value !== null && nf.value !== '') {
+          merged.push(nf);
+        }
+      }
+      this.currentFilters = merged;
+    } else {
+      this.currentFilters = newFilters;
+    }
+    this.pagination = { ...this.pagination, current: 1 };
+  }
+
+  resetFilters() {
+    this.currentFilters = [];
+    this.pagination = { ...this.pagination, current: 1 };
+  }
+
+  /** For client-side pagination mode */
+  get clientData(): TData[] {
+    if (this.paginationMode !== 'client') return [];
+    const allData = this.data;
+    const start = (this.current - 1) * this.pageSize;
+    const end = start + this.pageSize;
+    let sorted = [...allData];
+    const activeSorters = this.sortersMode === 'off' ? this.effectiveSorters : this.currentSorters;
+    if (activeSorters.length > 0) {
+      const { field, order } = activeSorters[0];
+      sorted.sort((a, b) => {
+        const va = (a as Record<string, unknown>)[field];
+        const vb = (b as Record<string, unknown>)[field];
+        if (va == null) return 1;
+        if (vb == null) return -1;
+        const cmp = va < vb ? -1 : va > vb ? 1 : 0;
+        return order === 'desc' ? -cmp : cmp;
+      });
+    }
+    return sorted.slice(start, end);
+  }
+}

package/src/toast.svelte.ts

@@ -1,4 +1,7 @@
-// Toast notification system — Svelte 5 runes-based
+// Toast notification system — wraps svelte-sonner for consistent API
+// Maintains backward-compatible `toast.success()` / `toast.error()` etc.
+
+import { toast as sonner } from 'svelte-sonner';
 
 export type ToastType = 'success' | 'error' | 'info' | 'warning' | 'undoable';
 
@@ -11,6 +14,7 @@ export interface Toast {
   onTimeout?: () => void;
 }
 
+// Legacy compatibility — kept for existing consumers
 let nextId = 0;
 let toasts = $state<Toast[]>([]);
 
@@ -19,23 +23,35 @@ export function getToasts(): Toast[] {
 }
 
 export function addToast(type: ToastType, message: string, duration = 3000, options?: { onUndo?: () => void, onTimeout?: () => void }): void {
+  // Use svelte-sonner for regular toasts
+  if (type !== 'undoable') {
+    switch (type) {
+      case 'success': sonner.success(message, { duration }); break;
+      case 'error': sonner.error(message, { duration }); break;
+      case 'warning': sonner.warning(message, { duration }); break;
+      case 'info': sonner.info(message, { duration }); break;
+    }
+    return;
+  }
+
+  // Undoable toasts still use custom system
   const id = nextId++;
   toasts = [...toasts, { id, type, message, duration, ...options }];
-  if (duration > 0 && type !== 'undoable') {
-    setTimeout(() => removeToast(id), duration);
-  }
 }
 
 export function removeToast(id: number): void {
   toasts = toasts.filter(t => t.id !== id);
 }
 
-// Convenience methods
+// Convenience methods — backward compatible
 export const toast = {
   success: (msg: string, duration?: number) => addToast('success', msg, duration),
   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) => 
+  undoable: (msg: string, duration: number, onUndo: () => void, onTimeout: () => void) =>
     addToast('undoable', msg, duration, { onUndo, onTimeout }),
+  /** Promise toast — shows loading → success/error automatically */
+  promise: <T>(promise: Promise<T>, opts: { loading: string; success: string; error: string }) =>
+    sonner.promise(promise, opts),
 };

package/src/types.ts

@@ -255,6 +255,8 @@ export interface ResourceDefinition {
   showInMenu?: boolean;
   parentName?: string;
   menuOrder?: number;
+  /** Navigation group name — resources with the same group are displayed in a collapsible section */
+  group?: string;
   meta?: Record<string, unknown> & { dataProviderName?: string; parent?: string };
 }
 
@@ -266,6 +268,7 @@ export interface FieldDefinition {
   required?: boolean;
   searchable?: boolean;
   sortable?: boolean;
+  filterable?: boolean;
   width?: string;
   showInList?: boolean;
   showInForm?: boolean;
@@ -280,6 +283,8 @@ export interface FieldDefinition {
   optionValue?: string;    // field to use as value
   // Validation
   validate?: (value: unknown) => string | null;
+  // Grouping
+  group?: string;
 }
 
 // ─── Resource Type Registry ───────────────────────────────────

package/src/unsaved-changes.svelte.ts

@@ -1,7 +1,7 @@
 // UnsavedChangesNotifier — warns user before leaving page with unsaved changes
 // Svelte 5 component using runes
 
-import { onDestroy, onMount } from 'svelte';
+// No lifecycle imports needed — uses module-level $state pattern
 
 let warnWhenUnsavedChanges = $state(false);
 

package/src/useCan.ts

@@ -1,37 +1,54 @@
-// useCan — reactive permission check hook
+// useCan — reactive permission check hook with TanStack Query integration
 
+import { createQuery } from '@tanstack/svelte-query';
 import { canAccessAsync } from './permissions';
-import type { Action, AccessControlResult } from './permissions';
+import type { Action, CanResult } from './permissions';
 
-interface UseCanResult {
-  allowed: boolean;
-  reason?: string;
-  isLoading: boolean;
+export interface UseCanOptions {
+  resource: string;
+  action: Action;
+  params?: Record<string, unknown>;
+  queryOptions?: {
+    enabled?: boolean;
+    staleTime?: number;
+  };
+}
+
+export interface UseCanResult {
+  readonly allowed: boolean;
+  readonly reason: string | undefined;
+  readonly isLoading: boolean;
 }
 
 /**
- * Reactive permission check. Calls canAccessAsync() and returns reactive state.
- * Usage: const can = useCan('posts', 'delete');
- *        if (can.allowed) { ... }
+ * Reactive permission check backed by TanStack Query for caching and deduplication.
+ *
+ * @example
+ * ```ts
+ * // Simple usage (backward compatible)
+ * const can = useCan('posts', 'delete');
+ * if (can.allowed) { ... }
+ *
+ * // With options object
+ * const can = useCan({ resource: 'posts', action: 'delete', params: { id: 1 } });
+ * ```
  */
-export function useCan(resource: string, action: Action, params?: Record<string, unknown>): UseCanResult {
-  let allowed = $state(true);
-  let reason = $state<string | undefined>(undefined);
-  let isLoading = $state(true);
+export function useCan(resourceOrOptions: string | UseCanOptions, action?: Action, params?: Record<string, unknown>): UseCanResult {
+  // Normalize arguments: support both (resource, action, params) and (options) signatures
+  const options: UseCanOptions = typeof resourceOrOptions === 'string'
+    ? { resource: resourceOrOptions, action: action ?? 'list', params }
+    : resourceOrOptions;
 
-  // Run the async check
-  canAccessAsync(resource, action, params).then((result: AccessControlResult) => {
-    allowed = result.can;
-    reason = result.reason;
-    isLoading = false;
-  }).catch(() => {
-    allowed = true; // default to allowed on error
-    isLoading = false;
-  });
+  const query = createQuery<CanResult>(() => ({
+    queryKey: ['useCan', options.resource, options.action, options.params],
+    queryFn: () => canAccessAsync(options.resource, options.action, options.params),
+    enabled: options.queryOptions?.enabled ?? true,
+    staleTime: options.queryOptions?.staleTime ?? 5 * 60 * 1000, // 5 min default cache
+  }));
 
   return {
-    get allowed() { return allowed; },
-    get reason() { return reason; },
-    get isLoading() { return isLoading; },
+    get allowed() { return query.data?.can ?? true; },
+    get reason() { return query.data?.reason; },
+    get isLoading() { return query.isLoading; },
   };
 }

package/src/useParsed.ts

@@ -1,7 +1,7 @@
 // useParsed — parse current URL hash into structured route info
 
 import { currentPath } from './router';
-import { getResources } from './context';
+import { getResources } from './context.svelte';
 
 interface ParsedRoute {
   resource?: string;

package/src/useStepsForm.svelte.ts

@@ -35,7 +35,7 @@ export function useStepsForm<
   TError = HttpError,
   TVariables = Record<string, unknown>,
   TData extends BaseRecord = TQueryFnData
->(options: UseStepsFormOptions<TQueryFnData, TError, TVariables, TData> = {} as any): UseStepsFormResult<TQueryFnData, TError, TVariables, TData> {
+>(options: UseStepsFormOptions<TQueryFnData, TError, TVariables, TData> = {} as UseStepsFormOptions<TQueryFnData, TError, TVariables, TData>): UseStepsFormResult<TQueryFnData, TError, TVariables, TData> {
   const form = useForm<TQueryFnData, TError, TVariables, TData>(options);
   
   let currentStep = $state(options.defaultStep ?? 0);

package/src/utility-hooks.svelte.ts

@@ -1,7 +1,7 @@
 import { useForm, type UseFormOptions } from './form-hooks.svelte';
 import { useQueryClient } from '@tanstack/svelte-query';
 import { useParsed } from './useParsed';
-import { getResource, getResources } from './context';
+import { getResource, getResources } from './context.svelte';
 import { getAdminOptions } from './options';
 import { navigate } from './router';
 import { t } from './i18n.svelte';