@makolabs/ripple 1.2.3 → 1.2.8

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

@@ -0,0 +1,12 @@
+/**
+ * User Management Module
+ * Components and utilities for managing users
+ */
+export { default as UserManagement } from './UserManagement.svelte';
+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/index.js

@@ -0,0 +1,11 @@
+/**
+ * User Management Module
+ * Components and utilities for managing users
+ */
+// Components
+export { default as UserManagement } from './UserManagement.svelte';
+export { default as UserTable } from './UserTable.svelte';
+export { default as UserModal } from './UserModal.svelte';
+export { default as UserViewModal } from './UserViewModal.svelte';
+// Utilities
+export { createUser, getUserDisplayName, getUserInitials } from './user-management.js';

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

@@ -0,0 +1,126 @@
+/**
+ * User Management Types
+ * Type definitions for user management components
+ */
+import type { ClassValue } from 'tailwind-variants';
+export interface UserEmail {
+    email_address: string;
+    verified?: boolean;
+}
+export interface UserPhone {
+    phone_number: string;
+    verified?: boolean;
+}
+export interface User {
+    id: string;
+    first_name?: string;
+    last_name?: string;
+    username?: string;
+    email_addresses?: UserEmail[];
+    phone_numbers?: UserPhone[];
+    image_url?: string;
+    created_at?: number;
+    last_sign_in_at?: number;
+    private_metadata?: Record<string, unknown>;
+    public_metadata?: Record<string, unknown>;
+    permissions?: string[];
+    role?: string;
+}
+export interface Permission {
+    id: string;
+    name: string;
+    description?: string;
+    category?: string;
+}
+export interface Role {
+    value: string;
+    label: string;
+    description?: string;
+    permissions: string[];
+}
+export interface UserTableProps {
+    users: User[];
+    loading?: boolean;
+    currentPage?: number;
+    pageSize?: number;
+    totalUsers?: number;
+    onPageChange: (page: number) => void;
+    onPageSizeChange: (size: number) => void;
+    onSort?: (state: {
+        column: string | null;
+        direction: 'asc' | 'desc' | null;
+    }) => void;
+    onView: (user: User) => void;
+    onEdit: (user: User) => void;
+    onDelete: (userId: string) => void;
+    class?: ClassValue;
+}
+export interface UserModalProps {
+    open: boolean;
+    user: User | null;
+    roles?: Role[];
+    onSave: (user: User, mode: 'create' | 'edit') => Promise<void>;
+    onClose: () => void;
+    class?: ClassValue;
+}
+export interface UserViewModalProps {
+    open: boolean;
+    user: User | null;
+    permissions?: Permission[];
+    onEdit?: (user: User) => void;
+    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 {
+    /**
+     * 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[];
+    class?: ClassValue;
+}
+export interface FormErrors {
+    [key: string]: string;
+}
+export declare function createUser(partial?: Partial<User>): User;
+export declare function getUserDisplayName(user: User | null): string;
+export declare function getUserInitials(user: User | null): string;

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

@@ -0,0 +1,42 @@
+/**
+ * User Management Types
+ * Type definitions for user management components
+ */
+// Export convenience function to create a user object
+export function createUser(partial = {}) {
+    return {
+        id: '',
+        first_name: '',
+        last_name: '',
+        username: '',
+        email_addresses: [],
+        phone_numbers: [],
+        permissions: [],
+        ...partial
+    };
+}
+// Export convenience function to format user display name
+export function getUserDisplayName(user) {
+    if (!user)
+        return 'Unknown User';
+    if (user.first_name || user.last_name) {
+        return `${user.first_name || ''} ${user.last_name || ''}`.trim();
+    }
+    if (user.username)
+        return user.username;
+    if (user.email_addresses?.[0]?.email_address) {
+        return user.email_addresses[0].email_address;
+    }
+    return user.id || 'Unknown User';
+}
+// Export convenience function to get user initials
+export function getUserInitials(user) {
+    if (!user)
+        return '?';
+    if (user.first_name)
+        return user.first_name[0].toUpperCase();
+    if (user.email_addresses?.[0]?.email_address) {
+        return user.email_addresses[0].email_address[0].toUpperCase();
+    }
+    return '?';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@makolabs/ripple",
-	"version": "1.2.3",
+	"version": "1.2.8",
 	"description": "Simple Svelte 5 powered component library ✨",
 	"license": "SEE LICENSE IN LICENSE",
 	"repository": {
@@ -71,7 +71,9 @@
 		"eslint-plugin-storybook": "^9.0.18",
 		"eslint-plugin-svelte": "^3.0.0",
 		"globals": "^16.0.0",
+		"husky": "^9.1.7",
 		"jsdom": "^26.0.0",
+		"lint-staged": "^16.2.6",
 		"prettier": "^3.4.2",
 		"prettier-plugin-svelte": "^3.3.3",
 		"prettier-plugin-tailwindcss": "^0.6.11",
@@ -115,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",

package/dist/types/markdown.d.ts

@@ -1,14 +0,0 @@
-declare module 'markdown' {
-	export interface MarkdownOptions {
-		dialect?: string;
-	}
-
-	export interface MarkdownAPI {
-		toHTML(markdown: string, options?: MarkdownOptions): string;
-		parse(markdown: string): any;
-		renderJsonML(jsonml: any): string;
-		toHTMLTree(tree: any): any;
-	}
-
-	export const markdown: MarkdownAPI;
-}

package/dist/types/variants.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/variants.js

@@ -1 +0,0 @@
-"use strict";