@svadmin/core 0.17.0 → 0.18.0

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@svadmin/core",
-  "version": "0.17.0",
-  "description": "Core SDK — hooks, types, context, i18n, permissions, router",
-  "type": "module",
-  "sideEffects": false,
-  "files": [
-    "src/**/*"
-  ],
+  "version": "0.18.0",
+  "author": "zuohuadong",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zuohuadong/svadmin.git",
+    "directory": "packages/core"
+  },
   "main": "src/index.ts",
-  "types": "src/index.ts",
+  "devDependencies": {
+    "@types/bun": "^1.3.11"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0",
+    "@tanstack/svelte-query": "^6.0.0"
+  },
   "exports": {
     ".": {
       "types": "./src/index.ts",
@@ -43,25 +49,19 @@
       "default": "./src/theme.svelte.ts"
     }
   },
-  "peerDependencies": {
-    "svelte": "^5.0.0",
-    "@tanstack/svelte-query": "^6.0.0"
-  },
-  "license": "MIT",
-  "author": "zuohuadong",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/zuohuadong/svadmin.git",
-    "directory": "packages/core"
-  },
-  "homepage": "https://github.com/zuohuadong/svadmin#readme",
   "bugs": {
     "url": "https://github.com/zuohuadong/svadmin/issues"
   },
-  "devDependencies": {
-    "@types/bun": "^1.3.11"
-  },
+  "description": "Core SDK — hooks, types, context, i18n, permissions, router",
+  "files": [
+    "src/**/*"
+  ],
+  "homepage": "https://github.com/zuohuadong/svadmin#readme",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "types": "src/index.ts",
   "dependencies": {
-    "svelte-sonner": "^1.1.0"
+    "sonner-svelte": "^0.3.3"
   }
 }

package/src/README.md

@@ -0,0 +1,18 @@
+# Name
+### {{module_name}}
+
+# Synopsis
+{{synopsis}}
+
+# Description
+
+# Example
+
+# Install:
+`npm install {{module_name}}`
+
+# Test:
+`npm test`
+
+#License:
+{{license}}

package/src/auth-hooks.svelte.ts

@@ -266,17 +266,28 @@ export function useOnError() {
 
 /**
  * Fetches permissions from authProvider.getPermissions().
- * Returns a reactive object with data, isLoading, and error.
+ * Returns a reactive integrated object.
+ * 
+ * @example
+ * ```svelte
+ * <script>
+ *   import { usePermissions } from '@svadmin/core';
+ *   const perms = usePermissions();
+ *   const canAdmin = $derived(perms.has('admin'));
+ * </script>
+ * ```
  */
 export function usePermissions<T = unknown>() {
   const provider = getAuthProvider();
-  let data = $state<T | null>(null);
+  let permissions = $state<T | null>(null);
   let isLoading = $state(true);
   let error = $state<Error | null>(null);
+  let version = $state(0); // Force reactive invalidation
 
   if (provider?.getPermissions) {
-    provider.getPermissions().then(permissions => {
-      data = permissions as T;
+    provider.getPermissions().then(p => {
+      permissions = p as T;
+      version++;
       isLoading = false;
     }).catch(err => {
       error = err instanceof Error ? err : new Error(String(err));
@@ -288,66 +299,28 @@ export function usePermissions<T = unknown>() {
   }
 
   return {
-    get data() { return data; },
     get isLoading() { return isLoading; },
     get error() { return error; },
+    get version() { return version; },
+    
+    /** Get the raw permissions data */
+    get raw() { return permissions; },
+
+    /** Convenience: check if a specific permission 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;
+    },
+
+    /** Convenience: check resource action (Casbin style representation if applicable) */
+    can(resource: string, action: string): boolean {
+      // Tries to map to a standard permission string format like "resource:action" 
+      // Replace with your own logic if your permissions are structured differently.
+      return this.has(`${resource}:${action}`);
+    }
   };
 }
 
-// ─── useHasPermission ────────────────────────────────────────
-
-/**
- * Reactive permission checker — returns a closure that re-evaluates
- * when the underlying permissions data changes.
- *
- * Works with Casbin-style permission arrays, Sets, or permission objects.
- * The returned function is safe to use inside `$derived()` for reactive UI updates.
- *
- * @example
- * ```svelte
- * <script>
- *   import { useHasPermission } from '@svadmin/core';
- *
- *   const hasPermission = useHasPermission();
- *   // ✅ Reactive — UI updates when permissions finish loading
- *   const canDelete = $derived(hasPermission('admin'));
- *   const canExport = $derived(hasPermission('data:export'));
- * </script>
- *
- * {#if canDelete}
- *   <Button variant="destructive">Delete</Button>
- * {/if}
- * ```
- */
-export function useHasPermission() {
-  const provider = getAuthProvider();
-  let permissions = $state<unknown>(null);
-  let loaded = $state(false);
-
-  if (provider?.getPermissions) {
-    provider.getPermissions().then(p => {
-      permissions = p;
-      loaded = true;
-    }).catch(err => {
-      console.warn('[svadmin] useHasPermission: getPermissions failed', err);
-      loaded = true;
-    });
-  } else {
-    loaded = true;
-  }
-
-  /**
-   * Check if the current user has a specific permission.
-   * Supports: `string[]`, `Set<string>`, `Record<string, boolean>`, or any object with `.includes` / `.has`.
-   */
-  function hasPermission(perm: string): boolean {
-    if (!loaded || permissions == null) 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 hasPermission;
-}
-

package/src/index.ts

@@ -78,7 +78,7 @@ export {
   useLogin, useLogout,
   useRegister, useForgotPassword, useUpdatePassword,
   useGetIdentity, useIsAuthenticated,
-  useOnError, usePermissions, useHasPermission,
+  useOnError, usePermissions,
 } from './auth-hooks.svelte';
 export { useParsed } from './useParsed.svelte';
 export * from './useStepsForm.svelte';

package/src/permissions.test.ts

@@ -27,7 +27,7 @@ describe('permissions', () => {
       can: async () => ({ can: true }),
     });
     const result = await canAccessAsync('posts', 'edit');
-    expect(result.can).toBe(true);
+    expect((result as any).can).toBe(true);
   });
 
   test('canAccessAsync resolves with denied status', async () => {
@@ -35,8 +35,8 @@ describe('permissions', () => {
       can: async () => ({ can: false, reason: 'No permission' }),
     });
     const result = await canAccessAsync('users', 'delete');
-    expect(result.can).toBe(false);
-    expect(result.reason).toBe('No permission');
+    expect((result as any).can).toBe(false);
+    expect((result as any).reason).toBe('No permission');
   });
 
   test('resource-specific rules', async () => {
@@ -89,8 +89,8 @@ describe('AccessControlProvider', () => {
       },
     });
     const result = await canAccessAsync('posts', 'edit', { id: 42 });
-    expect(result.can).toBe(false);
-    expect(result.reason).toBe('Record locked');
+    expect((result as any).can).toBe(false);
+    expect((result as any).reason).toBe('Record locked');
   });
 
   test('extended action types work', async () => {

package/src/permissions.ts

@@ -38,7 +38,7 @@ export interface CanResult {
  * ```
  */
 export interface AccessControlProvider {
-  can: (params: CanParams) => Promise<CanResult>;
+  can: (params: CanParams | CanParams[]) => Promise<CanResult | CanResult[]>;
   options?: {
     buttons?: {
       /** Enable access control checks on CRUD buttons globally. Default: false */
@@ -73,9 +73,21 @@ export function getAccessControlOptions() {
 }
 
 /**
- * Async access check. Returns `{ can: true }` if no provider is registered.
+ * Async access check. 
+ * Supports both single capability requests or an array of batched checks.
  */
-export async function canAccessAsync(resource: string, action: Action, params?: Record<string, unknown>): Promise<CanResult> {
-  if (!provider) return { can: true };
-  return provider.can({ resource, action, params });
+export async function canAccessAsync(params: CanParams[]): Promise<CanResult[]>;
+export async function canAccessAsync(resource: string, action: Action, params?: Record<string, unknown>): Promise<CanResult>;
+export async function canAccessAsync(resourceOrBatch: string | CanParams[], action?: Action, params?: Record<string, unknown>): Promise<CanResult | CanResult[]> {
+  if (!provider) {
+    return Array.isArray(resourceOrBatch)
+      ? resourceOrBatch.map(() => ({ can: true }))
+      : { can: true };
+  }
+  
+  if (Array.isArray(resourceOrBatch)) {
+    return provider.can(resourceOrBatch);
+  }
+  
+  return provider.can({ resource: resourceOrBatch, action: action!, params }) as Promise<CanResult>;
 }

package/src/toast.svelte.ts

@@ -1,7 +1,7 @@
-// Toast notification system — wraps svelte-sonner for consistent API
+// Toast notification system — wraps sonner-svelte for consistent API
 // Maintains backward-compatible `toast.success()` / `toast.error()` etc.
 
-import { toast as sonner } from 'svelte-sonner';
+import { toast as sonner } from 'sonner-svelte';
 
 export type ToastType = 'success' | 'error' | 'info' | 'warning' | 'undoable';
 
@@ -23,7 +23,7 @@ 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
+  // Use sonner-svelte for regular toasts
   if (type !== 'undoable') {
     switch (type) {
       case 'success': sonner.success(message, { duration }); break;