@jini-ai/user-management 0.2.0

package/dist/admin/react/hooks/UsersPage.hooks.d.ts

@@ -0,0 +1,106 @@
+import type { UsersController } from '../../controllers/users.controller.js';
+import type { UsersState } from '../../models.js';
+import type { UsersPageProps } from './UsersBinding.hooks.js';
+export interface UsersView {
+    controller: UsersController;
+    state: UsersState;
+    permissions: readonly string[];
+}
+export declare const UsersViewContext: import("react").Context<UsersView | null>;
+export declare function useUsersView(_required?: Record<string, never>, _optional?: Record<string, never>): UsersView;
+export declare function useUsersPage(props: UsersPageProps, _optional?: Record<string, never>): {
+    content: import("react").FunctionComponentElement<{
+        readonly params?: Readonly<Record<string, unknown>>;
+    } | ({
+        readonly params?: Readonly<Record<string, unknown>>;
+    } & import("react").RefAttributes<import("react").Component<{
+        readonly params?: Readonly<Record<string, unknown>>;
+    }, any, any>>)> | null;
+    controller: {
+        getSnapshot: (_required?: Record<string, never>, _optional?: Record<string, never>) => Readonly<UsersState>;
+        subscribe: ({ listener }: {
+            listener: () => void;
+        }, _optional?: Record<string, never>) => () => void;
+        allowed: ({ principalId, action }: {
+            principalId: string;
+            action: import("../../models.js").UserAction;
+        }, _optional?: Record<string, never>) => boolean;
+        load: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+        loadCaller: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+        createUser: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+        toggleExpanded: ({ principalId }: {
+            principalId: string;
+        }, _optional?: Record<string, never>) => void;
+        savePanel: ({ principalId, kind }: {
+            principalId: string;
+            kind: "email" | "role" | "policy";
+        }, _optional?: Record<string, never>) => Promise<boolean>;
+        enableUser: ({ principalId }: {
+            principalId: string;
+        }, _optional?: Record<string, never>) => Promise<boolean>;
+        requestDestructive: ({ principalId, kind }: {
+            principalId: string;
+            kind: "disable" | "delete" | "reset";
+        }, _optional?: Record<string, never>) => void;
+        confirmDestructive: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+        cancelDestructive(_required: Record<string, never>, _optional?: Record<string, never>): void;
+        setFormOpen({ open }: {
+            open: boolean;
+        }, _optional?: Record<string, never>): void;
+        setDraft({ patch }: {
+            patch: Partial<import("../../models.js").UsersDraft>;
+        }, _optional?: Record<string, never>): void;
+        togglePasswordVisible({ field }: {
+            field: "new" | "confirm";
+        }, _optional?: Record<string, never>): void;
+        dispose(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+    } | null;
+    state: UsersState | null;
+    visible: boolean;
+    view: {
+        controller: {
+            getSnapshot: (_required?: Record<string, never>, _optional?: Record<string, never>) => Readonly<UsersState>;
+            subscribe: ({ listener }: {
+                listener: () => void;
+            }, _optional?: Record<string, never>) => () => void;
+            allowed: ({ principalId, action }: {
+                principalId: string;
+                action: import("../../models.js").UserAction;
+            }, _optional?: Record<string, never>) => boolean;
+            load: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+            loadCaller: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+            createUser: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+            toggleExpanded: ({ principalId }: {
+                principalId: string;
+            }, _optional?: Record<string, never>) => void;
+            savePanel: ({ principalId, kind }: {
+                principalId: string;
+                kind: "email" | "role" | "policy";
+            }, _optional?: Record<string, never>) => Promise<boolean>;
+            enableUser: ({ principalId }: {
+                principalId: string;
+            }, _optional?: Record<string, never>) => Promise<boolean>;
+            requestDestructive: ({ principalId, kind }: {
+                principalId: string;
+                kind: "disable" | "delete" | "reset";
+            }, _optional?: Record<string, never>) => void;
+            confirmDestructive: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+            cancelDestructive(_required: Record<string, never>, _optional?: Record<string, never>): void;
+            setFormOpen({ open }: {
+                open: boolean;
+            }, _optional?: Record<string, never>): void;
+            setDraft({ patch }: {
+                patch: Partial<import("../../models.js").UsersDraft>;
+            }, _optional?: Record<string, never>): void;
+            togglePasswordVisible({ field }: {
+                field: "new" | "confirm";
+            }, _optional?: Record<string, never>): void;
+            dispose(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+        };
+        state: UsersState;
+        permissions: readonly string[];
+    } | null;
+    readOnly: boolean;
+    retry: () => void;
+};
+//# sourceMappingURL=UsersPage.hooks.d.ts.map

package/dist/admin/react/hooks/UsersPage.hooks.js

@@ -0,0 +1,22 @@
+import { createElement, createContext, useContext, useMemo } from 'react';
+import { createUsersController } from '../../controllers/users.controller.js';
+import { hasAdminGrant } from '../../people.rules.js';
+import { useUsersScope } from './UsersBinding.hooks.js';
+import { usePeopleController } from './PeopleController.hooks.js';
+export const UsersViewContext = createContext(null);
+export function useUsersView(_required = {}, _optional = {}) { const v = useContext(UsersViewContext); if (!v)
+    throw new Error('Users controller unavailable.'); return v; }
+export function useUsersPage(props, _optional = {}) {
+    const { api, safety, permissions } = useUsersScope({});
+    const scope = useMemo(() => ({ api, safety, closed: props.onOwnPasswordResetClosed }), [api, safety, props.onOwnPasswordResetClosed]);
+    const key = JSON.stringify([permissions, props.openOwnPasswordReset]);
+    const { controller, state } = usePeopleController({ scope, key,
+        create: () => createUsersController({ api, safety }, { permissions, ...(props.openOwnPasswordReset !== undefined ? { openOwnPasswordReset: props.openOwnPasswordReset } : {}), ...(props.onOwnPasswordResetClosed ? { onOwnPasswordResetClosed: props.onOwnPasswordResetClosed } : {}) }),
+        start: c => { void c.load({}); void c.loadCaller({}); },
+    });
+    const visible = props.description.visible && props.description.tabs.some(t => t.visible);
+    return { content: props.tabs.users ? createElement(props.tabs.users, {}) : null, controller, state, visible, view: controller && state ? { controller, state, permissions } : null,
+        readOnly: !hasAdminGrant({ permissions, permission: 'user.manage' }) && !hasAdminGrant({ permissions, permission: 'role.manage' }),
+        retry: () => { void controller?.load({}); } };
+}
+//# sourceMappingURL=UsersPage.hooks.js.map

package/dist/admin/react/hooks/UsersTab.hooks.d.ts

@@ -0,0 +1,101 @@
+import type { FormEvent } from 'react';
+import type { AdminOperator } from '../../models.js';
+import type { MenuItem } from '@jini-ai/ui-kit/react';
+/** Semantic autocomplete must survive a reveal to type=text and host facade overrides. */
+export declare const newPasswordAttrs: {
+    autoComplete: string;
+    'data-jini-part': string;
+};
+export declare function useUsersTab(_required?: Record<string, never>, _optional?: Record<string, never>): {
+    s: import("../../models.js").UsersState;
+    canCreate: boolean;
+    toggleForm: () => void;
+    cancelForm: () => void;
+    username: ({ value }: {
+        value: string;
+    }) => void;
+    email: ({ value }: {
+        value: string;
+    }) => void;
+    password: ({ value }: {
+        value: string;
+    }) => void;
+    submit: (e: FormEvent) => void;
+};
+export declare function useUserRow({ user }: {
+    user: AdminOperator;
+}, _optional?: Record<string, never>): {
+    s: import("../../models.js").UsersState;
+    items: MenuItem[];
+    canEmail: boolean;
+    canGrants: boolean;
+    expanded: boolean;
+    canExpand: boolean;
+    roles: string;
+    policies: string;
+    toggle: () => void;
+    menuLabel: string;
+    email: ({ value }: {
+        value: string;
+    }) => void;
+    role: ({ value }: {
+        value: string;
+    }) => void;
+    policy: ({ value }: {
+        value: string;
+    }) => void;
+    saveEmail: () => void;
+    assignRole: () => void;
+    attachPolicy: () => void;
+    roleOptions: {
+        value: string;
+        label: string;
+    }[];
+    policyOptions: {
+        value: string;
+        label: string;
+    }[];
+};
+export declare function useUsersConfirmation(_required?: Record<string, never>, _optional?: Record<string, never>): {
+    s: import("../../models.js").UsersState;
+    reset: boolean;
+    mismatch: boolean;
+    error: string | null;
+    copy: {
+        title: string;
+        label: string;
+        tone: "danger";
+        body: string;
+        consequence: string;
+    } | {
+        title: string;
+        label: string;
+        tone: "warning";
+        body: string;
+        consequence: string;
+    };
+    confirm: {
+        open: boolean;
+        title: string;
+        confirmLabel: string;
+        tone: "warning" | "danger";
+        consequence: string;
+        pending: boolean;
+        agentMayConfirm: boolean;
+        onConfirm: () => Promise<void>;
+        onCancel: () => void;
+    };
+    newPassword: ({ value }: {
+        value: string;
+    }) => void;
+    confirmPassword: ({ value }: {
+        value: string;
+    }) => void;
+    newType: "password" | "text";
+    confirmType: "password" | "text";
+    toggleNew: () => void;
+    toggleConfirm: () => void;
+    newLabel: string;
+    confirmLabel: string;
+};
+//# sourceMappingURL=UsersTab.hooks.d.ts.map

package/dist/admin/react/hooks/UsersTab.hooks.js

@@ -0,0 +1,53 @@
+import { useUsersView } from './UsersPage.hooks.js';
+import { grantLabel, hasAdminGrant } from '../../people.rules.js';
+/** Semantic autocomplete must survive a reveal to type=text and host facade overrides. */
+export const newPasswordAttrs = { autoComplete: 'new-password', 'data-jini-part': 'new-password' };
+export function useUsersTab(_required = {}, _optional = {}) {
+    const { controller: c, state: s, permissions } = useUsersView({});
+    return { s, canCreate: hasAdminGrant({ permissions, permission: 'user.manage' }),
+        toggleForm: () => c.setFormOpen({ open: !s.formOpen }), cancelForm: () => c.setFormOpen({ open: false }),
+        username: ({ value }) => c.setDraft({ patch: { username: value } }),
+        email: ({ value }) => c.setDraft({ patch: { email: value } }),
+        password: ({ value }) => c.setDraft({ patch: { password: value } }),
+        submit: (e) => { e.preventDefault(); void c.createUser({}); },
+    };
+}
+export function useUserRow({ user }, _optional = {}) {
+    const { controller: c, state: s } = useUsersView({});
+    const id = user.principalId, canEmail = c.allowed({ principalId: id, action: 'email' }), canGrants = c.allowed({ principalId: id, action: 'grants' });
+    const items = [];
+    if (canEmail || canGrants)
+        items.push({ id: 'manage', label: 'Manage', onPress: () => c.toggleExpanded({ principalId: id }) });
+    if (c.allowed({ principalId: id, action: 'disable' }))
+        items.push({ id: 'disable', label: 'Disable', onPress: () => c.requestDestructive({ principalId: id, kind: 'disable' }) });
+    if (c.allowed({ principalId: id, action: 'enable' }))
+        items.push({ id: 'enable', label: 'Enable', onPress: () => { void c.enableUser({ principalId: id }); } });
+    if (c.allowed({ principalId: id, action: 'reset' }))
+        items.push({ id: 'reset', label: 'Reset password', onPress: () => c.requestDestructive({ principalId: id, kind: 'reset' }) });
+    if (c.allowed({ principalId: id, action: 'delete' }))
+        items.push({ id: 'delete', label: 'Delete', onPress: () => c.requestDestructive({ principalId: id, kind: 'delete' }) });
+    return { s, items, canEmail, canGrants, expanded: s.expandedId === id, canExpand: canEmail || canGrants,
+        roles: grantLabel({ ids: user.roleIds, records: s.roles ?? [] }), policies: grantLabel({ ids: user.policyIds, records: s.policies ?? [] }),
+        toggle: () => c.toggleExpanded({ principalId: id }), menuLabel: `Actions for user "${user.username}"`,
+        email: ({ value }) => c.setDraft({ patch: { editEmail: value } }), role: ({ value }) => c.setDraft({ patch: { pendingRoleId: value } }), policy: ({ value }) => c.setDraft({ patch: { pendingPolicyId: value } }),
+        saveEmail: () => { void c.savePanel({ principalId: id, kind: 'email' }); }, assignRole: () => { void c.savePanel({ principalId: id, kind: 'role' }); }, attachPolicy: () => { void c.savePanel({ principalId: id, kind: 'policy' }); },
+        roleOptions: [{ value: '', label: 'Select a role…' }, ...(s.roles ?? []).map(r => ({ value: r.id, label: `${r.name}${r.isBuiltin ? ' (built-in)' : ''}` }))],
+        policyOptions: [{ value: '', label: 'Select a policy…' }, ...(s.policies ?? []).map(p => ({ value: p.id, label: `${p.name}${p.isBuiltin ? ' (built-in)' : ''}` }))], };
+}
+export function useUsersConfirmation(_required = {}, _optional = {}) {
+    const { state: s, controller: c } = useUsersView({});
+    const kind = s.pending?.kind, reset = kind === 'reset', mismatch = s.newPassword !== s.confirmPassword;
+    const copy = kind === 'delete' ? { title: 'Delete this user?', label: 'Move to trash', tone: 'danger',
+        body: 'They will be signed out and moved to the Trash. You can restore them there; they are deleted permanently after 60 days.', consequence: 'moves the user to the Trash' }
+        : reset ? { title: 'Reset password?', label: 'Reset password', tone: 'warning', body: 'Every active session for this user will be signed out.', consequence: 'revokes every active session' }
+            : { title: 'Disable this user?', label: 'Disable', tone: 'warning', body: 'They will not be able to sign in until re-enabled.', consequence: 'revokes sign-in access' };
+    return { s, reset, mismatch, error: mismatch ? 'Passwords do not match.' : s.passwordError, copy,
+        confirm: { open: s.pending !== null, title: copy.title, confirmLabel: copy.label, tone: copy.tone, consequence: copy.consequence, pending: s.confirming, agentMayConfirm: false,
+            onConfirm: async () => { await c.confirmDestructive({}); }, onCancel: () => c.cancelDestructive({}) },
+        newPassword: ({ value }) => c.setDraft({ patch: { newPassword: value } }),
+        confirmPassword: ({ value }) => c.setDraft({ patch: { confirmPassword: value } }),
+        newType: s.showNewPassword ? 'text' : 'password', confirmType: s.showConfirmPassword ? 'text' : 'password',
+        toggleNew: () => c.togglePasswordVisible({ field: 'new' }), toggleConfirm: () => c.togglePasswordVisible({ field: 'confirm' }),
+        newLabel: s.showNewPassword ? 'Hide new password' : 'Show new password', confirmLabel: s.showConfirmPassword ? 'Hide confirm password' : 'Show confirm password', };
+}
+//# sourceMappingURL=UsersTab.hooks.js.map

package/dist/admin/react/index.d.ts

@@ -0,0 +1,203 @@
+export declare const rolesKitNeeds: import("@jini-ai/ui-kit").KitNeeds<"Notice" | "Spinner" | "Tabs" | "Badge" | "Menu" | "Button" | "TextField" | "ConfirmDialog">;
+/** Optional composition surface. Identity services remain owned by user-management. */
+export declare function roles(_required: Record<string, never>, _optional?: Record<string, never>): {
+    id: "roles";
+    requires: {
+        readonly rolesApi: import("@jini-ai/admin/core/module").AdminPortToken<import("../ports.js").RolesApiPort, "jini.identity.rolesApi">;
+    };
+    provides: {};
+    messages: Readonly<{
+        title: "Roles & Permissions";
+        roles: "Roles";
+        policies: "Policies";
+        people: "People";
+        description: "Define roles and policies here. Assign them to people in Users.";
+        loading: "Loading roles & permissions…";
+        readOnly: "Read-only: managing roles requires role.manage.";
+        forbidden: "You do not have permission to do that.";
+        conflict: "It is still in use — remove that assignment/attachment first.";
+        unknownPermission: "That permission is not recognized.";
+        exceedsIssuer: "You cannot grant a permission you do not hold.";
+        validation: "Please correct the highlighted fields.";
+        immutable: "Built-in roles and built-in or frozen policies cannot be changed.";
+    }>;
+    pages: {
+        readonly roles: {
+            readonly path: "/roles";
+            readonly label: "Roles & Permissions";
+            readonly permissions: readonly [];
+            readonly nav: {
+                readonly group: "people";
+                readonly icon: "users";
+            };
+            readonly tabs: {
+                readonly roles: {
+                    readonly label: "Roles";
+                };
+                readonly policies: {
+                    readonly label: "Policies";
+                };
+            };
+        };
+    };
+} & {
+    react: {
+        pages: {
+            roles: {
+                Page: import("react").LazyExoticComponent<typeof import("./pages/RolesPage.js").default>;
+                tabs: {
+                    roles: import("react").LazyExoticComponent<typeof import("./tabs/RolesTab.js").default>;
+                    policies: import("react").LazyExoticComponent<typeof import("./tabs/PoliciesTab.js").default>;
+                };
+            };
+        };
+        Provider: ({ admin, children }: {
+            admin: import("@jini-ai/admin/core/module").AdminInstance;
+            children: import("react").ReactNode;
+        }, _optional?: Record<string, never>) => import("react").FunctionComponentElement<import("react").ProviderProps<import("./hooks/RolesBinding.hooks.js").RolesScope | null>>;
+    };
+    kitNeeds: import("@jini-ai/ui-kit").KitNeeds<"Notice" | "Spinner" | "Tabs" | "Badge" | "Menu" | "Button" | "TextField" | "ConfirmDialog">;
+};
+export type { RolesPageProps, RolesTabProps } from './hooks/RolesBinding.hooks.js';
+export declare const usersKitNeeds: import("@jini-ai/ui-kit").KitNeeds<"Notice" | "Spinner" | "Badge" | "Menu" | "Button" | "TextField" | "Select" | "ConfirmDialog">;
+export declare const membersKitNeeds: import("@jini-ai/ui-kit").KitNeeds<"Notice" | "Spinner" | "Badge" | "Menu" | "Button" | "ConfirmDialog">;
+export declare const authKitNeeds: import("@jini-ai/ui-kit").KitNeeds<"Notice" | "Spinner" | "Button" | "TextField">;
+export declare function users(_required: Record<string, never>, _optional?: Record<string, never>): {
+    id: "users";
+    requires: {
+        readonly usersApi: import("@jini-ai/admin/core/module").AdminPortToken<import("../ports.js").UsersApiPort, "jini.identity.usersApi">;
+        readonly usersSafety: import("@jini-ai/admin/core/module").AdminPortToken<import("../ports.js").UsersSafetyPort, "jini.identity.usersSafety">;
+    };
+    provides: {};
+    messages: {
+        readonly title: "Users";
+        readonly description: "Operator accounts with access to this admin — assign roles and policies, or disable access.";
+        readonly loading: "Loading users…";
+        readonly readOnly: "Read-only — user administration is unavailable with your current grants.";
+        readonly passwordHelp: "No 'forgot password' email yet. If someone is locked out, the owner can reset their password here.";
+        readonly protected: "Only an owner can modify an owner. Unresolved owner status prevents changes.";
+        readonly forbidden: "You do not have permission to do that.";
+    };
+    pages: {
+        readonly users: {
+            readonly path: "/users";
+            readonly label: "Users";
+            readonly permissions: readonly [];
+            readonly nav: {
+                readonly group: "people";
+                readonly icon: "users";
+            };
+            readonly tabs: {
+                readonly users: {
+                    readonly label: "Users";
+                };
+            };
+        };
+    };
+} & {
+    react: {
+        pages: {
+            users: {
+                Page: import("react").LazyExoticComponent<typeof import("./pages/UsersPage.js").default>;
+                tabs: {
+                    users: import("react").LazyExoticComponent<typeof import("./tabs/UsersTab.js").default>;
+                };
+            };
+        };
+        Provider: ({ admin, children }: {
+            admin: import("@jini-ai/admin/core/module").AdminInstance;
+            children: import("react").ReactNode;
+        }, _optional?: Record<string, never>) => import("react").FunctionComponentElement<import("react").ProviderProps<import("./hooks/UsersBinding.hooks.js").UsersScope | null>>;
+    };
+    kitNeeds: import("@jini-ai/ui-kit").KitNeeds<"Notice" | "Spinner" | "Badge" | "Menu" | "Button" | "TextField" | "Select" | "ConfirmDialog">;
+};
+export declare function members(_required: Record<string, never>, _optional?: Record<string, never>): {
+    id: "members";
+    requires: {
+        readonly membersApi: import("@jini-ai/admin/core/module").AdminPortToken<import("../ports.js").MembersApiPort, "jini.identity.membersApi">;
+    };
+    provides: {};
+    messages: {
+        readonly title: "Members";
+        readonly description: "People who have registered an account — review status, resend a sign-in link, or disable access.";
+        readonly loading: "Loading members…";
+        readonly readOnly: "Read-only — member actions require member.manage.";
+    };
+    pages: {
+        readonly members: {
+            readonly path: "/members";
+            readonly label: "Members";
+            readonly permissions: readonly [];
+            readonly nav: {
+                readonly group: "people";
+                readonly icon: "users";
+            };
+            readonly tabs: {
+                readonly members: {
+                    readonly label: "Members";
+                };
+            };
+        };
+    };
+} & {
+    react: {
+        pages: {
+            members: {
+                Page: import("react").LazyExoticComponent<typeof import("./pages/MembersPage.js").default>;
+                tabs: {
+                    members: import("react").LazyExoticComponent<typeof import("./tabs/MembersTab.js").default>;
+                };
+            };
+        };
+        Provider: ({ admin, children }: {
+            admin: import("@jini-ai/admin/core/module").AdminInstance;
+            children: import("react").ReactNode;
+        }, _optional?: Record<string, never>) => import("react").FunctionComponentElement<import("react").ProviderProps<import("./hooks/MembersBinding.hooks.js").MembersScope | null>>;
+    };
+    kitNeeds: import("@jini-ai/ui-kit").KitNeeds<"Notice" | "Spinner" | "Badge" | "Menu" | "Button" | "ConfirmDialog">;
+};
+export declare function auth(_required: Record<string, never>, _optional?: Record<string, never>): {
+    id: "auth";
+    requires: {
+        readonly authApi: import("@jini-ai/admin/core/module").AdminPortToken<import("../ports.js").AuthApiPort, "jini.identity.authApi">;
+    };
+    provides: {};
+    messages: {
+        readonly title: "Sign in to your workspace";
+        readonly submit: "Sign in";
+        readonly busy: "Signing in…";
+        readonly failed: "login failed";
+    };
+    pages: {
+        readonly auth: {
+            readonly path: "/login";
+            readonly label: "Login";
+            readonly permissions: readonly [];
+            readonly tabs: {
+                readonly auth: {
+                    readonly label: "Login";
+                };
+            };
+        };
+    };
+} & {
+    react: {
+        pages: {
+            auth: {
+                Page: import("react").LazyExoticComponent<typeof import("./pages/LoginPage.js").default>;
+                tabs: {
+                    auth: import("react").LazyExoticComponent<typeof import("./tabs/AuthTab.js").default>;
+                };
+            };
+        };
+        Provider: ({ admin, children }: {
+            admin: import("@jini-ai/admin/core/module").AdminInstance;
+            children: import("react").ReactNode;
+        }, _optional?: Record<string, never>) => import("react").FunctionComponentElement<import("react").ProviderProps<import("./hooks/AuthBinding.hooks.js").AuthScope | null>>;
+    };
+    kitNeeds: import("@jini-ai/ui-kit").KitNeeds<"Notice" | "Spinner" | "Button" | "TextField">;
+};
+export type { UsersPageProps } from './hooks/UsersBinding.hooks.js';
+export type { MembersPageProps } from './hooks/MembersBinding.hooks.js';
+export type { AuthPageProps } from './hooks/AuthBinding.hooks.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/admin/react/index.js

@@ -0,0 +1,32 @@
+import { needs } from '@jini-ai/ui-kit';
+import { rolesModule } from '../roles.module.js';
+import { createRolesBinding } from './hooks/RolesBinding.hooks.js';
+export const rolesKitNeeds = needs({ id: 'identity.roles', components: ['Button', 'TextField', 'Menu', 'Tabs', 'Notice', 'Spinner', 'Badge', 'ConfirmDialog'] });
+/** Optional composition surface. Identity services remain owned by user-management. */
+export function roles(_required, _optional = {}) {
+    const module = { ...rolesModule };
+    // createAdmin scopes by descriptor identity; bind the exact enriched object being composed.
+    return Object.assign(module, { react: createRolesBinding({ module }), kitNeeds: rolesKitNeeds });
+}
+import { usersModule } from '../users.module.js';
+import { membersModule } from '../members.module.js';
+import { authModule } from '../auth.module.js';
+import { createUsersBinding } from './hooks/UsersBinding.hooks.js';
+import { createMembersBinding } from './hooks/MembersBinding.hooks.js';
+import { createAuthBinding } from './hooks/AuthBinding.hooks.js';
+export const usersKitNeeds = needs({ id: 'identity.users', components: ['Button', 'TextField', 'Select', 'Menu', 'Notice', 'Spinner', 'Badge', 'ConfirmDialog'] });
+export const membersKitNeeds = needs({ id: 'identity.members', components: ['Button', 'Menu', 'Notice', 'Spinner', 'Badge', 'ConfirmDialog'] });
+export const authKitNeeds = needs({ id: 'identity.auth', components: ['Button', 'TextField', 'Notice', 'Spinner'] });
+export function users(_required, _optional = {}) {
+    const module = { ...usersModule };
+    return Object.assign(module, { react: createUsersBinding({ module }), kitNeeds: usersKitNeeds });
+}
+export function members(_required, _optional = {}) {
+    const module = { ...membersModule };
+    return Object.assign(module, { react: createMembersBinding({ module }), kitNeeds: membersKitNeeds });
+}
+export function auth(_required, _optional = {}) {
+    const module = { ...authModule };
+    return Object.assign(module, { react: createAuthBinding({ module }), kitNeeds: authKitNeeds });
+}
+//# sourceMappingURL=index.js.map

package/dist/admin/react/pages/LoginPage.d.ts

@@ -0,0 +1,3 @@
+import type { AuthPageProps } from '../hooks/AuthBinding.hooks.js';
+export default function LoginPage(props: AuthPageProps, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=LoginPage.d.ts.map

package/dist/admin/react/pages/LoginPage.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Suspense } from 'react';
+import { Notice, Spinner } from '@jini-ai/ui-kit/react';
+import { AuthViewContext, useLoginPage } from '../hooks/LoginPage.hooks.js';
+export default function LoginPage(props, _optional = {}) {
+    const v = useLoginPage(props);
+    if (!v.visible)
+        return _jsx(Notice, { children: "Login is unavailable." });
+    if (!v.view)
+        return _jsx(Spinner, { label: "Loading login\u2026" });
+    return _jsx(AuthViewContext.Provider, { value: v.view, children: _jsxs("div", { className: "login-screen", children: [_jsx("h1", { children: v.title }), _jsx(Suspense, { fallback: _jsx(Spinner, { label: "Loading login\u2026" }), children: v.content })] }) });
+}
+//# sourceMappingURL=LoginPage.js.map

package/dist/admin/react/pages/MembersPage.d.ts

@@ -0,0 +1,3 @@
+import type { MembersPageProps } from '../hooks/MembersBinding.hooks.js';
+export default function MembersPage(props: MembersPageProps, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=MembersPage.d.ts.map

package/dist/admin/react/pages/MembersPage.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Suspense } from 'react';
+import { Notice, Spinner, Button } from '@jini-ai/ui-kit/react';
+import { MembersViewContext, useMembersPage } from '../hooks/MembersPage.hooks.js';
+import { membersMessagesEn as m } from '../../messages.en.js';
+import { MembersConfirmation } from '../components/MembersConfirmation.js';
+export default function MembersPage(props, _optional = {}) {
+    const v = useMembersPage(props);
+    if (!v.visible)
+        return _jsx(Notice, { children: "Members administration is unavailable." });
+    if (!v.state)
+        return _jsx(Spinner, { label: m.loading });
+    if (v.state.error)
+        return _jsxs(Notice, { tone: "danger", children: [v.state.error, _jsx(Button, { onPress: v.retry, children: "Retry" })] });
+    if (!v.view || !v.state.members)
+        return _jsx(Spinner, { label: m.loading });
+    return _jsx(MembersViewContext.Provider, { value: v.view, children: _jsxs("div", { className: "page", children: [_jsxs("header", { children: [_jsx("p", { children: "People" }), _jsx("h1", { children: m.title }), _jsx("p", { children: m.description })] }), !v.canManage ? _jsx(Notice, { children: m.readOnly }) : null, _jsx(Suspense, { fallback: _jsx(Spinner, { label: m.loading }), children: v.content }), _jsx(MembersConfirmation, {})] }) });
+}
+//# sourceMappingURL=MembersPage.js.map

package/dist/admin/react/pages/RolesPage.d.ts

@@ -0,0 +1,3 @@
+import type { RolesPageProps } from '../hooks/RolesBinding.hooks.js';
+export default function RolesPage(props: RolesPageProps, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=RolesPage.d.ts.map

package/dist/admin/react/pages/RolesPage.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Suspense } from 'react';
+import { Button, Notice, Spinner, Tabs } from '@jini-ai/ui-kit/react';
+import { RolesViewContext, useRolesPage } from '../hooks/RolesPage.hooks.js';
+import { DestructiveDialog } from '../components/DestructiveDialog.js';
+import { rolesMessagesEn as m } from '../../messages.en.js';
+export default function RolesPage(props, _optional = {}) {
+    const v = useRolesPage(props);
+    if (v.hidden)
+        return _jsx(Notice, { children: "Roles administration is unavailable." });
+    if (!v.state)
+        return _jsx(Spinner, { label: m.loading });
+    if (v.state.error)
+        return _jsxs(Notice, { tone: "danger", children: [v.state.error, _jsx(Button, { onPress: v.retry, children: "Retry" })] });
+    if (!v.view || !v.state.roles || !v.state.policies)
+        return _jsx(Spinner, { label: m.loading });
+    return _jsx(RolesViewContext.Provider, { value: v.view, children: _jsxs("div", { className: "page", children: [_jsxs("header", { children: [_jsx("p", { children: m.people }), _jsx("h1", { children: m.title }), _jsx("p", { children: m.description })] }), !v.canManage ? _jsx(Notice, { children: m.readOnly }) : null, v.state.rowError ? _jsx(Notice, { tone: "danger", children: v.state.rowError }) : null, v.noTabs ? _jsx(Notice, { children: "No roles tabs are enabled." }) : _jsx(Suspense, { fallback: _jsx(Spinner, { label: m.loading }), children: _jsx(Tabs, { label: m.title, value: v.tab, items: v.items, onValueChange: v.changeTab }) }), _jsx(DestructiveDialog, { ...v.confirm })] }) });
+}
+//# sourceMappingURL=RolesPage.js.map

package/dist/admin/react/pages/UsersPage.d.ts

@@ -0,0 +1,3 @@
+import type { UsersPageProps } from '../hooks/UsersBinding.hooks.js';
+export default function UsersPage(props: UsersPageProps, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=UsersPage.d.ts.map

package/dist/admin/react/pages/UsersPage.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Suspense } from 'react';
+import { Button, Notice, Spinner } from '@jini-ai/ui-kit/react';
+import { useUsersPage, UsersViewContext } from '../hooks/UsersPage.hooks.js';
+import { usersMessagesEn as m } from '../../messages.en.js';
+import { UsersConfirmation } from '../components/UsersConfirmation.js';
+export default function UsersPage(props, _optional = {}) {
+    const v = useUsersPage(props);
+    if (!v.visible)
+        return _jsx(Notice, { children: "Users administration is unavailable." });
+    if (!v.state)
+        return _jsx(Spinner, { label: m.loading });
+    if (v.state.error)
+        return _jsxs(Notice, { tone: "danger", children: [v.state.error, _jsx(Button, { onPress: v.retry, children: "Retry" })] });
+    if (!v.view || !v.state.users || !v.state.roles || !v.state.policies)
+        return _jsx(Spinner, { label: m.loading });
+    return _jsx(UsersViewContext.Provider, { value: v.view, children: _jsxs("div", { className: "page", children: [_jsxs("header", { children: [_jsx("p", { children: "People" }), _jsx("h1", { children: m.title }), _jsx("p", { children: m.description }), _jsx("p", { children: m.passwordHelp })] }), v.readOnly ? _jsx(Notice, { children: m.readOnly }) : null, _jsx(Notice, { children: m.protected }), v.state.rowError ? _jsx(Notice, { tone: "danger", children: v.state.rowError }) : null, v.state.notice ? _jsx(Notice, { tone: "success", children: v.state.notice }) : null, _jsx(Suspense, { fallback: _jsx(Spinner, { label: m.loading }), children: v.content }), _jsx(UsersConfirmation, {})] }) });
+}
+//# sourceMappingURL=UsersPage.js.map

package/dist/admin/react/tabs/AuthTab.d.ts

@@ -0,0 +1,4 @@
+export default function AuthTab(_props?: {
+    readonly params?: Readonly<Record<string, unknown>>;
+}, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=AuthTab.d.ts.map

package/dist/admin/react/tabs/AuthTab.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, TextField, Notice } from '@jini-ai/ui-kit/react';
+import { useAuthTab } from '../hooks/LoginPage.hooks.js';
+export default function AuthTab(_props = {}, _optional = {}) {
+    const v = useAuthTab({});
+    return _jsxs("form", { onSubmit: v.submit, children: [_jsx(TextField, { label: "Username", attrs: v.usernameAttrs, value: v.s.username, onValueChange: v.username }), _jsx(TextField, { label: "Password", attrs: v.passwordAttrs, type: "password", value: v.s.password, onValueChange: v.password }), v.s.error ? _jsx(Notice, { tone: "danger", children: v.s.error }) : null, _jsx(Button, { type: "submit", pending: v.s.busy, children: v.submitLabel })] });
+}
+//# sourceMappingURL=AuthTab.js.map

package/dist/admin/react/tabs/MembersTab.d.ts

@@ -0,0 +1,4 @@
+export default function MembersTab(_props?: {
+    readonly params?: Readonly<Record<string, unknown>>;
+}, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=MembersTab.d.ts.map