@jini-ai/admin 0.4.2 → 0.4.4

package/dist/seo/react/hooks/SeoPage.hooks.d.ts

@@ -0,0 +1,69 @@
+import type { FormEvent, ComponentType } from 'react';
+import type { TabBarTab } from '@jini-ai/ui/tab-strip';
+import type { SeoTranslator, SeoSettingsPatch, SeoSettings, SeoEntryAnalysis } from '../../models.js';
+export { buildSeoSettingsPatch, resolveSeoTabId } from '../../rules.js';
+export type { SeoTabId } from '../../rules.js';
+export declare function resolveSeoTabs(_required?: Record<string, never>, { t }?: {
+    t?: SeoTranslator | undefined;
+}): TabBarTab[];
+export declare function sitemapStateLabel({ sitemapEnabled }: {
+    sitemapEnabled: boolean;
+}, { t }?: {
+    t?: SeoTranslator | undefined;
+}): string;
+/** Module onTabChange owns the ?tab= URL. The host uses replace:true to avoid back-stack growth. */
+export declare function useSeoPageActions({ onTabChange }: {
+    onTabChange?: ((required: {
+        tab: string;
+    }, optional?: Record<string, never>) => void) | undefined;
+}, _optional?: Record<string, never>): {
+    changeTab: (tab: string) => void | undefined;
+};
+export declare function useSeoTabs({ tabId }: {
+    tabId?: string | null | undefined;
+}, _optional?: Record<string, never>): {
+    activeTabId: "entries" | "defaults" | "sitemap";
+    tabs: TabBarTab[];
+};
+export declare function useAnalyzePanel({ analysis }: {
+    analysis: SeoEntryAnalysis;
+}, _optional?: Record<string, never>): {
+    sortedIssues: import("../../../core/index.js").AdminSeoIssue[];
+};
+/** All seven defaults remain in one FormData submission; tabs never split this form. */
+export declare function useSeoDefaults({ save }: {
+    save: (patch: SeoSettingsPatch) => Promise<void>;
+}, _optional?: Record<string, never>): {
+    submit: (event: FormEvent<HTMLFormElement>) => void;
+};
+export interface SeoTabController {
+    locale: string;
+    settings: SeoSettings;
+    saving: boolean;
+    save: (patch: SeoSettingsPatch) => Promise<void>;
+    defaultOgImage: string;
+    setDefaultOgImage: (value: string) => void;
+    regenerateSitemap: () => void;
+    openSitemapModal: () => void;
+}
+/** Panel selection is presentation dispatch; this never changes the defaults form's field set. */
+export declare function seoTabPanel({ activeTabId, controller, components }: {
+    activeTabId: import('../../rules.js').SeoTabId;
+    controller: SeoTabController;
+    components: {
+        SeoDefaultsTab: ComponentType<{
+            controller: SeoTabController;
+        }>;
+        SeoSitemapTab: ComponentType<{
+            controller: SeoTabController;
+        }>;
+        SeoEntrySection: ComponentType<{
+            locale: string;
+        }>;
+    };
+}, _optional?: Record<string, never>): import("react").ReactElement<{
+    controller: SeoTabController;
+}, string | import("react").JSXElementConstructor<any>> | import("react").ReactElement<{
+    locale: string;
+}, string | import("react").JSXElementConstructor<any>>;
+//# sourceMappingURL=SeoPage.hooks.d.ts.map

package/dist/seo/react/hooks/SeoPage.hooks.js

@@ -0,0 +1,37 @@
+import { createElement } from 'react';
+import { SeoDefaultsIcon, SeoSitemapIcon, SeoEntriesIcon } from '../components/SeoIcons.js';
+import { buildSeoSettingsPatch, resolveSeoTabId, sortIssuesBySeverity } from '../../rules.js';
+import { useSeoOptions } from './SeoPorts.hooks.js';
+export { buildSeoSettingsPatch, resolveSeoTabId } from '../../rules.js';
+export function resolveSeoTabs(_required = {}, { t = key => key } = {}) {
+    return [
+        { id: 'defaults', label: t('Site defaults'), icon: createElement(SeoDefaultsIcon), handle: 'seo-tab-defaults', handleLabel: 'Switch to the Site defaults tab — title template, meta description, social image and card handle, and the default robots directives' },
+        { id: 'sitemap', label: t('Sitemap'), icon: createElement(SeoSitemapIcon), handle: 'seo-tab-sitemap', handleLabel: 'Switch to the Sitemap tab — rebuild the cached sitemap, or view the URLs it contains' },
+        { id: 'entries', label: t('Pages & posts'), icon: createElement(SeoEntriesIcon), handle: 'seo-tab-entries', handleLabel: 'Switch to the Pages & posts tab — override and analyze the SEO metadata of one page or post' },
+    ];
+}
+export function sitemapStateLabel({ sitemapEnabled }, { t = key => key } = {}) {
+    return t(sitemapEnabled ? 'This site publishes a sitemap.' : 'This site does not publish a sitemap. Turn it on under Site defaults.');
+}
+/** Module onTabChange owns the ?tab= URL. The host uses replace:true to avoid back-stack growth. */
+export function useSeoPageActions({ onTabChange }, _optional = {}) { return { changeTab: (tab) => onTabChange?.({ tab }) }; }
+export function useSeoTabs({ tabId }, _optional = {}) {
+    const { t } = useSeoOptions();
+    return { activeTabId: resolveSeoTabId({ tabId }), tabs: resolveSeoTabs({}, { t }) };
+}
+export function useAnalyzePanel({ analysis }, _optional = {}) {
+    return { sortedIssues: sortIssuesBySeverity({ issues: analysis.issues }) };
+}
+/** All seven defaults remain in one FormData submission; tabs never split this form. */
+export function useSeoDefaults({ save }, _optional = {}) {
+    return { submit: (event) => { event.preventDefault(); void save(buildSeoSettingsPatch({ form: new FormData(event.currentTarget) })); } };
+}
+/** Panel selection is presentation dispatch; this never changes the defaults form's field set. */
+export function seoTabPanel({ activeTabId, controller, components }, _optional = {}) {
+    if (activeTabId === 'sitemap')
+        return createElement(components.SeoSitemapTab, { controller });
+    if (activeTabId === 'entries')
+        return createElement(components.SeoEntrySection, { locale: controller.locale });
+    return createElement(components.SeoDefaultsTab, { controller });
+}
+//# sourceMappingURL=SeoPage.hooks.js.map

package/dist/seo/react/hooks/SeoPorts.hooks.d.ts

@@ -0,0 +1,19 @@
+import type { AdminSeoPort, SeoEventsPort } from '../../ports.js';
+import type { MediaPickerPort } from '../../../contracts/media-picker.js';
+import type { SeoReactOptions } from '../options.js';
+export interface SeoPorts {
+    readonly seoApi: AdminSeoPort;
+    readonly seoEvents?: SeoEventsPort;
+    readonly mediaPicker?: MediaPickerPort;
+}
+export declare const SeoPortsContext: import("react").Context<SeoPorts | null>;
+export declare const SeoOptionsContext: import("react").Context<SeoReactOptions | null>;
+export declare function useSeoPorts(_required?: Record<string, never>, _optional?: Record<string, never>): SeoPorts;
+export declare function useSeoOptions(_required?: Record<string, never>, _optional?: Record<string, never>): SeoReactOptions;
+/** The legacy markup's locale argument is metadata only; translation is injected by the host. */
+export declare function useSeoCopy(_required?: Record<string, never>, _optional?: Record<string, never>): (required: {
+    locale?: string;
+    key: string;
+    vars?: Record<string, string | number>;
+}) => string;
+//# sourceMappingURL=SeoPorts.hooks.d.ts.map

package/dist/seo/react/hooks/SeoPorts.hooks.js

@@ -0,0 +1,22 @@
+import { createContext, useContext } from 'react';
+import { AdminConfigError } from '../../../core/module/index.js';
+export const SeoPortsContext = createContext(null);
+export const SeoOptionsContext = createContext(null);
+export function useSeoPorts(_required = {}, _optional = {}) {
+    const ports = useContext(SeoPortsContext);
+    if (!ports)
+        throw new AdminConfigError({ issues: ['React scope unavailable: seo'] });
+    return ports;
+}
+export function useSeoOptions(_required = {}, _optional = {}) {
+    const options = useContext(SeoOptionsContext);
+    if (!options)
+        throw new AdminConfigError({ issues: ['React options unavailable: seo (siteUrl is required)'] });
+    return options;
+}
+/** The legacy markup's locale argument is metadata only; translation is injected by the host. */
+export function useSeoCopy(_required = {}, _optional = {}) {
+    const { t = key => key } = useSeoOptions();
+    return (required) => t(required.key, required.vars);
+}
+//# sourceMappingURL=SeoPorts.hooks.js.map

package/dist/seo/react/hooks/SitemapModal.hooks.d.ts

@@ -0,0 +1,26 @@
+import type { SitemapModalController } from '../../models.js';
+/** Refetch only after accepted regeneration; a failed write must leave the viewed XML alone. */
+export declare function useSitemapModalRegenerate({ onRegenerate, refetch }: {
+    onRegenerate: () => Promise<boolean>;
+    refetch: () => void;
+}, _optional?: Record<string, never>): {
+    handleRegenerate: () => Promise<void>;
+};
+export declare function useSitemapTable({ modal }: {
+    modal: SitemapModalController;
+}, _optional?: Record<string, never>): {
+    rowHandles: string[];
+};
+export declare function useSitemapViewToggle({ modal }: {
+    modal: SitemapModalController;
+}, _optional?: Record<string, never>): {
+    toggleView: () => void;
+};
+export declare function useSitemapPresentation({ locale, modal }: {
+    locale: string;
+    modal: SitemapModalController;
+}, _optional?: Record<string, never>): {
+    title: string;
+    sourceUrl: string;
+};
+//# sourceMappingURL=SitemapModal.hooks.d.ts.map

package/dist/seo/react/hooks/SitemapModal.hooks.js

@@ -0,0 +1,20 @@
+import { useSeoCopy, useSeoOptions } from './SeoPorts.hooks.js';
+import { buildAgentListHandles } from '@jini-ai/agentic';
+/** Refetch only after accepted regeneration; a failed write must leave the viewed XML alone. */
+export function useSitemapModalRegenerate({ onRegenerate, refetch }, _optional = {}) {
+    return { handleRegenerate: async () => { if (await onRegenerate())
+            refetch(); } };
+}
+export function useSitemapTable({ modal }, _optional = {}) {
+    return { rowHandles: buildAgentListHandles({ prefix: 'seo-sitemap-row', ids: modal.filteredEntries.map(entry => entry.loc) }) };
+}
+export function useSitemapViewToggle({ modal }, _optional = {}) {
+    return { toggleView: () => modal.setView(modal.view === 'raw' ? 'table' : 'raw') };
+}
+export function useSitemapPresentation({ locale, modal }, _optional = {}) {
+    const t = useSeoCopy();
+    const { siteUrl } = useSeoOptions();
+    const title = modal.status === 'ready' ? t({ locale, key: 'Sitemap · {count} URLs' }).replace('{count}', String(modal.entries.length)) : t({ locale, key: 'Sitemap' });
+    return { title, sourceUrl: `${siteUrl().replace(/\/$/, '')}/sitemap.xml` };
+}
+//# sourceMappingURL=SitemapModal.hooks.js.map

package/dist/seo/react/hooks/use-entry-picker.hooks.d.ts

@@ -0,0 +1,11 @@
+import type { EntryPickerController, SeoTranslator, SeoErrorFormatter } from '../../models.js';
+import type { AdminSeoPort } from '../../ports.js';
+export type { EntryPickerController } from '../../models.js';
+export declare function useEntryPicker({ api }: {
+    api: AdminSeoPort;
+}, { t, describeError }?: {
+    t?: SeoTranslator | undefined;
+    describeError?: SeoErrorFormatter | undefined;
+}): EntryPickerController;
+export declare function useWiredEntryPicker(_required?: Record<string, never>, _optional?: Record<string, never>): EntryPickerController;
+//# sourceMappingURL=use-entry-picker.hooks.d.ts.map

package/dist/seo/react/hooks/use-entry-picker.hooks.js

@@ -0,0 +1,20 @@
+import { describeSeoError } from '../../models.js';
+import { useRef } from 'react';
+import { useController } from '../../../core/react/use-controller.js';
+import { createEntryPickerController } from '../../controllers/entry-picker.controller.js';
+import { initialEntryPickerState } from '../../models.js';
+import { useSeoOptions, useSeoPorts } from './SeoPorts.hooks.js';
+export function useEntryPicker({ api }, { t, describeError } = {}) {
+    const translator = useRef(t);
+    translator.current = t;
+    const formatter = useRef(describeError);
+    formatter.current = describeError;
+    const { snapshot } = useController({ create: () => createEntryPickerController({ api }, { t: (key, vars) => translator.current?.(key, vars) ?? key, describeError: required => formatter.current ? formatter.current(required) : describeSeoError(required) }), dependencies: [api] }, { start: ({ controller }) => { void controller.load({}); } });
+    return snapshot ?? initialEntryPickerState;
+}
+export function useWiredEntryPicker(_required = {}, _optional = {}) {
+    const { seoApi: api } = useSeoPorts();
+    const { t, describeError } = useSeoOptions();
+    return useEntryPicker({ api }, { t, describeError });
+}
+//# sourceMappingURL=use-entry-picker.hooks.js.map

package/dist/seo/react/hooks/use-seo-entry-panel.hooks.d.ts

@@ -0,0 +1,14 @@
+import type { SeoEntryPanelController, SeoTranslator, SeoErrorFormatter } from '../../models.js';
+import type { AdminSeoPort } from '../../ports.js';
+export type { SeoEntryPanelController, SeoEntryPanelOptions } from '../../models.js';
+export declare function useSeoEntryPanel({ api, entryId }: {
+    api: AdminSeoPort;
+    entryId: string;
+}, { t, describeError }?: {
+    t?: SeoTranslator | undefined;
+    describeError?: SeoErrorFormatter | undefined;
+}): SeoEntryPanelController;
+export declare function useWiredSeoEntryPanel({ entryId }: {
+    entryId: string;
+}, _optional?: Record<string, never>): SeoEntryPanelController;
+//# sourceMappingURL=use-seo-entry-panel.hooks.d.ts.map

package/dist/seo/react/hooks/use-seo-entry-panel.hooks.js

@@ -0,0 +1,26 @@
+import { describeSeoError } from '../../models.js';
+import { useRef } from 'react';
+import { useController } from '../../../core/react/use-controller.js';
+import { createSeoEntryController } from '../../controllers/seo-entry.controller.js';
+import { initialSeoEntryState } from '../../models.js';
+import { useSeoOptions, useSeoPorts } from './SeoPorts.hooks.js';
+export function useSeoEntryPanel({ api, entryId }, { t, describeError } = {}) {
+    const translator = useRef(t);
+    translator.current = t;
+    const formatter = useRef(describeError);
+    formatter.current = describeError;
+    const { controller, snapshot } = useController({ create: () => createSeoEntryController({ api, entryId }, { t: (key, vars) => translator.current?.(key, vars) ?? key, describeError: required => formatter.current ? formatter.current(required) : describeSeoError(required) }), dependencies: [api, entryId] }, { start: ({ controller }) => { void controller.load({}); } });
+    const state = snapshot ?? initialSeoEntryState;
+    return {
+        ...state,
+        fieldValue: (key, resolvedValue) => controller ? controller.fieldValue({ key, resolvedValue }) : resolvedValue,
+        setField: (key, value) => controller?.setField({ key, value }),
+        save: async () => { await controller?.save({}); },
+    };
+}
+export function useWiredSeoEntryPanel({ entryId }, _optional = {}) {
+    const { seoApi: api } = useSeoPorts();
+    const { t, describeError } = useSeoOptions();
+    return useSeoEntryPanel({ api, entryId }, { t, describeError });
+}
+//# sourceMappingURL=use-seo-entry-panel.hooks.js.map

package/dist/seo/react/hooks/use-seo-entry-section.hooks.d.ts

@@ -0,0 +1,4 @@
+import type { SeoEntrySectionController } from '../../models.js';
+export type { SeoEntrySectionController } from '../../models.js';
+export declare function useSeoEntrySection(_required?: Record<string, never>, _optional?: Record<string, never>): SeoEntrySectionController;
+//# sourceMappingURL=use-seo-entry-section.hooks.d.ts.map

package/dist/seo/react/hooks/use-seo-entry-section.hooks.js

@@ -0,0 +1,7 @@
+import { useController } from '../../../core/react/use-controller.js';
+import { createSeoEntrySectionController } from '../../controllers/entry-section.controller.js';
+export function useSeoEntrySection(_required = {}, _optional = {}) {
+    const { controller, snapshot } = useController({ create: () => createSeoEntrySectionController({}), dependencies: [] });
+    return { entryId: snapshot?.entryId ?? '', setEntryId: entryId => controller?.setEntryId({ entryId }) };
+}
+//# sourceMappingURL=use-seo-entry-section.hooks.js.map

package/dist/seo/react/hooks/use-seo.hooks.d.ts

@@ -0,0 +1,11 @@
+import type { SeoController, SeoTranslator } from '../../models.js';
+import type { AdminSeoPort, SeoEventsPort } from '../../ports.js';
+export type { SeoController } from '../../models.js';
+export declare function useSeo({ api }: {
+    api: AdminSeoPort;
+}, { t, events }?: {
+    t?: SeoTranslator | undefined;
+    events?: SeoEventsPort | undefined;
+}): SeoController;
+export declare function useWiredSeo(_required?: Record<string, never>, _optional?: Record<string, never>): SeoController;
+//# sourceMappingURL=use-seo.hooks.d.ts.map

package/dist/seo/react/hooks/use-seo.hooks.js

@@ -0,0 +1,29 @@
+import { useEffect, useRef } from 'react';
+import { useController } from '../../../core/react/use-controller.js';
+import { createSeoController } from '../../controllers/seo.controller.js';
+import { initialSeoState } from '../../models.js';
+import { useSeoOptions, useSeoPorts } from './SeoPorts.hooks.js';
+export function useSeo({ api }, { t, events } = {}) {
+    const translator = useRef(t);
+    translator.current = t;
+    const { controller, snapshot } = useController({ create: () => createSeoController({ api }, { t: (key, vars) => translator.current?.(key, vars) ?? key }), dependencies: [api] }, { start: ({ controller }) => { void controller.load({}); } });
+    useEffect(() => {
+        if (!controller || !events)
+            return;
+        return events.subscribe({ onRefresh: () => { void controller.load({}); } });
+    }, [controller, events]);
+    return {
+        ...(snapshot ?? initialSeoState), locale: 'en',
+        save: async (patch) => { await controller?.save({ patch }); },
+        setDefaultOgImage: value => controller?.setDefaultOgImage({ value }),
+        regenerateSitemap: async () => await controller?.regenerateSitemap({}) ?? false,
+        openSitemapModal: () => controller?.openSitemapModal({}),
+        closeSitemapModal: () => controller?.closeSitemapModal({}),
+    };
+}
+export function useWiredSeo(_required = {}, _optional = {}) {
+    const { seoApi: api, seoEvents: events } = useSeoPorts();
+    const { t } = useSeoOptions();
+    return useSeo({ api }, { t, events });
+}
+//# sourceMappingURL=use-seo.hooks.js.map

package/dist/seo/react/hooks/use-sitemap-modal.hooks.d.ts

@@ -0,0 +1,10 @@
+import type { SitemapModalController, SitemapModalInputs } from '../../models.js';
+import type { AdminSeoPort } from '../../ports.js';
+export type { SitemapModalController, SitemapModalInputs } from '../../models.js';
+export declare function useSitemapModal({ api, enabled }: {
+    api: AdminSeoPort;
+    enabled: boolean;
+    onClose?: () => void;
+}, _optional?: Record<string, never>): SitemapModalController;
+export declare function useWiredSitemapModal({ enabled, onClose }: SitemapModalInputs, _optional?: Record<string, never>): SitemapModalController;
+//# sourceMappingURL=use-sitemap-modal.hooks.d.ts.map

package/dist/seo/react/hooks/use-sitemap-modal.hooks.js

@@ -0,0 +1,18 @@
+import { useMemo } from 'react';
+import { useController } from '../../../core/react/use-controller.js';
+import { createSitemapController } from '../../controllers/sitemap.controller.js';
+import { parseSitemapXml, filterSitemapEntries } from '../../rules.js';
+import { useSeoPorts } from './SeoPorts.hooks.js';
+export function useSitemapModal({ api, enabled }, _optional = {}) {
+    const { controller, snapshot } = useController({ create: () => createSitemapController({ api, enabled }), dependencies: [api, enabled] }, { start: ({ controller }) => { void controller.load({}); } });
+    const state = snapshot ?? { status: enabled ? 'loading' : 'disabled', error: null, xmlText: '', filter: '', view: 'table' };
+    // Parse only when text/status changes, never on each filter keystroke.
+    const entries = useMemo(() => state.status === 'ready' ? parseSitemapXml({ xmlText: state.xmlText }) : [], [state.status, state.xmlText]);
+    const filteredEntries = useMemo(() => filterSitemapEntries({ entries, query: state.filter }), [entries, state.filter]);
+    return { ...state, entries, filteredEntries, setFilter: value => controller?.setFilter({ value }), setView: view => controller?.setView({ view }), refetch: () => { void controller?.load({}); } };
+}
+export function useWiredSitemapModal({ enabled, onClose }, _optional = {}) {
+    const { seoApi: api } = useSeoPorts();
+    return useSitemapModal({ api, enabled, onClose });
+}
+//# sourceMappingURL=use-sitemap-modal.hooks.js.map