@jini-ai/admin 0.4.2 → 0.4.4

package/dist/redirects/controllers/hit-count.controller.d.ts

@@ -0,0 +1,14 @@
+/** Button-controlled query gate: many mounted rows never cause a burst of hit requests.
+ * @example createHitCountController({}, {});
+ */
+export declare function createHitCountController(_required: Record<string, never>, _optional?: {}): {
+    getSnapshot: () => Readonly<{
+        requested: boolean;
+    }>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    request(_input?: Record<string, never>, _options?: {}): void;
+};
+//# sourceMappingURL=hit-count.controller.d.ts.map

package/dist/redirects/controllers/hit-count.controller.js

@@ -0,0 +1,10 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+/** Button-controlled query gate: many mounted rows never cause a burst of hit requests.
+ * @example createHitCountController({}, {});
+ */
+export function createHitCountController(_required, _optional = {}) {
+    const store = createControllerStore({ initial: { requested: false } });
+    return { getSnapshot: store.getSnapshot, subscribe: store.subscribe, dispose: store.dispose,
+        request(_input = {}, _options = {}) { store.set({ patch: { requested: true } }); } };
+}
+//# sourceMappingURL=hit-count.controller.js.map

package/dist/redirects/controllers/import-redirects.controller.d.ts

@@ -0,0 +1,28 @@
+import type { AdminRedirectCreateInput, AdminRedirectImportResult } from '../../core/ports/redirects.js';
+import type { RedirectsTranslate } from '../models.js';
+export interface ImportRedirectsActions {
+    reset(): void;
+    run(rules: readonly AdminRedirectCreateInput[]): Promise<AdminRedirectImportResult>;
+}
+/** Parse errors are local; the existing query mutation owns request errors and pending state.
+ * @example createImportRedirectsController({ actions: () => currentMutation, t }, {});
+ */
+export declare function createImportRedirectsController({ actions, t }: {
+    actions: () => ImportRedirectsActions;
+    t: () => RedirectsTranslate;
+}, _optional?: {}): {
+    getSnapshot: () => Readonly<{
+        raw: string;
+        parseError: string | null;
+        result: AdminRedirectImportResult | null;
+    }>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    setRaw({ raw }: {
+        raw: string;
+    }, _options?: {}): void;
+    submit(_required?: Record<string, never>, _options?: {}): Promise<void>;
+};
+//# sourceMappingURL=import-redirects.controller.d.ts.map

package/dist/redirects/controllers/import-redirects.controller.js

@@ -0,0 +1,29 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { parseImportPayload } from '../rules.js';
+/** Parse errors are local; the existing query mutation owns request errors and pending state.
+ * @example createImportRedirectsController({ actions: () => currentMutation, t }, {});
+ */
+export function createImportRedirectsController({ actions, t }, _optional = {}) {
+    const store = createControllerStore({
+        initial: { raw: '', parseError: null, result: null },
+    });
+    return {
+        getSnapshot: store.getSnapshot, subscribe: store.subscribe, dispose: store.dispose,
+        setRaw({ raw }, _options = {}) { store.set({ patch: { raw } }); },
+        async submit(_required = {}, _options = {}) {
+            store.set({ patch: { parseError: null, result: null } });
+            actions().reset();
+            // Check JSON + array only: the server remains the validator and returns each item's 207 outcome.
+            const parsed = parseImportPayload({ raw: store.getSnapshot().raw, translate: t() });
+            if (!parsed.ok) {
+                store.set({ patch: { parseError: parsed.error } });
+                return;
+            }
+            try {
+                store.set({ patch: { result: await actions().run(parsed.rules) } });
+            }
+            catch { /* already surfaced by the mutation's request-error channel */ }
+        },
+    };
+}
+//# sourceMappingURL=import-redirects.controller.js.map

package/dist/redirects/controllers/redirects.controller.d.ts

@@ -0,0 +1,37 @@
+import type { AdminRedirect } from '../../core/ports/redirects.js';
+/** Fetch-query owns request/cache states; this controller owns confirmation and write sequencing. */
+export interface RedirectsActions {
+    saving: boolean;
+    create(form: FormData): Promise<unknown>;
+    toggle(rule: AdminRedirect): Promise<unknown>;
+    remove(rule: AdminRedirect): Promise<unknown>;
+    resetOthers(active: 'create' | 'toggle' | 'remove'): void;
+}
+/** The action getter reads the current query mutations, preserving independent errors and guards.
+ * @example createRedirectsController({ actions: () => currentActions }, {});
+ */
+export declare function createRedirectsController({ actions }: {
+    actions: () => RedirectsActions;
+}, _optional?: {}): {
+    getSnapshot: () => Readonly<{
+        pendingDelete: AdminRedirect | null;
+    }>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    setPendingDelete({ rule }: {
+        rule: AdminRedirect | null;
+    }, _options?: {}): void;
+    createRedirect({ form }: {
+        form: FormData;
+    }, _options?: {}): Promise<boolean>;
+    onToggleStatus({ rule }: {
+        rule: AdminRedirect;
+    }, _options?: {}): void;
+    onRequestDelete({ rule }: {
+        rule: AdminRedirect;
+    }, _options?: {}): void;
+    confirmDelete(_required?: Record<string, never>, _options?: {}): void;
+};
+//# sourceMappingURL=redirects.controller.d.ts.map

package/dist/redirects/controllers/redirects.controller.js

@@ -0,0 +1,38 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+/** The action getter reads the current query mutations, preserving independent errors and guards.
+ * @example createRedirectsController({ actions: () => currentActions }, {});
+ */
+export function createRedirectsController({ actions }, _optional = {}) {
+    const store = createControllerStore({ initial: { pendingDelete: null } });
+    return {
+        getSnapshot: store.getSnapshot, subscribe: store.subscribe, dispose: store.dispose,
+        setPendingDelete({ rule }, _options = {}) { store.set({ patch: { pendingDelete: rule } }); },
+        createRedirect({ form }, _options = {}) {
+            actions().resetOthers('create');
+            // Never rejects: a failed create preserves the operator's form so it can be fixed/resubmitted.
+            return actions().create(form).then(() => true, () => false);
+        },
+        onToggleStatus({ rule }, _options = {}) {
+            if (actions().saving || store.signal.aborted)
+                return;
+            actions().resetOthers('toggle');
+            // The mutation owns the visible error; handle this derived promise too.
+            void actions().toggle(rule).catch(() => { });
+        },
+        onRequestDelete({ rule }, _options = {}) {
+            if (actions().saving || store.signal.aborted)
+                return;
+            store.set({ patch: { pendingDelete: rule } });
+        },
+        confirmDelete(_required = {}, _options = {}) {
+            const rule = store.getSnapshot().pendingDelete;
+            if (!rule || store.signal.aborted)
+                return;
+            actions().resetOthers('remove');
+            // Catch BEFORE finally: finally creates a new rejection even if mutate handled its own.
+            // Failure is already surfaced by the mutation; always close confirmation once it settles.
+            void actions().remove(rule).catch(() => { }).finally(() => store.set({ patch: { pendingDelete: null } }));
+        },
+    };
+}
+//# sourceMappingURL=redirects.controller.js.map

package/dist/redirects/index.d.ts

@@ -0,0 +1,11 @@
+/** Universal redirects admin contracts, metadata, rules and headless controllers. */
+export { redirectsModule } from './redirects.module.js';
+export * from './ports.js';
+export * from './models.js';
+export * from './rules.js';
+export * from './messages.en.js';
+export * from './controllers/redirects.controller.js';
+export * from './controllers/import-redirects.controller.js';
+export * from './controllers/hit-count.controller.js';
+export type { AdminRedirect, AdminRedirectCreateInput, AdminRedirectUpdatePatch, AdminRedirectListFilter, AdminRedirectHitStats, AdminRedirectImportResult, AdminRedirectImportFailure, RedirectMatchType, RedirectStatusCode, RedirectSource, RedirectStatus } from '../core/ports/redirects.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/redirects/index.js

@@ -0,0 +1,10 @@
+/** Universal redirects admin contracts, metadata, rules and headless controllers. */
+export { redirectsModule } from './redirects.module.js';
+export * from './ports.js';
+export * from './models.js';
+export * from './rules.js';
+export * from './messages.en.js';
+export * from './controllers/redirects.controller.js';
+export * from './controllers/import-redirects.controller.js';
+export * from './controllers/hit-count.controller.js';
+//# sourceMappingURL=index.js.map

package/dist/redirects/messages.en.d.ts

@@ -0,0 +1,58 @@
+import type { RedirectsTranslate } from './models.js';
+/** English source keys are preserved verbatim; the host supplies localized values. */
+export declare const redirectsMessagesEn: {
+    readonly "Loading\u2026": "Loading…";
+    readonly "Load hits": "Load hits";
+    readonly "Bulk import": "Bulk import";
+    readonly "rule objects (1-500 items)": "rule objects (1-500 items)";
+    readonly "Importing\u2026": "Importing…";
+    readonly Import: "Import";
+    readonly Marketing: "Marketing";
+    readonly Redirects: "Redirects";
+    readonly "Manage URL redirects, including those created automatically when a page's address changes.": "Manage URL redirects, including those created automatically when a page's address changes.";
+    readonly "Match type": "Match type";
+    readonly "From path": "From path";
+    readonly "To target": "To target";
+    readonly "Status code": "Status code";
+    readonly "301 (permanent)": "301 (permanent)";
+    readonly "302 (temporary)": "302 (temporary)";
+    readonly "307 (temporary, method-preserving)": "307 (temporary, method-preserving)";
+    readonly "308 (permanent, method-preserving)": "308 (permanent, method-preserving)";
+    readonly "Add redirect": "Add redirect";
+    readonly "No redirect rules yet.": "No redirect rules yet.";
+    readonly From: "From";
+    readonly To: "To";
+    readonly Type: "Type";
+    readonly Code: "Code";
+    readonly Source: "Source";
+    readonly Hits: "Hits";
+    readonly "Delete redirect rule?": "Delete redirect rule?";
+    readonly "Loading redirects\u2026": "Loading redirects…";
+    readonly "Not valid JSON.": "Not valid JSON.";
+    readonly "Must be a JSON array of rule objects.": "Must be a JSON array of rule objects.";
+    readonly exact: "Exact match";
+    readonly prefix: "Starts with";
+    readonly wildcard: "Wildcard";
+    readonly Status: "Status";
+    readonly More: "More";
+    readonly Delete: "Delete";
+    readonly Disable: "Disable";
+    readonly Enable: "Enable";
+    readonly "Saving\u2026": "Saving…";
+    readonly Created: "Created";
+    readonly active: "Active";
+    readonly disabled: "Disabled";
+    readonly "{created} created, {failed} failed.": "{created} created, {failed} failed.";
+    readonly "Item {index} ({code})": "Item {index} ({code})";
+    readonly "Actions for redirect rule from \"{fromPattern}\"": "Actions for redirect rule from \"{fromPattern}\"";
+    readonly "Paste a JSON array of ": "Paste a JSON array of ";
+    readonly " rule objects (1-500 items)": " rule objects (1-500 items)";
+    readonly "Delete the redirect rule from \"": "Delete the redirect rule from \"";
+    readonly "\"?": "\"?";
+    readonly manual: "Manual";
+    readonly auto_slug_change: "URL change";
+    readonly import: "Imported";
+};
+/** English fallback with the same named-placeholder interpolation as the host dictionary. */
+export declare const translateRedirectsEn: RedirectsTranslate;
+//# sourceMappingURL=messages.en.d.ts.map

package/dist/redirects/messages.en.js

@@ -0,0 +1,60 @@
+/** English source keys are preserved verbatim; the host supplies localized values. */
+export const redirectsMessagesEn = {
+    "Loading…": "Loading…",
+    "Load hits": "Load hits",
+    "Bulk import": "Bulk import",
+    "rule objects (1-500 items)": "rule objects (1-500 items)",
+    "Importing…": "Importing…",
+    "Import": "Import",
+    "Marketing": "Marketing",
+    "Redirects": "Redirects",
+    "Manage URL redirects, including those created automatically when a page's address changes.": "Manage URL redirects, including those created automatically when a page's address changes.",
+    "Match type": "Match type",
+    "From path": "From path",
+    "To target": "To target",
+    "Status code": "Status code",
+    "301 (permanent)": "301 (permanent)",
+    "302 (temporary)": "302 (temporary)",
+    "307 (temporary, method-preserving)": "307 (temporary, method-preserving)",
+    "308 (permanent, method-preserving)": "308 (permanent, method-preserving)",
+    "Add redirect": "Add redirect",
+    "No redirect rules yet.": "No redirect rules yet.",
+    "From": "From",
+    "To": "To",
+    "Type": "Type",
+    "Code": "Code",
+    "Source": "Source",
+    "Hits": "Hits",
+    "Delete redirect rule?": "Delete redirect rule?",
+    "Loading redirects…": "Loading redirects…",
+    "Not valid JSON.": "Not valid JSON.",
+    "Must be a JSON array of rule objects.": "Must be a JSON array of rule objects.",
+    "exact": "Exact match",
+    "prefix": "Starts with",
+    "wildcard": "Wildcard",
+    "Status": "Status",
+    "More": "More",
+    "Delete": "Delete",
+    "Disable": "Disable",
+    "Enable": "Enable",
+    "Saving…": "Saving…",
+    "Created": "Created",
+    "active": "Active",
+    "disabled": "Disabled",
+    "{created} created, {failed} failed.": "{created} created, {failed} failed.",
+    "Item {index} ({code})": "Item {index} ({code})",
+    "Actions for redirect rule from \"{fromPattern}\"": "Actions for redirect rule from \"{fromPattern}\"",
+    "Paste a JSON array of ": "Paste a JSON array of ",
+    " rule objects (1-500 items)": " rule objects (1-500 items)",
+    "Delete the redirect rule from \"": "Delete the redirect rule from \"",
+    "\"?": "\"?",
+    "manual": "Manual",
+    "auto_slug_change": "URL change",
+    "import": "Imported",
+};
+/** English fallback with the same named-placeholder interpolation as the host dictionary. */
+export const translateRedirectsEn = (key, vars = {}) => {
+    const template = Object.hasOwn(redirectsMessagesEn, key) ? redirectsMessagesEn[key] : key;
+    return template.replace(/\{(\w+)\}/g, (match, name) => String(vars[name] ?? match));
+};
+//# sourceMappingURL=messages.en.js.map

package/dist/redirects/models.d.ts

@@ -0,0 +1,14 @@
+/** View configuration; redirect records and write contracts belong to core/ports/redirects. */
+export type RedirectsTranslate = (key: string, vars?: Record<string, string | number>) => string;
+export type RedirectsMessageKey = 'importRulesLabel' | 'deleteRedirectBody';
+export interface RedirectsRowAction {
+    key: string;
+    label: string;
+    destructive?: boolean;
+    onSelect: () => void;
+}
+export interface RedirectsWriteState {
+    status: 'idle' | 'pending' | 'success' | 'error';
+    error: Error | null;
+}
+//# sourceMappingURL=models.d.ts.map

package/dist/redirects/models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=models.js.map

package/dist/redirects/ports.d.ts

@@ -0,0 +1,9 @@
+import type { AdminRedirectsPort } from '../core/ports/redirects.js';
+export type { AdminRedirectsPort } from '../core/ports/redirects.js';
+/** Refresh notifications contain no rows; the authorized API remains the data owner. */
+export interface RedirectsEventsPort {
+    subscribe(listener: () => void): () => void;
+}
+export declare const redirectsApiToken: import("../core/module/token.js").AdminPortToken<AdminRedirectsPort, "admin.redirects.api">;
+export declare const redirectsEventsToken: import("../core/module/token.js").AdminPortToken<RedirectsEventsPort, "admin.redirects.events">;
+//# sourceMappingURL=ports.d.ts.map

package/dist/redirects/ports.js

@@ -0,0 +1,4 @@
+import { adminPort } from '../core/module/token.js';
+export const redirectsApiToken = adminPort({ id: 'admin.redirects.api' });
+export const redirectsEventsToken = adminPort({ id: 'admin.redirects.events' });
+//# sourceMappingURL=ports.js.map

package/dist/redirects/react/components/HitCountCell.d.ts

@@ -0,0 +1,19 @@
+import type { RedirectsTranslate as Translate } from '../../models.js';
+import { useWiredHitCountCell } from '../hooks/wired.hooks.js';
+export interface HitCountCellProps {
+    redirectId: string;
+    /** Bound translator, threaded down from `Redirects`'s own hook rather than resolved here — see
+     *  this file's header. */
+    t: Translate;
+    /** This row's own distinct handle base — same reasoning as `Users.tsx`'s `UserRowProps.agentBase`.
+     *  Optional (identity-omitted default) since this component is exported and unit-tested directly
+     *  without one. */
+    agentHandleBase?: string;
+    /** Dependency injection seam for tests — see `PostsProps.usePostsHook` for the convention. */
+    useHitCountCellHook?: typeof useWiredHitCountCell;
+}
+/** Lazy hit-count cell (REQ-03) — fetches on first click rather than on mount, so a list of many
+ *  rows never fires a synchronous burst of `/hits` requests. A rule with zero recorded hits still
+ *  renders `0` (not blank), matching `hits.ts`'s own "still 200s with hitCount: 0" contract. */
+export declare function HitCountCell({ redirectId, t, agentHandleBase, useHitCountCellHook }: HitCountCellProps): import("react").JSX.Element;
+//# sourceMappingURL=HitCountCell.d.ts.map

package/dist/redirects/react/components/HitCountCell.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { agentHandle } from '@jini-ai/agentic';
+import { describeApiError } from '../../../core/transport/errors.js';
+import { useWiredHitCountCell } from '../hooks/wired.hooks.js';
+/** Lazy hit-count cell (REQ-03) — fetches on first click rather than on mount, so a list of many
+ *  rows never fires a synchronous burst of `/hits` requests. A rule with zero recorded hits still
+ *  renders `0` (not blank), matching `hits.ts`'s own "still 200s with hitCount: 0" contract. */
+export function HitCountCell({ redirectId, t, agentHandleBase, useHitCountCellHook = useWiredHitCountCell }) {
+    const { error, data, isFetching, request } = useHitCountCellHook({ redirectId, t });
+    if (error)
+        return _jsx("span", { className: "save-error", children: describeApiError({ e: error, fallback: "failed" }) });
+    // A rule with zero recorded hits still renders `0` (not blank), matching
+    // `hits.ts`'s own "still 200s with hitCount: 0" contract — so this branches
+    // on the request having completed, never on the count's truthiness.
+    if (data)
+        return _jsx("span", { children: data.data.hitCount });
+    return (_jsx("button", { type: "button", onClick: request, disabled: isFetching, ...(agentHandleBase ? agentHandle({ handle: `${agentHandleBase}-load-hits` }, { role: "button", label: "Load this rule's hit count" }) : {}), children: isFetching ? t("Loading…") : t("Load hits") }));
+}
+//# sourceMappingURL=HitCountCell.js.map

package/dist/redirects/react/components/ImportRedirectsForm.d.ts

@@ -0,0 +1,17 @@
+import type { RedirectsTranslate as Translate } from '../../models.js';
+import { useWiredImportRedirectsForm } from '../hooks/wired.hooks.js';
+export interface ImportRedirectsFormProps {
+    /** Bound translator, threaded down from `Redirects`'s own hook rather than resolved here — see
+     *  this file's header. */
+    t: Translate;
+    /** Raw resolved locale — needed alongside `t` because the host may resolve locale-specific message fragments. See this file's header. */
+    locale: string;
+    /** Dependency injection seam for tests — see `PostsProps.usePostsHook` for the convention. */
+    useImportRedirectsFormHook?: typeof useWiredImportRedirectsForm;
+}
+/** Bulk-import affordance (REQ-04) — paste a JSON array of rule objects, submit through
+ * `api.importRedirects`, and surface the `207` per-item created/failed breakdown directly
+ * (never collapsed into a single pass/fail toast — a partial-batch failure is the route's own
+ * designed behavior, not an edge case). */
+export declare function ImportRedirectsForm({ t, locale, useImportRedirectsFormHook }: ImportRedirectsFormProps): import("react").JSX.Element;
+//# sourceMappingURL=ImportRedirectsForm.d.ts.map

package/dist/redirects/react/components/ImportRedirectsForm.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { agentHandle } from '@jini-ai/agentic';
+import { useWiredImportRedirectsForm } from '../hooks/wired.hooks.js';
+/** Bulk-import affordance (REQ-04) — paste a JSON array of rule objects, submit through
+ * `api.importRedirects`, and surface the `207` per-item created/failed breakdown directly
+ * (never collapsed into a single pass/fail toast — a partial-batch failure is the route's own
+ * designed behavior, not an edge case). */
+export function ImportRedirectsForm({ t, locale, useImportRedirectsFormHook = useWiredImportRedirectsForm }) {
+    const { raw, error, result, importing, submit, changeRaw, rulesLabel, resultSummary, createdText, failedLabel } = useImportRedirectsFormHook({ t, locale });
+    return (_jsxs("details", { className: "notice redirects-import form-measure", children: [_jsx("summary", { children: t("Bulk import") }), _jsxs("form", { onSubmit: submit, children: [_jsx("label", { htmlFor: "redirects-import-json", children: rulesLabel }), _jsx("textarea", { id: "redirects-import-json", rows: 6, value: raw, onChange: changeRaw, placeholder: '[{"matchType":"exact","fromPattern":"/old","toTarget":"/new","statusCode":301}]', ...agentHandle({ handle: "redirects-import-json" }, { role: "field", label: "JSON array of redirect rules to bulk-import" }) }), _jsx("button", { type: "submit", className: "btn-secondary", disabled: importing, ...agentHandle({ handle: "redirects-import-submit" }, { role: "button", label: "Import the pasted redirect rules" }), children: importing ? t("Importing…") : t("Import") })] }), error ? (_jsx("div", { className: "notice error", role: "alert", children: error })) : null, result ? (_jsxs("div", { className: "redirects-import-result", children: [_jsx("p", { children: resultSummary }), result.created.length > 0 ? (_jsx("ul", { children: result.created.map((r) => (_jsxs("li", { children: [_jsx("span", { className: "save-ok", children: createdText }), " ", r.fromPattern, " \u2192 ", r.toTarget] }, r.id))) })) : null, result.failed.length > 0 ? (_jsx("ul", { children: result.failed.map((f) => (_jsxs("li", { children: [_jsx("span", { className: "save-error", children: failedLabel(f) }), ": ", f.message] }, f.index))) })) : null] })) : null] }));
+}
+//# sourceMappingURL=ImportRedirectsForm.js.map

package/dist/redirects/react/hooks/RedirectsOptions.hooks.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+import type { RedirectsTranslate, RedirectsMessageKey } from '../../models.js';
+/** Node messages retain the host's locale-specific fragment ordering and DOM wrappers. */
+export interface RedirectsRenderMessageInput {
+    key: RedirectsMessageKey;
+    vars?: Record<string, string | number>;
+    shapeCode?: ReactNode;
+}
+export interface RedirectsReactOptions {
+    t?: RedirectsTranslate;
+    locale?: string;
+    headerActions?: ReactNode;
+    slots?: {
+        renderMessage?: (required: RedirectsRenderMessageInput, optional?: Record<string, never>) => ReactNode;
+    };
+}
+export declare const RedirectsOptionsContext: import("react").Context<RedirectsReactOptions>;
+export declare function useRedirectsOptions(_required?: Record<string, never>, _optional?: {}): {
+    t: RedirectsTranslate;
+    locale: string;
+    renderMessage: (required: RedirectsRenderMessageInput, optional?: Record<string, never>) => ReactNode;
+    headerActions?: ReactNode;
+    slots?: {
+        renderMessage?: (required: RedirectsRenderMessageInput, optional?: Record<string, never>) => ReactNode;
+    };
+};
+//# sourceMappingURL=RedirectsOptions.hooks.d.ts.map

package/dist/redirects/react/hooks/RedirectsOptions.hooks.js

@@ -0,0 +1,15 @@
+import { createContext, createElement, useContext } from 'react';
+import { translateRedirectsEn } from '../../messages.en.js';
+export const RedirectsOptionsContext = createContext({});
+/** English fallback preserves original fragments and the delete body's paragraph wrapper. */
+function renderEnglishMessage({ key, vars = {}, shapeCode }) {
+    if (key === 'importRulesLabel')
+        return ['Paste a JSON array of ', shapeCode, ' rule objects (1-500 items)'];
+    return createElement('p', null, 'Delete the redirect rule from "', vars.fromPattern, '"?');
+}
+export function useRedirectsOptions(_required = {}, _optional = {}) {
+    const options = useContext(RedirectsOptionsContext);
+    return { ...options, t: options.t ?? translateRedirectsEn, locale: options.locale ?? 'en',
+        renderMessage: options.slots?.renderMessage ?? renderEnglishMessage };
+}
+//# sourceMappingURL=RedirectsOptions.hooks.js.map

package/dist/redirects/react/hooks/RedirectsPage.hooks.d.ts

@@ -0,0 +1,50 @@
+import type { AdminRedirect } from '../../../core/ports/redirects.js';
+import { useWiredRedirects } from './wired.hooks.js';
+/** Table projections stay outside TSX; DOM/class/handle identities remain the original ones. */
+export declare function useRedirectsPage({ useRedirectsHook }: {
+    useRedirectsHook?: typeof useWiredRedirects;
+}, _optional?: {}): {
+    columns: ({
+        key: string;
+        header: string;
+        cell: (rule: AdminRedirect) => string;
+    } | {
+        key: string;
+        header: string;
+        cell: (rule: AdminRedirect) => import("../../index.js").RedirectStatusCode;
+    } | {
+        key: string;
+        header: string;
+        cell: (rule: AdminRedirect) => import("react").DetailedReactHTMLElement<{
+            className: string;
+        }, HTMLElement>;
+    } | {
+        key: string;
+        header: string;
+        cell: (rule: AdminRedirect, index: number) => import("react").FunctionComponentElement<import("../components/HitCountCell.js").HitCountCellProps>;
+    } | {
+        key: string;
+        header: string;
+        cell: (rule: AdminRedirect, index: number) => import("react").FunctionComponentElement<import("../../../react/index.js").RowMenuProps>;
+    })[];
+    headerActions: import("react").ReactNode;
+    cancelDelete: () => void | undefined;
+    deleteBody: import("react").ReactNode;
+    redirects: readonly AdminRedirect[] | undefined;
+    listStatus: import("@jini-ai/ui").QueryStatus;
+    listError: Error | null;
+    error: Error | null;
+    saving: boolean;
+    pendingDelete: AdminRedirect | null;
+    setPendingDelete: (rule: AdminRedirect | null) => void | undefined;
+    confirmDelete: () => void | undefined;
+    deletePending: boolean;
+    createRedirect: (form: FormData) => Promise<boolean>;
+    submitCreate: (e: import("react").FormEvent<HTMLFormElement>) => void;
+    onToggleStatus: (rule: AdminRedirect) => void | undefined;
+    onRequestDelete: (rule: AdminRedirect) => void | undefined;
+    t: import("../../models.js").RedirectsTranslate;
+    locale: string;
+    rowMenuHandles: string[];
+};
+//# sourceMappingURL=RedirectsPage.hooks.d.ts.map

package/dist/redirects/react/hooks/RedirectsPage.hooks.js

@@ -0,0 +1,30 @@
+import { createElement } from 'react';
+import { RowMenu } from '../../../react/index.js';
+import { redirectRowMenuItems } from '../../rules.js';
+import { HitCountCell } from '../components/HitCountCell.js';
+import { useRedirectsOptions } from './RedirectsOptions.hooks.js';
+import { useWiredRedirects } from './wired.hooks.js';
+/** Table projections stay outside TSX; DOM/class/handle identities remain the original ones. */
+export function useRedirectsPage({ useRedirectsHook = useWiredRedirects }, _optional = {}) {
+    const state = useRedirectsHook();
+    const { renderMessage, headerActions } = useRedirectsOptions();
+    const { t, onToggleStatus, onRequestDelete, rowMenuHandles, pendingDelete } = state;
+    const columns = [
+        { key: 'from', header: t('From'), cell: (rule) => rule.fromPattern },
+        { key: 'to', header: t('To'), cell: (rule) => rule.toTarget },
+        { key: 'type', header: t('Type'), cell: (rule) => t(rule.matchType, { serverLabel: rule.matchType }) },
+        { key: 'code', header: t('Code'), cell: (rule) => rule.statusCode },
+        { key: 'source', header: t('Source'), cell: (rule) => t(rule.source, { serverLabel: rule.source }) },
+        // The host's shared serverLabel owns enum localization, including unknown-value passthrough.
+        { key: 'status', header: t('Status'), cell: (rule) => createElement('span', { className: `status status-${rule.status}` }, t(rule.status, { serverLabel: rule.status })) },
+        { key: 'hits', header: t('Hits'), cell: (rule, index) => createElement(HitCountCell, { t, redirectId: rule.id, ...(rowMenuHandles[index] ? { agentHandleBase: rowMenuHandles[index] } : {}) }) },
+        { key: 'actions', header: t('More'), cell: (rule, index) => createElement(RowMenu, {
+                triggerLabel: t('Actions for redirect rule from "{fromPattern}"', { fromPattern: rule.fromPattern }),
+                agentHandle: `${rowMenuHandles[index]}-menu`,
+                items: redirectRowMenuItems({ rule, handlers: { onToggleStatus, onRequestDelete } }, { t }),
+            }) },
+    ];
+    return { ...state, columns, headerActions, cancelDelete: () => state.setPendingDelete(null),
+        deleteBody: pendingDelete ? renderMessage({ key: 'deleteRedirectBody', vars: { fromPattern: pendingDelete.fromPattern } }) : null };
+}
+//# sourceMappingURL=RedirectsPage.hooks.js.map

package/dist/redirects/react/hooks/RedirectsPorts.hooks.d.ts

@@ -0,0 +1,10 @@
+import type { AdminRedirectsPort } from '../../../core/ports/redirects.js';
+import type { RedirectsEventsPort } from '../../ports.js';
+export interface RedirectsPorts {
+    readonly redirectsApi: AdminRedirectsPort;
+    readonly redirectsEvents?: RedirectsEventsPort;
+}
+export declare const RedirectsPortsContext: import("react").Context<RedirectsPorts | null>;
+/** The module binding supplies scoped ports, never a process-global API client. */
+export declare function useRedirectsPorts(_required?: Record<string, never>, _optional?: {}): RedirectsPorts;
+//# sourceMappingURL=RedirectsPorts.hooks.d.ts.map

package/dist/redirects/react/hooks/RedirectsPorts.hooks.js

@@ -0,0 +1,11 @@
+import { createContext, useContext } from 'react';
+import { AdminConfigError } from '../../../core/module/index.js';
+export const RedirectsPortsContext = createContext(null);
+/** The module binding supplies scoped ports, never a process-global API client. */
+export function useRedirectsPorts(_required = {}, _optional = {}) {
+    const ports = useContext(RedirectsPortsContext);
+    if (!ports)
+        throw new AdminConfigError({ issues: ['React scope unavailable: redirects'] });
+    return ports;
+}
+//# sourceMappingURL=RedirectsPorts.hooks.js.map

package/dist/redirects/react/hooks/use-hit-count-cell.hooks.d.ts

@@ -0,0 +1,19 @@
+import type { AdminRedirectsPort } from '../../../core/ports/redirects.js';
+import type { RedirectsTranslate } from '../../models.js';
+/** Localization is passed from the list once; a row never independently fetches locale settings. */
+export declare function useHitCountCell({ redirectId, api }: {
+    redirectId: string;
+    api: AdminRedirectsPort;
+}, { t }?: {
+    t?: RedirectsTranslate;
+}): {
+    error: Error | null;
+    data: {
+        data: import("../../index.js").AdminRedirectHitStats;
+    } | undefined;
+    isFetching: boolean;
+    request: () => void | undefined;
+    t: RedirectsTranslate;
+};
+export type HitCountCellController = ReturnType<typeof useHitCountCell>;
+//# sourceMappingURL=use-hit-count-cell.hooks.d.ts.map

package/dist/redirects/react/hooks/use-hit-count-cell.hooks.js

@@ -0,0 +1,15 @@
+import { useFetchQuery } from '@jini-ai/ui/fetch-query';
+import { useController } from '../../../core/react/use-controller.js';
+import { createHitCountController } from '../../controllers/hit-count.controller.js';
+import { KEYS } from '../../rules.js';
+import { translateRedirectsEn } from '../../messages.en.js';
+/** Localization is passed from the list once; a row never independently fetches locale settings. */
+export function useHitCountCell({ redirectId, api }, { t = translateRedirectsEn } = {}) {
+    // Preserve the original mount-local requested flag across redirect-id/port prop changes.
+    const { controller, snapshot } = useController({ create: () => createHitCountController({}), dependencies: [] });
+    // Enabled only after a gesture: no N+1 request burst when rendering a large table.
+    const hits = useFetchQuery({ key: KEYS.hits({ redirectId }), fetch: () => api.getRedirectHitStats({ id: redirectId }) }, { enabled: snapshot?.requested ?? false });
+    return { error: hits.error, data: hits.data === undefined ? undefined : { data: hits.data },
+        isFetching: hits.isFetching, request: () => controller?.request(), t };
+}
+//# sourceMappingURL=use-hit-count-cell.hooks.js.map

package/dist/redirects/react/hooks/use-import-redirects-form.hooks.d.ts

@@ -0,0 +1,21 @@
+import type { FormEvent } from 'react';
+import type { AdminRedirectsPort } from '../../../core/ports/redirects.js';
+import type { RedirectsTranslate } from '../../models.js';
+/** A resolved 207 is a result, including failed items; only transport failures enter error state. */
+export declare function useImportRedirectsForm({ api }: {
+    api: AdminRedirectsPort;
+}, { t, locale }?: {
+    t?: RedirectsTranslate;
+    locale?: string;
+}): {
+    raw: string;
+    setRaw: (raw: string) => void | undefined;
+    error: string | null;
+    result: import("../../index.js").AdminRedirectImportResult | null;
+    importing: boolean;
+    submit: (e: FormEvent) => Promise<void>;
+    t: RedirectsTranslate;
+    locale: string;
+};
+export type ImportRedirectsFormController = ReturnType<typeof useImportRedirectsForm>;
+//# sourceMappingURL=use-import-redirects-form.hooks.d.ts.map