@byline/admin 2.4.0 → 2.4.2

package/dist/modules/admin-roles/components/create.js

@@ -0,0 +1,177 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { revalidateLogic, useForm } from "@tanstack/react-form-start";
+import { Alert, Button, Input, LoaderEllipsis, TextArea } from "@byline/ui/react";
+import classnames from "classnames";
+import { z } from "zod";
+import { useBylineAdminServices } from "../../../services/admin-services-context.js";
+import create_module from "./create.module.js";
+const createAdminRoleFormSchema = z.object({
+    name: z.string().min(1, 'Name is required').max(128, 'Name must not exceed 128 characters'),
+    machine_name: z.string().min(1, 'Machine name is required').max(128, 'Machine name must not exceed 128 characters').regex(/^[a-z0-9][a-z0-9_-]*$/, {
+        message: 'Lowercase letters, numbers, hyphens, and underscores only'
+    }),
+    description: z.string().max(2000, "Description must not exceed 2000 characters")
+});
+const initialValues = {
+    name: '',
+    machine_name: '',
+    description: ''
+};
+function normaliseText(value) {
+    return value.trim().length > 0 ? value : null;
+}
+function CreateAdminRole({ onClose, onSuccess }) {
+    const { createAdminRole } = useBylineAdminServices();
+    const [formError, setFormError] = useState(null);
+    const form = useForm({
+        defaultValues: initialValues,
+        validationLogic: revalidateLogic({
+            mode: 'blur',
+            modeAfterSubmission: 'change'
+        }),
+        validators: {
+            onDynamic: createAdminRoleFormSchema
+        },
+        onSubmit: async ({ value })=>{
+            setFormError(null);
+            try {
+                const created = await createAdminRole({
+                    data: {
+                        name: value.name.trim(),
+                        machine_name: value.machine_name.trim(),
+                        description: normaliseText(value.description)
+                    }
+                });
+                form.reset(initialValues);
+                onSuccess?.(created);
+            } catch (err) {
+                const code = getErrorCode(err);
+                if ('admin.roles.machineNameInUse' === code) return void form.setFieldMeta('machine_name', (meta)=>({
+                        ...meta,
+                        errorMap: {
+                            ...meta.errorMap,
+                            onServer: 'This machine name is already in use.'
+                        },
+                        errors: [
+                            'This machine name is already in use.'
+                        ]
+                    }));
+                setFormError('Could not create this admin role. Please try again.');
+            }
+        }
+    });
+    return /*#__PURE__*/ jsx("div", {
+        className: classnames('byline-role-create-wrap', create_module.wrap),
+        children: /*#__PURE__*/ jsxs("form", {
+            noValidate: true,
+            onSubmit: (event)=>{
+                event.preventDefault();
+                event.stopPropagation();
+                form.handleSubmit();
+            },
+            className: classnames('byline-role-create-form', create_module.form),
+            children: [
+                formError ? /*#__PURE__*/ jsx(Alert, {
+                    intent: "danger",
+                    children: formError
+                }) : null,
+                /*#__PURE__*/ jsx(form.Field, {
+                    name: "name",
+                    children: (field)=>/*#__PURE__*/ jsx(Input, {
+                            label: "Name",
+                            id: "new-role-name",
+                            name: field.name,
+                            value: field.state.value,
+                            onBlur: field.handleBlur,
+                            onChange: (e)=>field.handleChange(e.currentTarget.value),
+                            error: field.state.meta.errors.length > 0,
+                            errorText: firstError(field.state.meta.errors),
+                            helpText: "Human-readable label, e.g. 'Editor'.",
+                            required: true
+                        })
+                }),
+                /*#__PURE__*/ jsx(form.Field, {
+                    name: "machine_name",
+                    children: (field)=>/*#__PURE__*/ jsx(Input, {
+                            label: "Machine name",
+                            id: "new-role-machine-name",
+                            name: field.name,
+                            value: field.state.value,
+                            onBlur: field.handleBlur,
+                            onChange: (e)=>field.handleChange(e.currentTarget.value),
+                            error: field.state.meta.errors.length > 0,
+                            errorText: firstError(field.state.meta.errors),
+                            helpText: "Stable code-side handle, e.g. 'editor'. Cannot be changed later.",
+                            required: true
+                        })
+                }),
+                /*#__PURE__*/ jsx(form.Field, {
+                    name: "description",
+                    children: (field)=>/*#__PURE__*/ jsx(TextArea, {
+                            label: "Description",
+                            id: "new-role-description",
+                            name: field.name,
+                            value: field.state.value,
+                            onBlur: field.handleBlur,
+                            onChange: (e)=>field.handleChange(e.currentTarget.value),
+                            error: field.state.meta.errors.length > 0,
+                            errorText: firstError(field.state.meta.errors),
+                            rows: 3
+                        })
+                }),
+                /*#__PURE__*/ jsxs("div", {
+                    className: classnames('byline-role-create-actions', create_module.actions),
+                    children: [
+                        /*#__PURE__*/ jsx(Button, {
+                            type: "button",
+                            intent: "secondary",
+                            size: "sm",
+                            onClick: onClose,
+                            className: classnames('byline-role-create-action', create_module.action),
+                            children: "Cancel"
+                        }),
+                        /*#__PURE__*/ jsx(form.Subscribe, {
+                            selector: (state)=>({
+                                    canSubmit: state.canSubmit,
+                                    isSubmitting: state.isSubmitting
+                                }),
+                            children: ({ canSubmit, isSubmitting })=>/*#__PURE__*/ jsx(Button, {
+                                    size: "sm",
+                                    intent: "primary",
+                                    type: "submit",
+                                    disabled: !canSubmit || isSubmitting,
+                                    className: classnames('byline-role-create-action', create_module.action),
+                                    children: true === isSubmitting ? /*#__PURE__*/ jsx(LoaderEllipsis, {
+                                        size: 42
+                                    }) : 'Save'
+                                })
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+}
+function firstError(errors) {
+    for (const err of errors){
+        if ('string' == typeof err) return err;
+        if (err && 'object' == typeof err && 'message' in err) {
+            const msg = err.message;
+            if ('string' == typeof msg) return msg;
+        }
+    }
+}
+function getErrorCode(err) {
+    if (err && 'object' == typeof err) {
+        const e = err;
+        if ('string' == typeof e.code) return e.code;
+        if (e.cause && 'object' == typeof e.cause && 'code' in e.cause) {
+            const cause = e.cause;
+            if ('string' == typeof cause.code) return cause.code;
+        }
+    }
+    return null;
+}
+export { CreateAdminRole };

package/dist/modules/admin-roles/components/create.module.js

@@ -0,0 +1,8 @@
+import "./create_module.css";
+const create_module = {
+    wrap: "wrap-TO0OTc",
+    form: "form-wmLTJg",
+    actions: "actions-mZfReT",
+    action: "action-yPyZD3"
+};
+export default create_module;

package/dist/modules/admin-roles/components/create_module.css

@@ -0,0 +1,27 @@
+:is(.wrap-TO0OTc, .byline-role-create-wrap) {
+  gap: var(--spacing-8);
+  padding: var(--spacing-4);
+  margin-top: var(--spacing-4);
+  flex-direction: column;
+  display: flex;
+}
+
+:is(.form-wmLTJg, .byline-role-create-form) {
+  gap: var(--spacing-16);
+  padding-top: var(--spacing-8);
+  flex-direction: column;
+  display: flex;
+}
+
+:is(.actions-mZfReT, .byline-role-create-actions) {
+  justify-content: flex-end;
+  align-items: center;
+  gap: var(--spacing-8);
+  margin-top: var(--spacing-16);
+  display: flex;
+}
+
+:is(.action-yPyZD3, .byline-role-create-action) {
+  min-width: 4rem;
+}
+

package/dist/modules/admin-roles/components/permissions.d.ts

@@ -0,0 +1,10 @@
+import type { ListRegisteredAbilitiesResponse, SetRoleAbilitiesResponse } from '../../admin-permissions/index.js';
+import type { AdminRoleResponse } from '../index.js';
+interface RolePermissionsProps {
+    role: AdminRoleResponse;
+    registered: ListRegisteredAbilitiesResponse;
+    initialAbilities: string[];
+    onSaved?: (response: SetRoleAbilitiesResponse) => void;
+}
+export declare function RolePermissions({ role, registered, initialAbilities, onSaved, }: RolePermissionsProps): import("react").JSX.Element;
+export {};

package/dist/modules/admin-roles/components/permissions.js

@@ -0,0 +1,303 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from "react";
+import { Alert, Button, Checkbox, LoaderEllipsis } from "@byline/ui/react";
+import classnames from "classnames";
+import { useBylineAdminServices } from "../../../services/admin-services-context.js";
+import permissions_module from "./permissions.module.js";
+function setsEqual(a, b) {
+    if (a.size !== b.size) return false;
+    for (const item of a)if (!b.has(item)) return false;
+    return true;
+}
+function GroupSection({ group, selected, mode, saving, onToggle, onSelectAll, onClearAll }) {
+    const groupKeys = useMemo(()=>group.abilities.map((a)=>a.key), [
+        group.abilities
+    ]);
+    const selectedInGroup = groupKeys.filter((key)=>selected.has(key)).length;
+    const isEdit = 'edit' === mode;
+    return /*#__PURE__*/ jsxs("div", {
+        className: classnames('byline-role-permissions-group', permissions_module.group),
+        children: [
+            /*#__PURE__*/ jsxs("div", {
+                className: classnames('byline-role-permissions-group-head', permissions_module["group-head"]),
+                children: [
+                    /*#__PURE__*/ jsxs("div", {
+                        children: [
+                            /*#__PURE__*/ jsx("span", {
+                                className: classnames('byline-role-permissions-group-name', permissions_module["group-name"]),
+                                children: group.group
+                            }),
+                            /*#__PURE__*/ jsxs("span", {
+                                className: classnames('muted', 'byline-role-permissions-group-count', permissions_module["group-count"]),
+                                children: [
+                                    selectedInGroup,
+                                    " of ",
+                                    group.abilities.length,
+                                    " ",
+                                    isEdit ? 'selected' : 'granted'
+                                ]
+                            })
+                        ]
+                    }),
+                    isEdit ? /*#__PURE__*/ jsxs("div", {
+                        className: classnames('byline-role-permissions-group-buttons', permissions_module["group-buttons"]),
+                        children: [
+                            /*#__PURE__*/ jsx(Button, {
+                                size: "xs",
+                                intent: "secondary",
+                                type: "button",
+                                disabled: saving || selectedInGroup === group.abilities.length,
+                                onClick: ()=>onSelectAll(groupKeys),
+                                children: "Select all"
+                            }),
+                            /*#__PURE__*/ jsx(Button, {
+                                size: "xs",
+                                intent: "secondary",
+                                type: "button",
+                                disabled: saving || 0 === selectedInGroup,
+                                onClick: ()=>onClearAll(groupKeys),
+                                children: "Clear"
+                            })
+                        ]
+                    }) : null
+                ]
+            }),
+            /*#__PURE__*/ jsx("div", {
+                className: classnames('byline-role-permissions-grid', permissions_module.grid),
+                children: group.abilities.map((ability)=>/*#__PURE__*/ jsxs("div", {
+                        className: classnames('byline-role-permissions-row', permissions_module.row),
+                        children: [
+                            /*#__PURE__*/ jsx(Checkbox, {
+                                id: `ability-${ability.key}`,
+                                name: `ability-${ability.key}`,
+                                checked: selected.has(ability.key),
+                                disabled: !isEdit || saving,
+                                onCheckedChange: (checked)=>onToggle(ability.key, true === checked),
+                                containerClasses: classnames('byline-role-permissions-checkbox-auto', permissions_module["checkbox-auto"]),
+                                componentClasses: classnames('byline-role-permissions-checkbox-auto', permissions_module["checkbox-auto"])
+                            }),
+                            /*#__PURE__*/ jsxs("label", {
+                                htmlFor: `ability-${ability.key}`,
+                                className: classnames('byline-role-permissions-label', permissions_module.label, isEdit && [
+                                    'byline-role-permissions-label-edit',
+                                    permissions_module["label-edit"]
+                                ]),
+                                children: [
+                                    /*#__PURE__*/ jsxs("div", {
+                                        className: classnames('byline-role-permissions-label-head', permissions_module["label-head"]),
+                                        children: [
+                                            /*#__PURE__*/ jsx("span", {
+                                                className: classnames('byline-role-permissions-label-name', permissions_module["label-name"]),
+                                                children: ability.label
+                                            }),
+                                            /*#__PURE__*/ jsx("code", {
+                                                className: classnames('byline-role-permissions-key', permissions_module.key),
+                                                children: ability.key
+                                            })
+                                        ]
+                                    }),
+                                    ability.description ? /*#__PURE__*/ jsx("p", {
+                                        className: classnames('muted', "byline-role-permissions-description", permissions_module.description),
+                                        children: ability.description
+                                    }) : null
+                                ]
+                            })
+                        ]
+                    }, ability.key))
+            })
+        ]
+    });
+}
+function RolePermissions({ role, registered, initialAbilities, onSaved }) {
+    const { setRoleAbilities } = useBylineAdminServices();
+    const [mode, setMode] = useState('view');
+    const [initialSet, setInitialSet] = useState(()=>new Set(initialAbilities));
+    const [selected, setSelected] = useState(()=>new Set(initialAbilities));
+    const [saving, setSaving] = useState(false);
+    const [error, setError] = useState(null);
+    const isDirty = !setsEqual(selected, initialSet);
+    const totalSelected = selected.size;
+    function handleToggle(key, checked) {
+        if ('edit' !== mode) return;
+        setSelected((current)=>{
+            const next = new Set(current);
+            if (checked) next.add(key);
+            else next.delete(key);
+            return next;
+        });
+    }
+    function handleSelectAll(groupKeys) {
+        setSelected((current)=>{
+            const next = new Set(current);
+            for (const key of groupKeys)next.add(key);
+            return next;
+        });
+    }
+    function handleClearAll(groupKeys) {
+        setSelected((current)=>{
+            const next = new Set(current);
+            for (const key of groupKeys)next.delete(key);
+            return next;
+        });
+    }
+    function handleCancel() {
+        setSelected(new Set(initialSet));
+        setError(null);
+        setMode('view');
+    }
+    function handleEnterEdit() {
+        setError(null);
+        setMode('edit');
+    }
+    function handleEnterView() {
+        if (isDirty) return;
+        setError(null);
+        setMode('view');
+    }
+    async function handleSave() {
+        if (saving) return;
+        setSaving(true);
+        setError(null);
+        try {
+            const response = await setRoleAbilities({
+                data: {
+                    id: role.id,
+                    abilities: Array.from(selected)
+                }
+            });
+            const storedSet = new Set(response.abilities);
+            setInitialSet(storedSet);
+            setSelected(new Set(storedSet));
+            onSaved?.(response);
+        } catch (err) {
+            const code = getErrorCode(err);
+            if ('admin.permissions.roleNotFound' === code) setError('This role no longer exists.');
+            else 'admin.permissions.abilityUnregistered' === code ? setError('One or more selected abilities are no longer registered. Reload the page and try again.') : setError('Could not save permissions. Please try again.');
+        } finally{
+            setSaving(false);
+        }
+    }
+    const isEdit = 'edit' === mode;
+    return /*#__PURE__*/ jsxs("div", {
+        className: classnames('byline-role-permissions-wrap', permissions_module.wrap),
+        children: [
+            /*#__PURE__*/ jsxs("div", {
+                className: classnames('byline-role-permissions-toolbar', permissions_module.toolbar),
+                children: [
+                    /*#__PURE__*/ jsx(ModeToggle, {
+                        mode: mode,
+                        dirty: isDirty,
+                        saving: saving,
+                        onView: handleEnterView,
+                        onEdit: handleEnterEdit
+                    }),
+                    /*#__PURE__*/ jsxs("p", {
+                        className: classnames('muted', 'byline-role-permissions-counter', permissions_module.counter),
+                        children: [
+                            /*#__PURE__*/ jsx("span", {
+                                className: classnames('byline-role-permissions-counter-num', permissions_module["counter-num"]),
+                                children: totalSelected
+                            }),
+                            ' ',
+                            "of",
+                            ' ',
+                            /*#__PURE__*/ jsx("span", {
+                                className: classnames('byline-role-permissions-counter-num', permissions_module["counter-num"]),
+                                children: registered.total
+                            }),
+                            ' ',
+                            isEdit ? 'selected' : 'granted',
+                            " for ",
+                            role.name
+                        ]
+                    }),
+                    isEdit && isDirty ? /*#__PURE__*/ jsxs("div", {
+                        className: classnames('byline-role-permissions-actions', permissions_module.actions),
+                        children: [
+                            /*#__PURE__*/ jsx(Button, {
+                                type: "button",
+                                intent: "secondary",
+                                size: "xs",
+                                onClick: handleCancel,
+                                disabled: saving,
+                                className: classnames('byline-role-permissions-action', permissions_module.action),
+                                children: "Cancel"
+                            }),
+                            /*#__PURE__*/ jsx(Button, {
+                                type: "button",
+                                intent: "primary",
+                                size: "xs",
+                                onClick: ()=>void handleSave(),
+                                disabled: saving,
+                                className: classnames('byline-role-permissions-action', permissions_module.action),
+                                children: saving ? /*#__PURE__*/ jsx(LoaderEllipsis, {
+                                    size: 30
+                                }) : 'Save'
+                            })
+                        ]
+                    }) : null
+                ]
+            }),
+            error ? /*#__PURE__*/ jsx(Alert, {
+                intent: "danger",
+                children: error
+            }) : null,
+            /*#__PURE__*/ jsx("div", {
+                className: classnames('byline-role-permissions-groups', permissions_module.groups),
+                children: registered.groups.map((group)=>/*#__PURE__*/ jsx(GroupSection, {
+                        group: group,
+                        selected: selected,
+                        mode: mode,
+                        saving: saving,
+                        onToggle: handleToggle,
+                        onSelectAll: handleSelectAll,
+                        onClearAll: handleClearAll
+                    }, group.group))
+            })
+        ]
+    });
+}
+function ModeToggle({ mode, dirty, saving, onView, onEdit }) {
+    const isView = 'view' === mode;
+    const isEdit = 'edit' === mode;
+    const viewDisabled = dirty || saving;
+    const editDisabled = saving;
+    return /*#__PURE__*/ jsxs("div", {
+        role: "group",
+        "aria-label": "Permissions mode",
+        className: classnames('byline-role-permissions-mode-toggle', permissions_module["mode-toggle"]),
+        children: [
+            /*#__PURE__*/ jsx("button", {
+                type: "button",
+                onClick: onView,
+                disabled: viewDisabled,
+                className: classnames('byline-role-permissions-mode-button', permissions_module["mode-button"], isView && [
+                    'byline-role-permissions-mode-button-active',
+                    permissions_module["mode-button-active"]
+                ], viewDisabled && !isView && [
+                    'byline-role-permissions-mode-button-disabled',
+                    permissions_module["mode-button-disabled"]
+                ]),
+                children: "View"
+            }),
+            /*#__PURE__*/ jsx("button", {
+                type: "button",
+                onClick: onEdit,
+                disabled: editDisabled,
+                className: classnames('byline-role-permissions-mode-button', 'byline-role-permissions-mode-button-divider', permissions_module["mode-button"], permissions_module["mode-button-divider"], isEdit && [
+                    'byline-role-permissions-mode-button-active',
+                    permissions_module["mode-button-active"]
+                ], editDisabled && !isEdit && [
+                    'byline-role-permissions-mode-button-disabled',
+                    permissions_module["mode-button-disabled"]
+                ]),
+                children: "Edit"
+            })
+        ]
+    });
+}
+function getErrorCode(err) {
+    return 'string' == typeof err?.code ? err.code : null;
+}
+export { RolePermissions };

package/dist/modules/admin-roles/components/permissions.module.js

@@ -0,0 +1,44 @@
+import "./permissions_module.css";
+const permissions_module = {
+    wrap: "wrap-oHhxZn",
+    toolbar: "toolbar-xiFHRx",
+    counter: "counter-pkbHZT",
+    "counter-num": "counter-num-zDSQWA",
+    counterNum: "counter-num-zDSQWA",
+    actions: "actions-TSS9AS",
+    action: "action-jzyool",
+    "checkbox-auto": "checkbox-auto-TFunEY",
+    checkboxAuto: "checkbox-auto-TFunEY",
+    groups: "groups-agis2F",
+    group: "group-Xf1YG0",
+    "group-head": "group-head-IUhwe9",
+    groupHead: "group-head-IUhwe9",
+    "group-name": "group-name-jAKMI7",
+    groupName: "group-name-jAKMI7",
+    "group-count": "group-count-BQDjxo",
+    groupCount: "group-count-BQDjxo",
+    "group-buttons": "group-buttons-KZVdZK",
+    groupButtons: "group-buttons-KZVdZK",
+    grid: "grid-tLxHtG",
+    row: "row-Q7NujV",
+    label: "label-wOoMvK",
+    "label-edit": "label-edit-oRTY7d",
+    labelEdit: "label-edit-oRTY7d",
+    "label-head": "label-head-nm1MZV",
+    labelHead: "label-head-nm1MZV",
+    "label-name": "label-name-c9gt0V",
+    labelName: "label-name-c9gt0V",
+    key: "key-ZIoxQA",
+    description: "description-FHyeNa",
+    "mode-toggle": "mode-toggle-rfVYTa",
+    modeToggle: "mode-toggle-rfVYTa",
+    "mode-button": "mode-button-y37cUe",
+    modeButton: "mode-button-y37cUe",
+    "mode-button-active": "mode-button-active-O9hDFq",
+    modeButtonActive: "mode-button-active-O9hDFq",
+    "mode-button-divider": "mode-button-divider-i7CEW9",
+    modeButtonDivider: "mode-button-divider-i7CEW9",
+    "mode-button-disabled": "mode-button-disabled-i9SxhV",
+    modeButtonDisabled: "mode-button-disabled-i9SxhV"
+};
+export default permissions_module;