@makolabs/ripple 1.2.4 → 1.2.9

package/dist/user-management/adapters/mockUserManagement.js

@@ -0,0 +1,187 @@
+/**
+ * Mock User Management Functions
+ *
+ * Mock implementation of user management functions for testing and development.
+ * These are regular async functions that match the UserManagementAdapter interface.
+ * They store data in memory.
+ *
+ * Note: This file uses .remote.ts extension for naming consistency, but these are
+ * NOT actual SvelteKit remote functions. They are regular async functions that
+ * work in both test and library contexts.
+ *
+ * For actual remote functions in your app, see UserManagement.remote.ts template.
+ *
+ * To set initial data, use the resetState function:
+ * ```ts
+ * import { resetState } from './mockUserManagement.js';
+ * await resetState({ initialUsers: [...], simulateDelay: false });
+ * ```
+ */
+// Internal module-level state
+let mockUsers = [];
+let simulateDelay = false;
+let delayMs = 300;
+async function delay() {
+    if (simulateDelay) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+}
+/**
+ * Reset mock adapter state
+ */
+export async function resetState(options = {}) {
+    mockUsers = options.initialUsers || [];
+    simulateDelay = options.simulateDelay ?? false;
+    delayMs = options.delayMs ?? 300;
+}
+/**
+ * Get users with pagination and sorting
+ * Matches UserManagementAdapter.getUsers signature
+ */
+export async function getUsers(options) {
+    await delay();
+    let filteredUsers = [...mockUsers];
+    // Apply search query if provided
+    if (options.query) {
+        const query = options.query.toLowerCase();
+        filteredUsers = filteredUsers.filter((user) => user.first_name?.toLowerCase().includes(query) ||
+            user.last_name?.toLowerCase().includes(query) ||
+            user.username?.toLowerCase().includes(query) ||
+            user.email_addresses?.[0]?.email_address?.toLowerCase().includes(query));
+    }
+    // Apply sorting
+    if (options.sortBy) {
+        filteredUsers.sort((a, b) => {
+            let aValue = '';
+            let bValue = '';
+            switch (options.sortBy) {
+                case 'first_name':
+                    aValue = a.first_name || '';
+                    bValue = b.first_name || '';
+                    break;
+                case 'last_name':
+                    aValue = a.last_name || '';
+                    bValue = b.last_name || '';
+                    break;
+                case 'email_address':
+                    aValue = a.email_addresses?.[0]?.email_address || '';
+                    bValue = b.email_addresses?.[0]?.email_address || '';
+                    break;
+                case 'created_at':
+                    aValue = a.created_at || 0;
+                    bValue = b.created_at || 0;
+                    break;
+                case 'last_sign_in_at':
+                    aValue = a.last_sign_in_at || 0;
+                    bValue = b.last_sign_in_at || 0;
+                    break;
+                default:
+                    return 0;
+            }
+            if (typeof aValue === 'string' && typeof bValue === 'string') {
+                return options.sortOrder === 'desc'
+                    ? bValue.localeCompare(aValue)
+                    : aValue.localeCompare(bValue);
+            }
+            else if (typeof aValue === 'number' && typeof bValue === 'number') {
+                return options.sortOrder === 'desc' ? bValue - aValue : aValue - bValue;
+            }
+            return 0;
+        });
+    }
+    // Apply pagination
+    const start = (options.page - 1) * options.pageSize;
+    const end = start + options.pageSize;
+    const paginatedUsers = filteredUsers.slice(start, end);
+    return {
+        users: paginatedUsers,
+        totalUsers: filteredUsers.length
+    };
+}
+/**
+ * Create a new user
+ * Matches UserManagementAdapter.createUser signature
+ */
+export async function createUser(userData) {
+    await delay();
+    const newUser = {
+        id: `user_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        first_name: userData.first_name || '',
+        last_name: userData.last_name || '',
+        username: userData.username,
+        email_addresses: userData.email_addresses || [{ email_address: '' }],
+        phone_numbers: userData.phone_numbers || [],
+        role: userData.role,
+        permissions: userData.permissions || [],
+        created_at: Date.now(),
+        ...userData
+    };
+    mockUsers.push(newUser);
+    return newUser;
+}
+/**
+ * Update an existing user
+ * Matches UserManagementAdapter.updateUser signature
+ */
+export async function updateUser(options) {
+    await delay();
+    const { userId, userData } = options;
+    const userIndex = mockUsers.findIndex((u) => u.id === userId);
+    if (userIndex === -1) {
+        throw new Error(`User with ID ${userId} not found`);
+    }
+    const updatedUser = {
+        ...mockUsers[userIndex],
+        ...userData,
+        id: userId // Ensure ID doesn't change
+    };
+    mockUsers[userIndex] = updatedUser;
+    return updatedUser;
+}
+/**
+ * Delete a single user
+ * Matches UserManagementAdapter.deleteUser signature
+ */
+export async function deleteUser(userId) {
+    await delay();
+    const userIndex = mockUsers.findIndex((u) => u.id === userId);
+    if (userIndex === -1) {
+        throw new Error(`User with ID ${userId} not found`);
+    }
+    mockUsers.splice(userIndex, 1);
+}
+/**
+ * Delete multiple users
+ * Matches UserManagementAdapter.deleteUsers signature
+ */
+export async function deleteUsers(userIds) {
+    await delay();
+    userIds.forEach((userId) => {
+        const userIndex = mockUsers.findIndex((u) => u.id === userId);
+        if (userIndex !== -1) {
+            mockUsers.splice(userIndex, 1);
+        }
+    });
+}
+/**
+ * Get permissions for a specific user
+ * Matches UserManagementAdapter.getUserPermissions signature
+ */
+export async function getUserPermissions(userId) {
+    await delay();
+    const user = mockUsers.find((u) => u.id === userId);
+    return user?.permissions || [];
+}
+/**
+ * Update permissions for a specific user
+ * Matches UserManagementAdapter.updateUserPermissions signature
+ */
+export async function updateUserPermissions(options) {
+    await delay();
+    const { userId, permissions } = options;
+    const user = mockUsers.find((u) => u.id === userId);
+    if (!user) {
+        throw new Error(`User with ID ${userId} not found`);
+    }
+    user.permissions = permissions;
+}

package/dist/user-management/adapters/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * User Management Adapter Types
+ *
+ * Shared types for user management adapters.
+ * These types are used by both remote function modules and the component.
+ */
+import type { User } from '../user-management.js';
+/**
+ * Options for fetching users
+ */
+export interface GetUsersOptions {
+    page: number;
+    pageSize: number;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+    query?: string;
+}
+/**
+ * Result of fetching users
+ */
+export interface GetUsersResult {
+    users: User[];
+    totalUsers: number;
+}

package/dist/user-management/adapters/types.js

@@ -0,0 +1,7 @@
+/**
+ * User Management Adapter Types
+ *
+ * Shared types for user management adapters.
+ * These types are used by both remote function modules and the component.
+ */
+export {};

package/dist/user-management/index.d.ts

@@ -7,4 +7,6 @@ export { default as UserTable } from './UserTable.svelte';
 export { default as UserModal } from './UserModal.svelte';
 export { default as UserViewModal } from './UserViewModal.svelte';
 export type { User, UserEmail, UserPhone, Permission, Role, UserTableProps, UserModalProps, UserViewModalProps, UserManagementProps, FormErrors } from './user-management.js';
+export type { GetUsersOptions, GetUsersResult } from './adapters/index.js';
+export type { UserManagementAdapter } from './user-management.js';
 export { createUser, getUserDisplayName, getUserInitials } from './user-management.js';

package/dist/user-management/user-management.d.ts

@@ -71,24 +71,51 @@ export interface UserViewModalProps {
     onClose: () => void;
     class?: ClassValue;
 }
+import type { GetUsersOptions, GetUsersResult } from './adapters/types.js';
+/**
+ * User Management Adapter Interface
+ *
+ * Defines the contract for user management adapters.
+ * Adapters can be remote function modules (returning RemoteQuery/RemoteCommand)
+ * or regular async function modules (returning Promise).
+ *
+ * Uses PromiseLike to accept both Promise and RemoteQuery/RemoteCommand types.
+ */
+export interface UserManagementAdapter {
+    getUsers: (options: GetUsersOptions) => PromiseLike<GetUsersResult>;
+    createUser: (userData: Partial<User>) => PromiseLike<User>;
+    updateUser: (options: {
+        userId: string;
+        userData: Partial<User>;
+    }) => PromiseLike<User>;
+    deleteUser: (userId: string) => PromiseLike<void>;
+    deleteUsers: (userIds: string[]) => PromiseLike<void>;
+    getUserPermissions: (userId: string) => PromiseLike<string[]>;
+    updateUserPermissions: (options: {
+        userId: string;
+        permissions: string[];
+    }) => PromiseLike<void>;
+}
 export interface UserManagementProps {
-    users: User[];
-    totalUsers: number;
-    loading?: boolean;
-    currentPage?: number;
-    pageSize?: number;
+    /**
+     * Adapter module containing remote functions or async functions
+     * Should be imported from a .remote.ts file
+     *
+     * Example:
+     * ```ts
+     * import * as adapter from './adapter.remote';
+     * <UserManagement adapter={adapter} roles={roles} />
+     * ```
+     */
+    adapter: UserManagementAdapter;
+    /**
+     * Available roles for user assignment
+     */
     roles?: Role[];
+    /**
+     * Available permissions for display (optional)
+     */
     permissions?: Permission[];
-    onPageChange: (page: number) => void;
-    onPageSizeChange: (size: number) => void;
-    onSort?: (state: {
-        column: string | null;
-        direction: 'asc' | 'desc' | null;
-    }) => void;
-    onCreateUser?: (userData: Partial<User>) => Promise<void>;
-    onUpdateUser?: (userId: string, userData: Partial<User>) => Promise<void>;
-    onDeleteUser?: (userId: string) => Promise<void>;
-    onDeleteUsers?: (userIds: string[]) => Promise<void>;
     class?: ClassValue;
 }
 export interface FormErrors {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@makolabs/ripple",
-	"version": "1.2.4",
+	"version": "1.2.9",
 	"description": "Simple Svelte 5 powered component library ✨",
 	"license": "SEE LICENSE IN LICENSE",
 	"repository": {
@@ -117,6 +117,7 @@
 	"dependencies": {
 		"@friendofsvelte/mermaid": "^0.0.4",
 		"@friendofsvelte/state": "^0.0.6-ts",
+		"@makolabs/ripple": "^1.2.4",
 		"@sveltejs/adapter-static": "^3.0.9",
 		"compromise": "^14.14.4",
 		"dayjs": "^1.11.13",