@happyvertical/smrt-users 0.30.0

package/dist/svelte/components/UserMenu.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserMenu.svelte.d.ts","sourceRoot":"","sources":["../../../src/svelte/components/UserMenu.svelte.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAM5D,uCAAuC;AACvC,MAAM,WAAW,KAAK;IACpB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,8DAA8D;IAC9D,IAAI,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,uBAAuB;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA+HD,QAAA,MAAM,QAAQ,2CAAwC,CAAC;AACvD,KAAK,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;AAC5C,eAAe,QAAQ,CAAC"}

package/dist/svelte/components/__tests__/InviteUserModal.test.js

@@ -0,0 +1,54 @@
+// @vitest-environment jsdom
+/**
+ * Component coverage for InviteUserModal via the shared S11 harness (#1416).
+ */
+import { fireEvent, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { describe, expect, it, vi } from 'vitest';
+import InviteUserModal from '../InviteUserModal.svelte';
+const baseProps = (over = {}) => ({
+    open: true,
+    tenant: { name: 'Acme' },
+    roles: [{ id: 'r1', slug: 'member', name: 'Member' }],
+    onsubmit: vi.fn(),
+    onclose: vi.fn(),
+    ...over,
+});
+describe('InviteUserModal', () => {
+    it('renders the invite dialog scoped to the tenant when open', () => {
+        render(InviteUserModal, { props: baseProps() });
+        expect(screen.getByRole('heading', { name: 'Invite User to Acme' })).toBeInTheDocument();
+        expect(screen.getByLabelText('Email address')).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Send Invite' })).toBeInTheDocument();
+    });
+    it('renders nothing when closed', () => {
+        render(InviteUserModal, { props: baseProps({ open: false }) });
+        expect(screen.queryByRole('dialog')).toBeNull();
+    });
+    it('shows the JS validation error when submitted with no email', async () => {
+        const onsubmit = vi.fn();
+        const { container } = render(InviteUserModal, {
+            props: baseProps({ onsubmit }),
+        });
+        // Submit the form directly to exercise the component's own guard — a button
+        // click would be pre-empted by the input's native `required` constraint.
+        const form = container.querySelector('form');
+        if (!form)
+            throw new Error('form not found');
+        await fireEvent.submit(form);
+        expect(screen.getByText('Email is required')).toBeInTheDocument();
+        expect(onsubmit).not.toHaveBeenCalled();
+    });
+    it('submits the email and default role', async () => {
+        const onsubmit = vi.fn();
+        render(InviteUserModal, { props: baseProps({ onsubmit }) });
+        await userEvent.type(screen.getByLabelText('Email address'), 'ada@example.com');
+        await userEvent.click(screen.getByRole('button', { name: 'Send Invite' }));
+        expect(onsubmit).toHaveBeenCalledWith(expect.objectContaining({ email: 'ada@example.com', roleId: 'r1' }));
+    });
+    it('closes via the Cancel button', async () => {
+        const onclose = vi.fn();
+        render(InviteUserModal, { props: baseProps({ onclose }) });
+        await userEvent.click(screen.getByRole('button', { name: 'Cancel' }));
+        expect(onclose).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/svelte/components/__tests__/UserAvatar.test.js

@@ -0,0 +1,31 @@
+// @vitest-environment jsdom
+/**
+ * First component test in smrt-users via the shared S11 harness (#1416): the
+ * Testing-Library + axe surface comes from `@happyvertical/smrt-vitest` and the
+ * jsdom + jest-dom setup from the shared `svelte-setup` wired in vitest.config.
+ */
+import { expectNoA11yViolations, render, screen, } from '@happyvertical/smrt-vitest/svelte';
+import { describe, expect, it } from 'vitest';
+import UserAvatar from '../UserAvatar.svelte';
+// UserAvatar only reads `profile.name`, so a minimal stub is enough to drive it.
+const profile = { name: 'Ada Lovelace' };
+describe('UserAvatar', () => {
+    it('renders the initials derived from the profile name', () => {
+        render(UserAvatar, { props: { profile } });
+        expect(screen.getByText('AL')).toBeInTheDocument();
+    });
+    it('renders the full name when showName is set', () => {
+        render(UserAvatar, { props: { profile, showName: true } });
+        expect(screen.getByText('Ada Lovelace')).toBeInTheDocument();
+    });
+    it('falls back to "U" initials for a profile with no name', () => {
+        render(UserAvatar, { props: { profile: {} } });
+        expect(screen.getByText('U')).toBeInTheDocument();
+    });
+    it('is axe-clean', async () => {
+        const { container } = render(UserAvatar, {
+            props: { profile, showName: true },
+        });
+        await expectNoA11yViolations(container);
+    });
+});

package/dist/svelte/components/__tests__/UserCard.test.js

@@ -0,0 +1,39 @@
+// @vitest-environment jsdom
+/**
+ * Component coverage for UserCard via the shared S11 harness (#1416).
+ */
+import { expectNoA11yViolations, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { describe, expect, it, vi } from 'vitest';
+import UserCard from '../UserCard.svelte';
+const baseProps = (over = {}) => ({
+    user: { id: 'u1', email: 'ada@example.com', status: 'active' },
+    profile: { name: 'Ada Lovelace' },
+    role: 'admin',
+    status: 'active',
+    ...over,
+});
+describe('UserCard', () => {
+    it('renders the name, email, role, and status', () => {
+        render(UserCard, { props: baseProps() });
+        expect(screen.getByText('Ada Lovelace')).toBeInTheDocument();
+        expect(screen.getByText('ada@example.com')).toBeInTheDocument();
+        expect(screen.getByText('admin')).toBeInTheDocument();
+        expect(screen.getByText('active')).toBeInTheDocument();
+    });
+    it('invokes onclick when the card is activated', async () => {
+        const onclick = vi.fn();
+        render(UserCard, { props: baseProps({ onclick }) });
+        await userEvent.click(screen.getByRole('button'));
+        expect(onclick).toHaveBeenCalledTimes(1);
+    });
+    it('is a disabled, non-interactive card without an onclick', () => {
+        render(UserCard, { props: baseProps() });
+        expect(screen.getByRole('button')).toBeDisabled();
+    });
+    it('is axe-clean', async () => {
+        const { container } = render(UserCard, {
+            props: baseProps({ onclick: vi.fn() }),
+        });
+        await expectNoA11yViolations(container);
+    });
+});

package/dist/svelte/components/__tests__/UserForm.test.js

@@ -0,0 +1,50 @@
+// @vitest-environment jsdom
+/**
+ * Component coverage for UserForm via the shared S11 harness (#1416).
+ */
+import { expectNoA11yViolations, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { describe, expect, it, vi } from 'vitest';
+import UserForm from '../UserForm.svelte';
+describe('UserForm', () => {
+    it('renders create-mode fields and a Create button', () => {
+        render(UserForm, { props: { onsubmit: vi.fn() } });
+        expect(screen.getByLabelText('Name')).toBeInTheDocument();
+        expect(screen.getByLabelText('Email')).toBeInTheDocument();
+        expect(screen.getByLabelText('Status')).toBeInTheDocument();
+        expect(screen.getByRole('button', { name: 'Create User' })).toBeInTheDocument();
+    });
+    it('submits the entered name and email', async () => {
+        const onsubmit = vi.fn();
+        render(UserForm, { props: { onsubmit } });
+        await userEvent.type(screen.getByLabelText('Name'), 'Ada Lovelace');
+        await userEvent.type(screen.getByLabelText('Email'), 'ada@example.com');
+        await userEvent.click(screen.getByRole('button', { name: 'Create User' }));
+        expect(onsubmit).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'Ada Lovelace',
+            email: 'ada@example.com',
+        }));
+    });
+    it('locks the email and switches to update mode for an existing user', () => {
+        render(UserForm, {
+            props: {
+                onsubmit: vi.fn(),
+                user: { email: 'ada@example.com', status: 'active' },
+                profile: { name: 'Ada Lovelace' },
+            },
+        });
+        expect(screen.getByLabelText('Email')).toBeDisabled();
+        expect(screen.getByRole('button', { name: 'Update User' })).toBeInTheDocument();
+    });
+    it('invokes oncancel from the Cancel button', async () => {
+        const oncancel = vi.fn();
+        render(UserForm, { props: { onsubmit: vi.fn(), oncancel } });
+        await userEvent.click(screen.getByRole('button', { name: 'Cancel' }));
+        expect(oncancel).toHaveBeenCalledTimes(1);
+    });
+    it('is axe-clean', async () => {
+        const { container } = render(UserForm, {
+            props: { onsubmit: vi.fn(), oncancel: vi.fn() },
+        });
+        await expectNoA11yViolations(container);
+    });
+});

package/dist/svelte/components/__tests__/UserList.test.js

@@ -0,0 +1,48 @@
+// @vitest-environment jsdom
+/**
+ * Component coverage for UserList via the shared S11 harness (#1416).
+ */
+import { expectNoA11yViolations, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { describe, expect, it, vi } from 'vitest';
+import UserList from '../UserList.svelte';
+const users = [
+    {
+        user: { id: 'u1', email: 'ada@example.com', status: 'active' },
+        profile: { name: 'Ada Lovelace' },
+        role: 'admin',
+    },
+    {
+        user: { id: 'u2', email: 'alan@example.com', status: 'pending' },
+        profile: { name: 'Alan Turing' },
+        role: 'member',
+    },
+];
+describe('UserList', () => {
+    it('renders a card per user', () => {
+        render(UserList, { props: { users } });
+        expect(screen.getByText('Ada Lovelace')).toBeInTheDocument();
+        expect(screen.getByText('Alan Turing')).toBeInTheDocument();
+    });
+    it('forwards the selected user through onselect', async () => {
+        const onselect = vi.fn();
+        render(UserList, { props: { users, onselect } });
+        await userEvent.click(screen.getByText('Alan Turing'));
+        expect(onselect).toHaveBeenCalledWith(expect.objectContaining({ id: 'u2' }));
+    });
+    it('shows the empty message when there are no users', () => {
+        render(UserList, {
+            props: { users: [], emptyMessage: 'Nobody here' },
+        });
+        expect(screen.getByText('Nobody here')).toBeInTheDocument();
+    });
+    it('shows a loading state', () => {
+        render(UserList, { props: { users: [], loading: true } });
+        expect(screen.getByText('Loading users...')).toBeInTheDocument();
+    });
+    it('is axe-clean', async () => {
+        const { container } = render(UserList, {
+            props: { users, onselect: vi.fn() },
+        });
+        await expectNoA11yViolations(container);
+    });
+});

package/dist/svelte/components/__tests__/UserMenu.test.js

@@ -0,0 +1,38 @@
+// @vitest-environment jsdom
+/**
+ * Component coverage for UserMenu via the shared S11 harness (#1416), plus the
+ * S12 a11y remediation (#1417): the open dropdown now has its own id (no longer
+ * duplicating the wrapper) and `aria-labelledby` resolves to the trigger, so axe
+ * is asserted on both the collapsed and open states.
+ */
+import { expectNoA11yViolations, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { describe, expect, it } from 'vitest';
+import UserMenu from '../UserMenu.svelte';
+describe('UserMenu', () => {
+    it('renders a collapsed trigger labelled with the display name', () => {
+        render(UserMenu, { props: { user: { name: 'Ada Lovelace' } } });
+        const trigger = screen.getByRole('button', { name: 'User menu' });
+        expect(trigger).toHaveAttribute('aria-expanded', 'false');
+        expect(screen.getByText('Ada Lovelace')).toBeInTheDocument();
+        expect(screen.queryByRole('menu')).toBeNull();
+    });
+    it('opens the menu with profile/settings/sign-out items on click', async () => {
+        render(UserMenu, {
+            props: { user: { name: 'Ada Lovelace', email: 'ada@example.com' } },
+        });
+        await userEvent.click(screen.getByRole('button', { name: 'User menu' }));
+        expect(screen.getByRole('menu')).toBeInTheDocument();
+        expect(screen.getByRole('menuitem', { name: 'Profile' })).toBeInTheDocument();
+        expect(screen.getByRole('menuitem', { name: 'Settings' })).toBeInTheDocument();
+        expect(screen.getByRole('menuitem', { name: 'Sign out' })).toBeInTheDocument();
+    });
+    it('is axe-clean while collapsed and when open', async () => {
+        const { container } = render(UserMenu, {
+            props: { user: { name: 'Ada Lovelace', email: 'ada@example.com' } },
+        });
+        await expectNoA11yViolations(container);
+        await userEvent.click(screen.getByRole('button', { name: 'User menu' }));
+        expect(screen.getByRole('menu')).toBeInTheDocument();
+        await expectNoA11yViolations(container);
+    });
+});

package/dist/svelte/i18n.d.ts

@@ -0,0 +1,15 @@
+export declare const M: {
+    readonly 'users.invite_user_modal.close_invite_dialog': "users.invite_user_modal.close_invite_dialog";
+    readonly 'users.invite_user_modal.title': "users.invite_user_modal.title";
+    readonly 'users.invite_user_modal.close': "users.invite_user_modal.close";
+    readonly 'users.invite_user_modal.email_address': "users.invite_user_modal.email_address";
+    readonly 'users.invite_user_modal.email_placeholder': "users.invite_user_modal.email_placeholder";
+    readonly 'users.invite_user_modal.send_invitation_email': "users.invite_user_modal.send_invitation_email";
+    readonly 'users.invite_user_modal.pending_hint': "users.invite_user_modal.pending_hint";
+    readonly 'users.invite_user_modal.sending': "users.invite_user_modal.sending";
+    readonly 'users.invite_user_modal.send_invite': "users.invite_user_modal.send_invite";
+    readonly 'users.user_form.email_cannot_be_changed': "users.user_form.email_cannot_be_changed";
+    readonly 'users.user_list.loading_users': "users.user_list.loading_users";
+    readonly 'users.user_menu.sign_out': "users.user_menu.sign_out";
+};
+//# sourceMappingURL=i18n.d.ts.map

package/dist/svelte/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/svelte/i18n.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,CAAC;;;;;;;;;;;;;CAeZ,CAAC"}

package/dist/svelte/i18n.js

@@ -0,0 +1,15 @@
+import { defineMessages } from '@happyvertical/smrt-ui/i18n';
+export const M = defineMessages({
+    'users.invite_user_modal.close_invite_dialog': 'Close invite dialog',
+    'users.invite_user_modal.title': 'Invite User to {tenantName}',
+    'users.invite_user_modal.close': 'Close',
+    'users.invite_user_modal.email_address': 'Email address',
+    'users.invite_user_modal.email_placeholder': 'user@example.com',
+    'users.invite_user_modal.send_invitation_email': 'Send invitation email',
+    'users.invite_user_modal.pending_hint': 'The user will be added with pending status. Share the invite link manually.',
+    'users.invite_user_modal.sending': 'Sending...',
+    'users.invite_user_modal.send_invite': 'Send Invite',
+    'users.user_form.email_cannot_be_changed': 'Email cannot be changed after creation',
+    'users.user_list.loading_users': 'Loading users...',
+    'users.user_menu.sign_out': 'Sign out',
+});

package/dist/svelte/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Users Module Svelte Components
+ *
+ * Optional Svelte UI components for user and tenant management.
+ * Auto-registers components with ModuleUIRegistry on import.
+ *
+ * @packageDocumentation
+ */
+import type { ComponentProps } from 'svelte';
+import InviteUserModal from './components/InviteUserModal.svelte';
+import UserAvatar from './components/UserAvatar.svelte';
+import UserCard from './components/UserCard.svelte';
+import UserForm from './components/UserForm.svelte';
+import UserList from './components/UserList.svelte';
+import UserMenu from './components/UserMenu.svelte';
+export { InviteUserModal, UserAvatar, UserCard, UserForm, UserList, UserMenu };
+export type InviteUserModalProps = ComponentProps<typeof InviteUserModal>;
+export type UserAvatarProps = ComponentProps<typeof UserAvatar>;
+export type UserCardProps = ComponentProps<typeof UserCard>;
+export type UserFormProps = ComponentProps<typeof UserForm>;
+export type UserListProps = ComponentProps<typeof UserList>;
+export type UserMenuProps = ComponentProps<typeof UserMenu>;
+//# sourceMappingURL=index.d.ts.map

package/dist/svelte/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svelte/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAI7C,OAAO,eAAe,MAAM,qCAAqC,CAAC;AAClE,OAAO,UAAU,MAAM,gCAAgC,CAAC;AACxD,OAAO,QAAQ,MAAM,8BAA8B,CAAC;AACpD,OAAO,QAAQ,MAAM,8BAA8B,CAAC;AACpD,OAAO,QAAQ,MAAM,8BAA8B,CAAC;AACpD,OAAO,QAAQ,MAAM,8BAA8B,CAAC;AAGpD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAG/E,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC,OAAO,eAAe,CAAC,CAAC;AAC1E,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC,OAAO,UAAU,CAAC,CAAC;AAChE,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,OAAO,QAAQ,CAAC,CAAC;AAC5D,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,OAAO,QAAQ,CAAC,CAAC;AAC5D,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,OAAO,QAAQ,CAAC,CAAC;AAC5D,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,OAAO,QAAQ,CAAC,CAAC"}

package/dist/svelte/index.js

@@ -0,0 +1,27 @@
+/**
+ * Users Module Svelte Components
+ *
+ * Optional Svelte UI components for user and tenant management.
+ * Auto-registers components with ModuleUIRegistry on import.
+ *
+ * @packageDocumentation
+ */
+import { ModuleUIRegistry } from '@happyvertical/smrt-ui/registry';
+import { USERS_MODULE_META } from '../ui.js';
+// Import components
+import InviteUserModal from './components/InviteUserModal.svelte';
+import UserAvatar from './components/UserAvatar.svelte';
+import UserCard from './components/UserCard.svelte';
+import UserForm from './components/UserForm.svelte';
+import UserList from './components/UserList.svelte';
+import UserMenu from './components/UserMenu.svelte';
+// Export components
+export { InviteUserModal, UserAvatar, UserCard, UserForm, UserList, UserMenu };
+// Auto-register with ModuleUIRegistry
+ModuleUIRegistry.registerModule(USERS_MODULE_META);
+ModuleUIRegistry.register('@happyvertical/smrt-users', 'invite-user-modal', InviteUserModal);
+ModuleUIRegistry.register('@happyvertical/smrt-users', 'user-avatar', UserAvatar);
+ModuleUIRegistry.register('@happyvertical/smrt-users', 'user-card', UserCard);
+ModuleUIRegistry.register('@happyvertical/smrt-users', 'user-form', UserForm);
+ModuleUIRegistry.register('@happyvertical/smrt-users', 'user-list', UserList);
+ModuleUIRegistry.register('@happyvertical/smrt-users', 'user-menu', UserMenu);

package/dist/svelte/playground.d.ts

@@ -0,0 +1,151 @@
+declare const _default: {
+    packageName: string;
+    displayName: string;
+    description: string | undefined;
+    moduleMeta: import("@happyvertical/smrt-types").SmrtModuleMeta;
+    entries: ({
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<typeof import("./components/UserList.svelte")>;
+        order: number;
+        props: {
+            users: {
+                user: {
+                    id: string;
+                    email: string;
+                    status: string;
+                };
+                profile: {
+                    id: string;
+                    name: string;
+                    email: string;
+                };
+                role: string;
+            }[];
+            selectedId: string;
+            onselect: () => void;
+            user?: undefined;
+            profile?: undefined;
+            onsubmit?: undefined;
+            oncancel?: undefined;
+            open?: undefined;
+            tenant?: undefined;
+            roles?: undefined;
+            onclose?: undefined;
+            profileUrl?: undefined;
+            settingsUrl?: undefined;
+            signoutUrl?: undefined;
+        };
+        modes: {
+            mock: {
+                label: string;
+            };
+        };
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<typeof import("./components/UserForm.svelte")>;
+        order: number;
+        props: {
+            user: {
+                id: string;
+                email: string;
+                status: string;
+            };
+            profile: {
+                id: string;
+                name: string;
+                email: string;
+            };
+            onsubmit: () => void;
+            oncancel: () => void;
+            users?: undefined;
+            selectedId?: undefined;
+            onselect?: undefined;
+            open?: undefined;
+            tenant?: undefined;
+            roles?: undefined;
+            onclose?: undefined;
+            profileUrl?: undefined;
+            settingsUrl?: undefined;
+            signoutUrl?: undefined;
+        };
+        modes: {
+            mock: {
+                label: string;
+            };
+        };
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<typeof import("./components/InviteUserModal.svelte")>;
+        order: number;
+        props: {
+            open: boolean;
+            tenant: {
+                id: string;
+                name: string;
+                slug: string;
+                status: string;
+            };
+            roles: {
+                id: string;
+                slug: string;
+                name: string;
+                description: string;
+            }[];
+            onsubmit: () => void;
+            onclose: () => void;
+            users?: undefined;
+            selectedId?: undefined;
+            onselect?: undefined;
+            user?: undefined;
+            profile?: undefined;
+            oncancel?: undefined;
+            profileUrl?: undefined;
+            settingsUrl?: undefined;
+            signoutUrl?: undefined;
+        };
+        modes: {
+            mock: {
+                label: string;
+            };
+        };
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<typeof import("./components/UserMenu.svelte")>;
+        order: number;
+        props: {
+            profile: {
+                id: string;
+                name: string;
+                email: string;
+            };
+            profileUrl: string;
+            settingsUrl: string;
+            signoutUrl: string;
+            users?: undefined;
+            selectedId?: undefined;
+            onselect?: undefined;
+            user?: undefined;
+            onsubmit?: undefined;
+            oncancel?: undefined;
+            open?: undefined;
+            tenant?: undefined;
+            roles?: undefined;
+            onclose?: undefined;
+        };
+        modes: {
+            mock: {
+                label: string;
+            };
+        };
+    })[];
+};
+export default _default;
+//# sourceMappingURL=playground.d.ts.map

package/dist/svelte/playground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../../src/svelte/playground.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,wBAkFE"}

package/dist/svelte/playground.js

@@ -0,0 +1,134 @@
+import { USERS_MODULE_META } from '../ui.js';
+const noop = () => { };
+const sampleTenant = {
+    id: 'tenant-riverstone',
+    name: 'Riverstone Newsroom',
+    slug: 'riverstone-newsroom',
+    status: 'active',
+};
+const sampleRoles = [
+    {
+        id: 'role-member',
+        slug: 'member',
+        name: 'Member',
+        description: 'Can collaborate on editorial work.',
+    },
+    {
+        id: 'role-editor',
+        slug: 'editor',
+        name: 'Editor',
+        description: 'Can approve and publish content.',
+    },
+];
+const sampleUsers = [
+    {
+        user: {
+            id: 'user-taylor',
+            email: 'taylor@example.com',
+            status: 'active',
+        },
+        profile: {
+            id: 'profile-taylor',
+            name: 'Taylor Rowan',
+            email: 'taylor@example.com',
+        },
+        role: 'Editor',
+    },
+    {
+        user: {
+            id: 'user-jordan',
+            email: 'jordan@example.com',
+            status: 'pending',
+        },
+        profile: {
+            id: 'profile-jordan',
+            name: 'Jordan Lee',
+            email: 'jordan@example.com',
+        },
+        role: 'Contributor',
+    },
+];
+const loadInviteUserModal = () => import('./components/InviteUserModal.svelte');
+const loadUserForm = () => import('./components/UserForm.svelte');
+const loadUserList = () => import('./components/UserList.svelte');
+const loadUserMenu = () => import('./components/UserMenu.svelte');
+export default {
+    packageName: '@happyvertical/smrt-users',
+    displayName: USERS_MODULE_META.displayName,
+    description: USERS_MODULE_META.description,
+    moduleMeta: USERS_MODULE_META,
+    entries: [
+        {
+            id: 'user-list',
+            title: 'User List',
+            description: 'Role-aware list of users with selection and profile display.',
+            loadComponent: loadUserList,
+            order: 1,
+            props: {
+                users: sampleUsers,
+                selectedId: 'user-taylor',
+                onselect: noop,
+            },
+            modes: {
+                mock: {
+                    label: 'Mock',
+                },
+            },
+        },
+        {
+            id: 'user-form',
+            title: 'User Form',
+            description: 'Create and edit form for user records and account status.',
+            loadComponent: loadUserForm,
+            order: 2,
+            props: {
+                user: sampleUsers[0].user,
+                profile: sampleUsers[0].profile,
+                onsubmit: noop,
+                oncancel: noop,
+            },
+            modes: {
+                mock: {
+                    label: 'Mock',
+                },
+            },
+        },
+        {
+            id: 'invite-user-modal',
+            title: 'Invite User Modal',
+            description: 'Invitation flow for adding a tenant member with a role assignment.',
+            loadComponent: loadInviteUserModal,
+            order: 3,
+            props: {
+                open: false,
+                tenant: sampleTenant,
+                roles: sampleRoles,
+                onsubmit: noop,
+                onclose: noop,
+            },
+            modes: {
+                mock: {
+                    label: 'Mock',
+                },
+            },
+        },
+        {
+            id: 'user-menu',
+            title: 'User Menu',
+            description: 'Authenticated account menu for profile, settings, and sign-out actions.',
+            loadComponent: loadUserMenu,
+            order: 4,
+            props: {
+                profile: sampleUsers[0].profile,
+                profileUrl: '/settings/profile',
+                settingsUrl: '/settings',
+                signoutUrl: '/auth/signout',
+            },
+            modes: {
+                mock: {
+                    label: 'Mock',
+                },
+            },
+        },
+    ],
+};