@orthacms/workspaces-admin 0.0.0-reserve.0

package/dist/lib/presentation/currentWorkspace/index.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import type { Workspace } from '../../domain/types/workspace';
+type CurrentWorkspaceProviderProps = {
+    /** The resolved workspace to expose to the subtree. */
+    workspace: Workspace;
+    children: ReactNode;
+};
+/** Provides the open workspace to everything rendered inside the shell. */
+export declare function CurrentWorkspaceProvider({ workspace, children }: CurrentWorkspaceProviderProps): import("react").JSX.Element;
+/**
+ * Returns the workspace currently open in the shell. Throws when called outside
+ * a {@link WorkspaceShell} — a workspace page is always mounted inside one, so a
+ * missing provider is a wiring bug, not a runtime state to handle.
+ */
+export declare function useCurrentWorkspace(): Workspace;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/currentWorkspace/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/presentation/currentWorkspace/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAwC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAW9D,KAAK,6BAA6B,GAAG;IACjC,uDAAuD;IACvD,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,2EAA2E;AAC3E,wBAAgB,wBAAwB,CAAC,EACrC,SAAS,EACT,QAAQ,EACX,EAAE,6BAA6B,+BAyB/B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,SAAS,CAQ/C"}

package/dist/lib/presentation/currentWorkspace/index.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect } from 'react';
+import { setActiveWorkspaceId } from '@orthacms/utils-admin';
+/**
+ * The workspace currently open in the shell. Provided by {@link WorkspaceShell}
+ * once it has resolved the `:id` route param against the workspaces list, and
+ * read by any page or rail button mounted inside the shell via
+ * {@link useCurrentWorkspace} — so a feature plugin never has to re-read the
+ * `:id` param or re-fetch the workspace itself.
+ */
+const CurrentWorkspaceContext = createContext(null);
+/** Provides the open workspace to everything rendered inside the shell. */
+export function CurrentWorkspaceProvider({ workspace, children }) {
+    // Sync the shared apiClient's workspace header during render — the parent
+    // renders before its children, so the header is set before any child's
+    // data hook fires its first request (a useEffect here runs *after* those
+    // child effects, leaving the first request unscoped). Idempotent.
+    setActiveWorkspaceId(workspace.id);
+    // Re-assert on mount and whenever the open workspace changes, so switching
+    // workspaces re-scopes the shared header. There is deliberately **no unmount
+    // cleanup**: nulling the header on unmount races with in-flight/background
+    // refetches (e.g. a window-focus refetch of a content list after navigating
+    // to the workspaces grid), which would then fire with no `X-Workspace-Id` and
+    // 400 at the guard. A lingering id is harmless — the header is only honored by
+    // workspace-scoped routes, which always live inside a shell that re-sets it on
+    // entry (render-time set above + this effect) before any request runs. This
+    // also sidesteps the StrictMode setup → cleanup → setup interim-null window.
+    useEffect(() => {
+        setActiveWorkspaceId(workspace.id);
+    }, [workspace.id]);
+    return (_jsx(CurrentWorkspaceContext.Provider, { value: workspace, children: children }));
+}
+/**
+ * Returns the workspace currently open in the shell. Throws when called outside
+ * a {@link WorkspaceShell} — a workspace page is always mounted inside one, so a
+ * missing provider is a wiring bug, not a runtime state to handle.
+ */
+export function useCurrentWorkspace() {
+    const workspace = useContext(CurrentWorkspaceContext);
+    if (!workspace) {
+        throw new Error('useCurrentWorkspace must be used inside a WorkspaceShell route.');
+    }
+    return workspace;
+}

package/dist/lib/presentation/hooks/useBasicsSchema/index.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+/**
+ * Builds the basics-step Zod schema with localized messages. Mirrors the
+ * server `CreateWorkspaceDto` through the shared {@link NAME_MAX} /
+ * {@link DESCRIPTION_MAX} constants (name required, ≤120; slug required, matching
+ * the {@link Slug} value object's rule; description ≤2000). The slug shape check
+ * delegates to the shared {@link Slug} VO so it can't drift from the availability
+ * hook or the server. Rebuilt when the locale changes so the copy stays in sync
+ * with the UI. Slug *availability* is checked separately by `useSlugAvailability`
+ * — this only validates shape.
+ */
+export declare function useBasicsSchema(): z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/hooks/useBasicsSchema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/hooks/useBasicsSchema/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4BxB;;;;;;;;;GASG;AACH,wBAAgB,eAAe;;;;kBAwC9B"}

package/dist/lib/presentation/hooks/useBasicsSchema/index.js

@@ -0,0 +1,71 @@
+import { useMemo } from 'react';
+import { defineMessages, useIntl } from 'react-intl';
+import { z } from 'zod';
+import { Slug } from '../../../domain/slug';
+import { DESCRIPTION_MAX, NAME_MAX } from '../../../domain/workspaceLimits';
+/** Validation copy for the basics step, co-located with the schema. */
+const messages = defineMessages({
+    nameRequired: {
+        id: 'workspaces.create.basics.nameRequired',
+        defaultMessage: 'Workspace name is required.'
+    },
+    nameTooLong: {
+        id: 'workspaces.create.basics.nameTooLong',
+        defaultMessage: 'Name must be at most {max} characters.'
+    },
+    slugRequired: {
+        id: 'workspaces.create.basics.slugRequired',
+        defaultMessage: 'Slug is required.'
+    },
+    slugPattern: {
+        id: 'workspaces.create.basics.slugPattern',
+        defaultMessage: 'Use lowercase letters, numbers, and hyphens only.'
+    },
+    descriptionTooLong: {
+        id: 'workspaces.create.basics.descriptionTooLong',
+        defaultMessage: 'Description must be at most {max} characters.'
+    }
+});
+/**
+ * Builds the basics-step Zod schema with localized messages. Mirrors the
+ * server `CreateWorkspaceDto` through the shared {@link NAME_MAX} /
+ * {@link DESCRIPTION_MAX} constants (name required, ≤120; slug required, matching
+ * the {@link Slug} value object's rule; description ≤2000). The slug shape check
+ * delegates to the shared {@link Slug} VO so it can't drift from the availability
+ * hook or the server. Rebuilt when the locale changes so the copy stays in sync
+ * with the UI. Slug *availability* is checked separately by `useSlugAvailability`
+ * — this only validates shape.
+ */
+export function useBasicsSchema() {
+    const intl = useIntl();
+    return useMemo(() => z.object({
+        name: z
+            .string()
+            .trim()
+            .min(1, {
+            message: intl.formatMessage(messages.nameRequired)
+        })
+            .max(NAME_MAX, {
+            message: intl.formatMessage(messages.nameTooLong, {
+                max: NAME_MAX
+            })
+        }),
+        slug: z
+            .string()
+            .trim()
+            .min(1, {
+            message: intl.formatMessage(messages.slugRequired)
+        })
+            .refine((value) => Slug.isValid(value), {
+            message: intl.formatMessage(messages.slugPattern)
+        }),
+        description: z
+            .string()
+            .trim()
+            .max(DESCRIPTION_MAX, {
+            message: intl.formatMessage(messages.descriptionTooLong, {
+                max: DESCRIPTION_MAX
+            })
+        })
+    }), [intl]);
+}

package/dist/lib/presentation/hooks/useComboboxList/index.d.ts

@@ -0,0 +1,44 @@
+import { type KeyboardEvent } from 'react';
+/** Arguments for {@link useComboboxList}. */
+export type UseComboboxListArgs = {
+    /** How many options the popover is currently showing. */
+    count: number;
+    /** Whether the popover is open (a closed list has no active option). */
+    open: boolean;
+    /** Commit the option at `index` — called on Enter. */
+    onSelect: (index: number) => void;
+    /** Close the popover — called on Escape. */
+    onDismiss?: () => void;
+};
+/** What {@link useComboboxList} returns. */
+export type UseComboboxListResult = {
+    /** `id` for the `role="listbox"` element, wired to `aria-controls`. */
+    listboxId: string;
+    /** `id` for the option at `index`, wired to `aria-activedescendant`. */
+    optionId: (index: number) => string;
+    /** The active option's id, or `undefined` when nothing is active. */
+    activeId: string | undefined;
+    /** Index of the visually-active option. */
+    activeIndex: number;
+    /** Point the active option at `index` (e.g. on pointer hover). */
+    setActiveIndex: (index: number) => void;
+    /** ↓/↑/Home/End/Enter/Escape handler for the combobox input. */
+    onKeyDown: (event: KeyboardEvent<HTMLInputElement>) => void;
+};
+/**
+ * The keyboard half of the ARIA 1.2 **combobox** pattern for a search input with
+ * a popover list of results.
+ *
+ * Focus deliberately stays in the input — the list is driven by
+ * `aria-activedescendant`, not by moving DOM focus — because a search field the
+ * user is still typing into must not lose focus when results arrive. That is
+ * what lets ↓/↑ walk the options while typing continues to work, and it is the
+ * affordance both typeaheads were missing: previously the only route to a result
+ * was Tab *out of* the input into the popover, which is not what anyone expects
+ * from a search box.
+ *
+ * The caller owns rendering and the `count → action` mapping; this owns the
+ * active index, the id wiring, and the key handling.
+ */
+export declare function useComboboxList({ count, open, onSelect, onDismiss }: UseComboboxListArgs): UseComboboxListResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/hooks/useComboboxList/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/hooks/useComboboxList/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,KAAK,aAAa,EACrB,MAAM,OAAO,CAAC;AAEf,6CAA6C;AAC7C,MAAM,MAAM,mBAAmB,GAAG;IAC9B,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,IAAI,EAAE,OAAO,CAAC;IACd,sDAAsD;IACtD,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CAC1B,CAAC;AAEF,4CAA4C;AAC5C,MAAM,MAAM,qBAAqB,GAAG;IAChC,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,qEAAqE;IACrE,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,gEAAgE;IAChE,SAAS,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC;CAC/D,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,EAC5B,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,SAAS,EACZ,EAAE,mBAAmB,GAAG,qBAAqB,CAuD7C"}

package/dist/lib/presentation/hooks/useComboboxList/index.js

@@ -0,0 +1,62 @@
+import { useCallback, useEffect, useId, useState } from 'react';
+/**
+ * The keyboard half of the ARIA 1.2 **combobox** pattern for a search input with
+ * a popover list of results.
+ *
+ * Focus deliberately stays in the input — the list is driven by
+ * `aria-activedescendant`, not by moving DOM focus — because a search field the
+ * user is still typing into must not lose focus when results arrive. That is
+ * what lets ↓/↑ walk the options while typing continues to work, and it is the
+ * affordance both typeaheads were missing: previously the only route to a result
+ * was Tab *out of* the input into the popover, which is not what anyone expects
+ * from a search box.
+ *
+ * The caller owns rendering and the `count → action` mapping; this owns the
+ * active index, the id wiring, and the key handling.
+ */
+export function useComboboxList({ count, open, onSelect, onDismiss }) {
+    const listboxId = useId();
+    const [activeIndex, setActiveIndex] = useState(0);
+    // Results change under the cursor as the query narrows, so the active option
+    // has to snap back rather than point past the end of a shorter list.
+    useEffect(() => {
+        setActiveIndex(0);
+    }, [count, open]);
+    const optionId = useCallback((index) => `${listboxId}-option-${index}`, [listboxId]);
+    const onKeyDown = useCallback((event) => {
+        if (event.key === 'Escape') {
+            onDismiss?.();
+            return;
+        }
+        if (!open || count === 0)
+            return;
+        if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
+            event.preventDefault();
+            const delta = event.key === 'ArrowDown' ? 1 : -1;
+            setActiveIndex((i) => (i + delta + count) % count);
+            return;
+        }
+        if (event.key === 'Home') {
+            event.preventDefault();
+            setActiveIndex(0);
+            return;
+        }
+        if (event.key === 'End') {
+            event.preventDefault();
+            setActiveIndex(count - 1);
+            return;
+        }
+        if (event.key === 'Enter') {
+            event.preventDefault();
+            onSelect(activeIndex);
+        }
+    }, [activeIndex, count, onDismiss, onSelect, open]);
+    return {
+        listboxId,
+        optionId,
+        activeId: open && count > 0 ? optionId(activeIndex) : undefined,
+        activeIndex,
+        setActiveIndex,
+        onKeyDown
+    };
+}

package/dist/lib/presentation/hooks/useRedirectNotice/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Router state a gated `<Navigate>` carries to the page it lands on, so the
+ * destination can explain why the user is not where they asked to be.
+ */
+export type RedirectNoticeState = {
+    /** Discriminator for the refusal; the destination owns the copy. */
+    redirectNotice?: string;
+};
+/**
+ * Handles the arrival half of a permission redirect.
+ *
+ * A `<Navigate replace>` swaps the page without moving focus or saying
+ * anything: focus stays on `<body>`, so the next Tab restarts at the very top
+ * of the document — above the whole sidebar — and a screen-reader user hears
+ * silence and has to explore to work out where they ended up. This is the SPA
+ * analogue of a silent redirect.
+ *
+ * On arrival it moves focus to the shell's `<main>` (already focusable for the
+ * skip link, so no new markup is needed) and returns the notice key once, for
+ * the caller to render in a `role="status"` region. The router state is then
+ * cleared so a reload or a Back/Forward doesn't replay the announcement.
+ */
+export declare function useRedirectNotice(): string | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/hooks/useRedirectNotice/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/hooks/useRedirectNotice/index.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,oEAAoE;IACpE,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAKF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAsBjD"}

package/dist/lib/presentation/hooks/useRedirectNotice/index.js

@@ -0,0 +1,37 @@
+import { useEffect, useState } from 'react';
+import { useLocation, useNavigate } from 'react-router-dom';
+/** The shell's `<main>`, which is already `tabIndex={-1}` for the skip link. */
+const MAIN_CONTENT_ID = 'main-content';
+/**
+ * Handles the arrival half of a permission redirect.
+ *
+ * A `<Navigate replace>` swaps the page without moving focus or saying
+ * anything: focus stays on `<body>`, so the next Tab restarts at the very top
+ * of the document — above the whole sidebar — and a screen-reader user hears
+ * silence and has to explore to work out where they ended up. This is the SPA
+ * analogue of a silent redirect.
+ *
+ * On arrival it moves focus to the shell's `<main>` (already focusable for the
+ * skip link, so no new markup is needed) and returns the notice key once, for
+ * the caller to render in a `role="status"` region. The router state is then
+ * cleared so a reload or a Back/Forward doesn't replay the announcement.
+ */
+export function useRedirectNotice() {
+    const location = useLocation();
+    const navigate = useNavigate();
+    const incoming = location.state?.redirectNotice ?? null;
+    const [notice, setNotice] = useState(incoming);
+    useEffect(() => {
+        if (!incoming)
+            return;
+        setNotice(incoming);
+        document.getElementById(MAIN_CONTENT_ID)?.focus();
+        // Drop the state so the message is a one-shot: it explains *this*
+        // navigation, not every later visit to the same URL.
+        navigate(location.pathname + location.search, {
+            replace: true,
+            state: null
+        });
+    }, [incoming, location.pathname, location.search, navigate]);
+    return notice;
+}

package/dist/lib/presentation/hooks/useResourceSelection/index.d.ts

@@ -0,0 +1,21 @@
+import type { ResourceSelection } from '../../../domain/types/wizard';
+/** Bound helpers returned by {@link useResourceSelection}. */
+export type ResourceSelectionController = {
+    /** Whether `id` is selected in the current mode. */
+    isSelected: (id: string) => boolean;
+    /** Toggle one id (include list in `specific`, exclude list in `all`). */
+    toggle: (id: string) => void;
+    /** Switch the whole resource to "all" or back to an empty "specific" list. */
+    setAll: (all: boolean) => void;
+    /** Whether the resource is in "all" mode. */
+    isAll: boolean;
+    /** Count of selected items given the total available. */
+    count: number;
+};
+/**
+ * Controlled wrapper over the pure `resourceSelection` helpers. State lives in
+ * the caller (the wizard); this binds the selection + `onChange` into ready
+ * handlers for a selection panel, and derives the selected `count` from `total`.
+ */
+export declare function useResourceSelection(selection: ResourceSelection, onChange: (next: ResourceSelection) => void, total: number): ResourceSelectionController;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/hooks/useResourceSelection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/hooks/useResourceSelection/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAQtE,8DAA8D;AAC9D,MAAM,MAAM,2BAA2B,GAAG;IACtC,oDAAoD;IACpD,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;IACpC,yEAAyE;IACzE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,8EAA8E;IAC9E,MAAM,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/B,6CAA6C;IAC7C,KAAK,EAAE,OAAO,CAAC;IACf,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAChC,SAAS,EAAE,iBAAiB,EAC5B,QAAQ,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,EAC3C,KAAK,EAAE,MAAM,GACd,2BAA2B,CAW7B"}

package/dist/lib/presentation/hooks/useResourceSelection/index.js

@@ -0,0 +1,16 @@
+import { useMemo } from 'react';
+import { count as countSelected, isSelected as isSelectedIn, setAll as setAllMode, toggle as toggleId } from '../../../domain/resourceSelection';
+/**
+ * Controlled wrapper over the pure `resourceSelection` helpers. State lives in
+ * the caller (the wizard); this binds the selection + `onChange` into ready
+ * handlers for a selection panel, and derives the selected `count` from `total`.
+ */
+export function useResourceSelection(selection, onChange, total) {
+    return useMemo(() => ({
+        isSelected: (id) => isSelectedIn(selection, id),
+        toggle: (id) => onChange(toggleId(selection, id)),
+        setAll: (all) => onChange(setAllMode(all)),
+        isAll: selection.mode === 'all',
+        count: countSelected(selection, total)
+    }), [selection, onChange, total]);
+}

package/dist/lib/presentation/hooks/useSlug/index.d.ts

@@ -0,0 +1,28 @@
+import type { SlugStatus, WizardData } from '../../../domain/types/wizard';
+/** Arguments for {@link useSlug}. */
+export type UseSlugArgs = {
+    /** Current basics data (reads `name`, `slug`, `slugEdited`). */
+    data: WizardData;
+    /** Merge a partial patch into the basics data. */
+    update: (patch: Partial<WizardData>) => void;
+};
+/** What {@link useSlug} returns. */
+export type UseSlugResult = {
+    /** Live availability status of the current slug. */
+    status: SlugStatus;
+    /** Name change handler: also auto-fills the slug until it's been edited. */
+    onNameChange: (name: string) => void;
+    /** Direct slug edit — marks the slug as user-owned. */
+    onSlugChange: (slug: string) => void;
+    /** Re-derive the slug from the name and resume auto-fill. */
+    regenerate: () => void;
+};
+/**
+ * Wires the name → slug relationship for the basics step. The slug auto-fills
+ * from the name (via {@link slugify}) until the user edits it; from then on it
+ * is left alone and a regenerate action restores auto-fill. Availability is
+ * tracked by {@link useSlugAvailability}. State lives in the wizard — this only
+ * supplies handlers and the live status.
+ */
+export declare function useSlug({ data, update }: UseSlugArgs): UseSlugResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/hooks/useSlug/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/hooks/useSlug/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE3E,qCAAqC;AACrC,MAAM,MAAM,WAAW,GAAG;IACtB,gEAAgE;IAChE,IAAI,EAAE,UAAU,CAAC;IACjB,kDAAkD;IAClD,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;CAChD,CAAC;AAEF,oCAAoC;AACpC,MAAM,MAAM,aAAa,GAAG;IACxB,oDAAoD;IACpD,MAAM,EAAE,UAAU,CAAC;IACnB,4EAA4E;IAC5E,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,uDAAuD;IACvD,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,6DAA6D;IAC7D,UAAU,EAAE,MAAM,IAAI,CAAC;CAC1B,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,WAAW,GAAG,aAAa,CAWpE"}

package/dist/lib/presentation/hooks/useSlug/index.js

@@ -0,0 +1,18 @@
+import { slugify } from '@orthacms/utils-admin';
+import { useSlugAvailability } from '../../../application/useSlugAvailability';
+/**
+ * Wires the name → slug relationship for the basics step. The slug auto-fills
+ * from the name (via {@link slugify}) until the user edits it; from then on it
+ * is left alone and a regenerate action restores auto-fill. Availability is
+ * tracked by {@link useSlugAvailability}. State lives in the wizard — this only
+ * supplies handlers and the live status.
+ */
+export function useSlug({ data, update }) {
+    const status = useSlugAvailability(data.slug);
+    return {
+        status,
+        onNameChange: (name) => update(data.slugEdited ? { name } : { name, slug: slugify(name) }),
+        onSlugChange: (slug) => update({ slug, slugEdited: true }),
+        regenerate: () => update({ slug: slugify(data.name), slugEdited: false })
+    };
+}

package/dist/lib/presentation/hooks/useWizard/index.d.ts

@@ -0,0 +1,60 @@
+import type { ContentMode, MemberDraft, ResourceSelection, WizardData, WizardSnapshot } from '../../../domain/types/wizard';
+/** The full controller returned by {@link useWizard}. */
+export type WizardController = {
+    /** Active step (1–3), mirrored to `?step=` and clamped. */
+    step: number;
+    /** Highest step the user has reached (gates rail navigation). */
+    maxReached: number;
+    /** Step 1 basics. */
+    data: WizardData;
+    /** Added members (excludes the implied owner). */
+    members: MemberDraft[];
+    /** Page-level content decision. */
+    contentMode: ContentMode;
+    /** Collection selection. */
+    collections: ResourceSelection;
+    /** Page selection. */
+    pages: ResourceSelection;
+    /** Whether the content-types list is still loading. */
+    ctLoading: boolean;
+    /** Whether the content-types list failed to load. */
+    ctError: boolean;
+    /** Navigate to a step (clamped); bumps {@link maxReached}. */
+    goStep: (next: number) => void;
+    /** Merge a partial patch into the basics data. */
+    update: (patch: Partial<WizardData>) => void;
+    /** Add a member if not already present. */
+    addMember: (member: MemberDraft) => void;
+    /** Remove a member by id. */
+    removeMember: (id: string) => void;
+    /** Set the page-level content mode. */
+    setContentMode: (mode: ContentMode) => void;
+    /** Replace the collection selection. */
+    setCollections: (selection: ResourceSelection) => void;
+    /** Replace the page selection. */
+    setPages: (selection: ResourceSelection) => void;
+    /** Whether the basics step passes shape validation (not availability). */
+    basicsValid: boolean;
+    /** Total members including the owner. */
+    memberCount: number;
+    /** Number of selected collections. */
+    collectionCount: number;
+    /** Number of selected pages. */
+    pageCount: number;
+    /**
+     * The full current wizard state as a submittable snapshot. The page hands
+     * this (optionally spread with an override, e.g. empty content for "Skip &
+     * create") to the create use-case hook without mutating wizard state.
+     */
+    snapshot: WizardSnapshot;
+};
+/**
+ * Single source of truth for the create-workspace wizard: step (mirrored to the
+ * `?step=` query param and clamped), the per-step form state, and derived
+ * validity and counts. Step bodies are presentational and read everything from
+ * here, so state survives navigating between steps. Submission itself lives in
+ * the `useCreateWorkspaceFlow` use-case hook — this only exposes the
+ * {@link WizardController.snapshot} it consumes.
+ */
+export declare function useWizard(): WizardController;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/hooks/useWizard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/hooks/useWizard/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACR,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,UAAU,EACV,cAAc,EACjB,MAAM,8BAA8B,CAAC;AAsBtC,yDAAyD;AACzD,MAAM,MAAM,gBAAgB,GAAG;IAC3B,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,qBAAqB;IACrB,IAAI,EAAE,UAAU,CAAC;IACjB,kDAAkD;IAClD,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,mCAAmC;IACnC,WAAW,EAAE,WAAW,CAAC;IACzB,4BAA4B;IAC5B,WAAW,EAAE,iBAAiB,CAAC;IAC/B,sBAAsB;IACtB,KAAK,EAAE,iBAAiB,CAAC;IACzB,uDAAuD;IACvD,SAAS,EAAE,OAAO,CAAC;IACnB,qDAAqD;IACrD,OAAO,EAAE,OAAO,CAAC;IACjB,8DAA8D;IAC9D,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,kDAAkD;IAClD,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;IAC7C,2CAA2C;IAC3C,SAAS,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;IACzC,6BAA6B;IAC7B,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,uCAAuC;IACvC,cAAc,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;IAC5C,wCAAwC;IACxC,cAAc,EAAE,CAAC,SAAS,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACvD,kCAAkC;IAClC,QAAQ,EAAE,CAAC,SAAS,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACjD,0EAA0E;IAC1E,WAAW,EAAE,OAAO,CAAC;IACrB,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,eAAe,EAAE,MAAM,CAAC;IACxB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,QAAQ,EAAE,cAAc,CAAC;CAC5B,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,SAAS,IAAI,gBAAgB,CA4F5C"}

package/dist/lib/presentation/hooks/useWizard/index.js

@@ -0,0 +1,93 @@
+import { useCallback, useEffect, useState } from 'react';
+import { useSearchParams } from 'react-router-dom';
+import { useContentTypes } from '../../../application/useContentTypes';
+import { count, EMPTY_SELECTION } from '../../../domain/resourceSelection';
+import { useBasicsSchema } from '../useBasicsSchema';
+const STEP_PARAM = 'step';
+const MIN_STEP = 1;
+const MAX_STEP = 3;
+/** Default accent color for a new workspace. */
+const DEFAULT_COLOR = 'slate';
+const INITIAL_DATA = {
+    name: '',
+    slug: '',
+    slugEdited: false,
+    description: '',
+    color: DEFAULT_COLOR
+};
+const clampStep = (n) => Math.min(MAX_STEP, Math.max(MIN_STEP, Number.isFinite(n) ? n : MIN_STEP));
+/**
+ * Single source of truth for the create-workspace wizard: step (mirrored to the
+ * `?step=` query param and clamped), the per-step form state, and derived
+ * validity and counts. Step bodies are presentational and read everything from
+ * here, so state survives navigating between steps. Submission itself lives in
+ * the `useCreateWorkspaceFlow` use-case hook — this only exposes the
+ * {@link WizardController.snapshot} it consumes.
+ */
+export function useWizard() {
+    const [searchParams, setSearchParams] = useSearchParams();
+    const requestedStep = clampStep(Number(searchParams.get(STEP_PARAM) ?? MIN_STEP));
+    const [data, setData] = useState(INITIAL_DATA);
+    const [members, setMembers] = useState([]);
+    const [contentMode, setContentMode] = useState('all');
+    const [collections, setCollections] = useState(EMPTY_SELECTION);
+    const [pages, setPages] = useState(EMPTY_SELECTION);
+    const basicsSchema = useBasicsSchema();
+    const contentTypes = useContentTypes();
+    const basicsValid = basicsSchema.safeParse({
+        name: data.name,
+        slug: data.slug,
+        description: data.description
+    }).success;
+    // The basics gate is enforced on the *state*, not just on the transition.
+    // All wizard state is in-memory, so a deep link or a reload lands on a later
+    // step with an empty step 1 — previously rendering a live "Create workspace"
+    // button whose only possible outcome was a generic failure toast. Falling
+    // back to step 1 makes the wizard self-healing: the user sees exactly what
+    // is missing instead of a dead end. Steps 2 and 3 hold no basics fields, so
+    // this can never yank a user backwards mid-flow.
+    const step = basicsValid ? requestedStep : MIN_STEP;
+    const [maxReached, setMaxReached] = useState(step);
+    // Keep maxReached monotonic across deep-links and browser back/forward.
+    useEffect(() => {
+        setMaxReached((m) => Math.max(m, step));
+    }, [step]);
+    const allTypes = contentTypes.data ?? [];
+    const collectionsTotal = allTypes.filter((ct) => ct.kind === 'collection').length;
+    const pagesTotal = allTypes.filter((ct) => ct.kind === 'single').length;
+    const goStep = useCallback((next) => {
+        const clamped = clampStep(next);
+        setMaxReached((m) => Math.max(m, clamped));
+        setSearchParams({ [STEP_PARAM]: String(clamped) });
+    }, [setSearchParams]);
+    const update = useCallback((patch) => setData((prev) => ({ ...prev, ...patch })), []);
+    const addMember = useCallback((member) => {
+        setMembers((prev) => prev.some((m) => m.id === member.id) ? prev : [...prev, member]);
+    }, []);
+    const removeMember = useCallback((id) => {
+        setMembers((prev) => prev.filter((m) => m.id !== id));
+    }, []);
+    return {
+        step,
+        maxReached,
+        data,
+        members,
+        contentMode,
+        collections,
+        pages,
+        ctLoading: contentTypes.isPending,
+        ctError: contentTypes.isError,
+        goStep,
+        update,
+        addMember,
+        removeMember,
+        setContentMode,
+        setCollections,
+        setPages,
+        basicsValid,
+        memberCount: members.length + 1,
+        collectionCount: count(collections, collectionsTotal),
+        pageCount: count(pages, pagesTotal),
+        snapshot: { data, members, contentMode, collections, pages }
+    };
+}

package/dist/lib/presentation/hooks/useWorkspaceProfileSchema/index.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+/**
+ * Builds the settings General-tab Zod schema with localized messages. Mirrors
+ * the server `UpdateWorkspaceDto` through the shared {@link NAME_MAX} /
+ * {@link DESCRIPTION_MAX} constants (name required, ≤120; description ≤2000),
+ * rather than restating the numbers here — which is how they previously drifted
+ * to 100/500 and locked long-named workspaces out of the whole form. The slug is
+ * intentionally absent — it's the workspace's immutable URL identifier and isn't
+ * editable from settings. Rebuilt when the locale changes so the copy stays in
+ * sync with the UI.
+ */
+export declare function useWorkspaceProfileSchema(): z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/hooks/useWorkspaceProfileSchema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/hooks/useWorkspaceProfileSchema/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB;;;kBA+BxC"}