@phis/ui 0.1.0

package/components/widgets/helpers/html-internal-references.server.js

@@ -0,0 +1,108 @@
+import "server-only";
+import renderNodes from "dom-serializer";
+import { parseDocument } from "htmlparser2";
+import { readPhiInternalReference } from "../../../types/references";
+import { resolvePhiWidgetInternalReferences } from "./internal-reference-resolver.server";
+function normalizePotentialPhiScheme(value) {
+    let current = value.trim().replace(/:/giu, ":").replace(/&#0*58;|&#x0*3a;/giu, ":");
+    for (let index = 0; index < 3; index += 1) {
+        try {
+            const decoded = decodeURIComponent(current);
+            if (decoded === current)
+                break;
+            current = decoded;
+        }
+        catch {
+            break;
+        }
+    }
+    return current.replace(/[\u0000-\u0020]+/gu, "").toLowerCase();
+}
+function externalUrl(value, sourceUrl) {
+    const normalized = value.trim();
+    if (!normalized || normalizePotentialPhiScheme(normalized).startsWith("phis:"))
+        return null;
+    if (normalized.startsWith("#") || /^(?:https?:|mailto:|tel:)/iu.test(normalized))
+        return normalized;
+    try {
+        return new URL(normalized, sourceUrl).toString();
+    }
+    catch {
+        return null;
+    }
+}
+function walk(nodes, visit) {
+    return nodes.flatMap((node) => {
+        node.children = walk(node.children ?? [], visit);
+        return visit(node) ?? [node];
+    });
+}
+export async function resolvePhiHtmlReferences(input) {
+    const document = parseDocument(input.html);
+    if (input.sourceMode === "url") {
+        const sourceUrl = input.sourceUrl?.trim();
+        if (!sourceUrl)
+            return "";
+        document.children = walk(document.children ?? [], (node) => {
+            if (node.name !== "a" && node.name !== "img")
+                return null;
+            const attribute = node.name === "a" ? "href" : "src";
+            const resolved = externalUrl(node.attribs?.[attribute] ?? "", sourceUrl);
+            if (resolved) {
+                node.attribs = { ...(node.attribs ?? {}), [attribute]: resolved };
+                return null;
+            }
+            return node.name === "a" ? node.children ?? [] : [];
+        });
+        return renderNodes(document.children);
+    }
+    const pageReferences = [];
+    const assetIds = [];
+    walk(document.children ?? [], (node) => {
+        const value = node.name === "a" ? node.attribs?.href : node.name === "img" ? node.attribs?.src : null;
+        const reference = readPhiInternalReference(value);
+        if (reference?.kind === "page")
+            pageReferences.push(reference.reference);
+        if (reference?.kind === "asset")
+            assetIds.push(reference.assetId);
+        return null;
+    });
+    const resolved = await resolvePhiWidgetInternalReferences({
+        runtime: input.runtime,
+        pageReferences,
+        assetIds,
+    });
+    document.children = walk(document.children ?? [], (node) => {
+        if (node.name === "a") {
+            const href = node.attribs?.href ?? "";
+            const reference = readPhiInternalReference(href);
+            if (reference?.kind === "page") {
+                const path = resolved.pagePaths.get(reference.reference);
+                if (!path)
+                    return node.children ?? [];
+                node.attribs = {
+                    ...(node.attribs ?? {}),
+                    href: `${path}${reference.fragment ? `#${encodeURIComponent(reference.fragment)}` : ""}`,
+                };
+                return null;
+            }
+            if (href.startsWith("/") || (!/^(?:https?:|mailto:|tel:|#)/iu.test(href)))
+                return node.children ?? [];
+        }
+        if (node.name === "img") {
+            const src = node.attribs?.src ?? "";
+            const reference = readPhiInternalReference(src);
+            if (reference?.kind === "asset") {
+                const deliveryUrl = resolved.assetUrls.get(reference.assetId);
+                if (!deliveryUrl)
+                    return [];
+                node.attribs = { ...(node.attribs ?? {}), src: deliveryUrl };
+                return null;
+            }
+            if (!/^https?:/iu.test(src))
+                return [];
+        }
+        return null;
+    });
+    return renderNodes(document.children);
+}

package/components/widgets/helpers/internal-reference-resolver.server.d.ts

@@ -0,0 +1,21 @@
+import "server-only";
+import type { PhiBlockRuntime } from "../../../types";
+import { type PhiPageReference } from "../../../types/references";
+/**
+ * Resolves one Asset reference for a Widget that binds a single Asset by id.
+ *
+ * Uses the same bulk endpoint as the content resolver so there is exactly one Asset resolution path.
+ * Returns `null` when the id is not a publicly deliverable Site Space Asset.
+ */
+export declare function resolvePhiPublicAssetReference(input: {
+    runtime: Pick<PhiBlockRuntime, "site">;
+    assetId: number;
+}): Promise<import("../../../types").PhiPublicMediaAssetReference | null>;
+export declare function resolvePhiWidgetInternalReferences(input: {
+    runtime: Pick<PhiBlockRuntime, "site" | "locale" | "area" | "viewer">;
+    pageReferences: readonly PhiPageReference[];
+    assetIds: readonly number[];
+}): Promise<{
+    pagePaths: Map<PhiPageReference, string>;
+    assetUrls: Map<number, string>;
+}>;

package/components/widgets/helpers/internal-reference-resolver.server.js

@@ -0,0 +1,63 @@
+import "server-only";
+import { resolveSiteInternalReferences } from "../../../gateway/internal-references";
+import { resolvePhiCmsRoutePresetByIdentity } from "../../../plugins/runtime-modules/descriptor-compiler";
+import { resolvePhiNavHref } from "../../../helpers/locale";
+import { phiRuntime } from "../../../server-helpers/phi-runtime";
+import { canPhiViewerAccess } from "../../../types/access";
+import { readPhiPageReference } from "../../../types/references";
+/**
+ * Resolves one Asset reference for a Widget that binds a single Asset by id.
+ *
+ * Uses the same bulk endpoint as the content resolver so there is exactly one Asset resolution path.
+ * Returns `null` when the id is not a publicly deliverable Site Space Asset.
+ */
+export async function resolvePhiPublicAssetReference(input) {
+    const rt = phiRuntime(input.runtime);
+    const projection = await resolveSiteInternalReferences({
+        apiBaseUrl: rt.apiBaseUrl,
+        internalToken: rt.internalToken,
+        siteKey: rt.siteKey,
+        assetIds: [input.assetId],
+    });
+    return projection.assets.get(input.assetId) ?? null;
+}
+export async function resolvePhiWidgetInternalReferences(input) {
+    const rt = phiRuntime(input.runtime);
+    const pageReferences = [...new Set(input.pageReferences)];
+    /**
+     * Both sources are Area-relative CMS paths, and `REFERENCES.md` requires the resolved href to be
+     * locale- and Area-correct. Navigation already localizes through this helper, so references share
+     * it rather than growing a second rule.
+     */
+    const href = (path) => resolvePhiNavHref(input.runtime.locale.current, input.runtime.area, path);
+    const projection = await resolveSiteInternalReferences({
+        apiBaseUrl: rt.apiBaseUrl,
+        internalToken: rt.internalToken,
+        siteKey: rt.siteKey,
+        area: input.runtime.area,
+        references: pageReferences,
+        assetIds: input.assetIds,
+    });
+    const pagePaths = new Map(projection.pages.flatMap((entry) => entry.targetKind === "site" && !entry.deleted && entry.path
+        ? [[entry.reference, href(entry.path)]]
+        : []));
+    const { catalog, activeModuleIds } = await import("../../../server-helpers/request-runtime")
+        .then(({ getPhiRequestNavigationContext }) => getPhiRequestNavigationContext(input.runtime.area));
+    for (const rawReference of pageReferences) {
+        if (pagePaths.has(rawReference))
+            continue;
+        const reference = readPhiPageReference(rawReference);
+        if (!reference || reference.target.kind !== "module")
+            continue;
+        const route = resolvePhiCmsRoutePresetByIdentity(catalog, reference.target.ownerModuleId, reference.target.presetKey);
+        if (route && route.area === input.runtime.area && activeModuleIds.has(route.ownerModuleId) &&
+            canPhiViewerAccess(input.runtime.viewer, route.accessPolicy)) {
+            pagePaths.set(reference.reference, href(route.path));
+        }
+    }
+    // The resolver emits only publicly deliverable Site Space Assets, so an absent id is simply not
+    // renderable and must not be re-filtered here.
+    const assetUrls = new Map([...projection.assets.values()]
+        .flatMap((asset) => asset.deliveryUrl ? [[asset.id, asset.deliveryUrl]] : []));
+    return { pagePaths, assetUrls };
+}

package/components/widgets/helpers/semantic-html-translation.d.ts

@@ -0,0 +1,2 @@
+import "server-only";
+export declare function translateSemanticHtml(sourceHtml: string, sourceLocale?: string): Promise<string>;

package/components/widgets/helpers/semantic-html-translation.js

@@ -0,0 +1,76 @@
+import "server-only";
+import renderHtml from "dom-serializer";
+import { parseDocument } from "htmlparser2";
+import { trBulk } from "../../../server-helpers/translate";
+import { sanitizePhiHtmlWidgetMarkup } from "./html-content";
+const SEMANTIC_HTML_BLOCKS = new Set([
+    "p",
+    "div",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "li",
+    "blockquote",
+    "td",
+    "th",
+]);
+function isElement(node) {
+    return node.type === "tag" || node.type === "script" || node.type === "style";
+}
+function hasSemanticDescendant(node) {
+    return (node.children ?? []).some((child) => (isElement(child) && SEMANTIC_HTML_BLOCKS.has(child.name?.toLowerCase() ?? "")) ||
+        hasSemanticDescendant(child));
+}
+function collectSemanticBlocks(node, result) {
+    if (isElement(node) &&
+        SEMANTIC_HTML_BLOCKS.has(node.name?.toLowerCase() ?? "") &&
+        !hasSemanticDescendant(node)) {
+        result.push(node);
+        return;
+    }
+    for (const child of node.children ?? []) {
+        collectSemanticBlocks(child, result);
+    }
+}
+function markCodeAsNonTranslatable(node) {
+    if (isElement(node) && (node.name === "code" || node.name === "pre")) {
+        node.attribs = { ...(node.attribs ?? {}), translate: "no" };
+    }
+    for (const child of node.children ?? []) {
+        markCodeAsNonTranslatable(child);
+    }
+}
+function renderNodes(nodes) {
+    return nodes.map((node) => renderHtml(node, { encodeEntities: "utf8" })).join("");
+}
+function hasVisibleText(html) {
+    return html.replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").trim().length > 0;
+}
+export async function translateSemanticHtml(sourceHtml, sourceLocale) {
+    const sanitized = sanitizePhiHtmlWidgetMarkup(sourceHtml);
+    if (!sanitized) {
+        return "";
+    }
+    const document = parseDocument(sanitized);
+    markCodeAsNonTranslatable(document);
+    const blocks = [];
+    collectSemanticBlocks(document, blocks);
+    const units = (blocks.length > 0 ? blocks : [document])
+        .map((node) => ({ node, html: renderNodes(node.children ?? []) }))
+        .filter((unit) => hasVisibleText(unit.html));
+    if (units.length === 0) {
+        return sanitized;
+    }
+    const translated = await trBulk(units.map((unit) => unit.html), 0, "html", sourceLocale);
+    units.forEach((unit, index) => {
+        const fragment = parseDocument(translated[index] ?? unit.html);
+        unit.node.children = fragment.children ?? [];
+        for (const child of unit.node.children) {
+            child.parent = unit.node;
+        }
+    });
+    return sanitizePhiHtmlWidgetMarkup(renderNodes(document.children ?? []));
+}

package/components/widgets/helpers/widget-source-url.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The address a Widget fetches its source from, for a source an author wrote as a path on this Site.
+ *
+ * A path is resolved against the Site's public URL, the address its visitors use, rather than against
+ * the host the current request came in on. The result used to be the same behind the proxy, but reading
+ * the request tied every page with such a Widget to that request, and a page that is the same for
+ * everybody could not be rendered once for all of them. Anything that is not a path is returned as
+ * written.
+ */
+export declare function resolvePhiWidgetSourceUrl(sourceUrl: string, publicUrl: string | null | undefined): string;

package/components/widgets/helpers/widget-source-url.js

@@ -0,0 +1,20 @@
+/**
+ * The address a Widget fetches its source from, for a source an author wrote as a path on this Site.
+ *
+ * A path is resolved against the Site's public URL, the address its visitors use, rather than against
+ * the host the current request came in on. The result used to be the same behind the proxy, but reading
+ * the request tied every page with such a Widget to that request, and a page that is the same for
+ * everybody could not be rendered once for all of them. Anything that is not a path is returned as
+ * written.
+ */
+export function resolvePhiWidgetSourceUrl(sourceUrl, publicUrl) {
+    const trimmed = sourceUrl.trim();
+    if (!trimmed.startsWith("/") || trimmed.startsWith("//")) {
+        return trimmed;
+    }
+    const base = publicUrl?.trim() ?? "";
+    if (!base) {
+        throw new Error(`Cannot resolve the relative source ${trimmed} without the Site's public URL.`);
+    }
+    return new URL(trimmed, base.endsWith("/") ? base : `${base}/`).toString();
+}

package/components/widgets/inspector-field-row.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+/** The label column every Inspector row shares, so a control that draws its own header lines up with the rest. */
+export declare const PHI_INSPECTOR_FIELD_LABEL_WIDTH = 140;
+export declare function PhiInspectorFieldRow({ label, children, labelWidth, }: {
+    label: ReactNode;
+    children: ReactNode;
+    labelWidth?: number;
+}): import("react").JSX.Element;

package/components/widgets/inspector-field-row.js

@@ -0,0 +1,8 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Flex, Typography } from "antd";
+/** The label column every Inspector row shares, so a control that draws its own header lines up with the rest. */
+export const PHI_INSPECTOR_FIELD_LABEL_WIDTH = 140;
+export function PhiInspectorFieldRow({ label, children, labelWidth = PHI_INSPECTOR_FIELD_LABEL_WIDTH, }) {
+    return (_jsxs(Flex, { align: "flex-start", gap: 12, wrap: false, style: { width: "100%" }, children: [_jsx(Typography.Text, { style: { flex: `0 0 ${labelWidth}px`, minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", lineHeight: "var(--ant-control-height)" }, children: label }), _jsx("div", { style: { flex: "1 1 auto", minWidth: 0 }, children: children })] }));
+}

package/components/widgets/label-sets/account.d.ts

@@ -0,0 +1,64 @@
+import "server-only";
+import { type PhiGlobalTranslatorOptions } from "../../../gateway/tr";
+export declare function getPhiAccountMenuLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    trigger: {
+        account: string;
+    };
+    guest: {
+        login: string;
+        register: string;
+    };
+    authenticated: {
+        profile: string;
+        settings: string;
+        logout: string;
+    };
+}>;
+export declare function getPhiLoginFormLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    title: string;
+    actions: {
+        submitLabel: string;
+        forgotPasswordLabel: string;
+        registerLabel: string;
+    };
+    fields: {
+        email: {
+            label: string;
+            required: string;
+            invalid: string;
+        };
+        password: {
+            label: string;
+            required: string;
+        };
+    };
+    errors: {
+        accountDisabled: string;
+        initSession: string;
+        invalidCredentials: string;
+        loginFailed: string;
+        network: string;
+    };
+}>;
+/**
+ * The second form on the Login page, for the visitor an external provider has just identified.
+ *
+ * It is its own form because it asks its own question -- one password, for an account that already
+ * exists -- and it is reached only by coming back from a provider with `?auth=link_required`.
+ */
+export declare function getPhiProviderLinkConfirmationFormLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    providerLink: {
+        passwordLabel: string;
+        passwordRequired: string;
+    };
+    actions: {
+        submitLabel: string;
+    };
+}>;
+/** What the row of external providers says, which is not the form's business and not its label set. */
+export declare function getPhiAuthMethodsLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    separator: string;
+    failed: string;
+    unavailable: string;
+}>;
+export declare const getPhiAccountLoginModalLabels: typeof getPhiLoginFormLabels;

package/components/widgets/label-sets/account.js

@@ -0,0 +1,117 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../gateway/tr";
+import { definePhiLabelSet, definePhiMessageLabel, getPhiLabelSet } from "../../../gateway/label-set";
+const PHI_ACCOUNT_MENU_LABEL_SET = definePhiLabelSet({
+    key: "widget:account-menu",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        account: "Account",
+        login: "Login",
+        register: "Register",
+        profile: "Profile",
+        settings: "Settings",
+        logout: "Logout",
+    },
+});
+const PHI_LOGIN_MODAL_LABEL_SET = definePhiLabelSet({
+    key: "widget:login-modal",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        title: "Login",
+        submit_label: "Sign in",
+        email_label: "Email",
+        password_label: "Password",
+        forgot_password_label: "Forgot password",
+        register_label: "Create account",
+        email_required: definePhiMessageLabel("Please enter your email."),
+        email_invalid: definePhiMessageLabel("Please enter a valid email address."),
+        password_required: definePhiMessageLabel("Please enter your password."),
+        error_init_session: definePhiMessageLabel("Could not initialize login session."),
+        error_account_disabled: definePhiMessageLabel("Your account is disabled. Please contact support."),
+        error_invalid_credentials: definePhiMessageLabel("Invalid credentials."),
+        error_login_failed: definePhiMessageLabel("Login failed."),
+        error_network: definePhiMessageLabel("Network error while logging in."),
+        methods_separator: "Or continue with",
+        provider_link_title: "Confirm your existing account",
+        provider_link_text: definePhiMessageLabel("The provider verified an email address that already belongs to an account here. Enter that account's password once to link the two."),
+        provider_link_password_label: "Password",
+        provider_link_password_required: definePhiMessageLabel("Enter your existing account password."),
+        provider_link_submit_label: "Link account and sign in",
+        error_method_failed: definePhiMessageLabel("Authentication could not be started."),
+        error_method_unavailable: definePhiMessageLabel("Could not initialize the sign-in session."),
+    },
+});
+export async function getPhiAccountMenuLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_ACCOUNT_MENU_LABEL_SET);
+    return {
+        trigger: {
+            account: labels.account,
+        },
+        guest: {
+            login: labels.login,
+            register: labels.register,
+        },
+        authenticated: {
+            profile: labels.profile,
+            settings: labels.settings,
+            logout: labels.logout,
+        },
+    };
+}
+export async function getPhiLoginFormLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_LOGIN_MODAL_LABEL_SET);
+    return {
+        title: labels.title,
+        actions: {
+            submitLabel: labels.submit_label,
+            forgotPasswordLabel: labels.forgot_password_label,
+            registerLabel: labels.register_label,
+        },
+        fields: {
+            email: {
+                label: labels.email_label,
+                required: labels.email_required,
+                invalid: labels.email_invalid,
+            },
+            password: {
+                label: labels.password_label,
+                required: labels.password_required,
+            },
+        },
+        errors: {
+            accountDisabled: labels.error_account_disabled,
+            initSession: labels.error_init_session,
+            invalidCredentials: labels.error_invalid_credentials,
+            loginFailed: labels.error_login_failed,
+            network: labels.error_network,
+        },
+    };
+}
+/**
+ * The second form on the Login page, for the visitor an external provider has just identified.
+ *
+ * It is its own form because it asks its own question -- one password, for an account that already
+ * exists -- and it is reached only by coming back from a provider with `?auth=link_required`.
+ */
+export async function getPhiProviderLinkConfirmationFormLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_LOGIN_MODAL_LABEL_SET);
+    return {
+        providerLink: {
+            passwordLabel: labels.provider_link_password_label,
+            passwordRequired: labels.provider_link_password_required,
+        },
+        actions: {
+            submitLabel: labels.provider_link_submit_label,
+        },
+    };
+}
+/** What the row of external providers says, which is not the form's business and not its label set. */
+export async function getPhiAuthMethodsLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_LOGIN_MODAL_LABEL_SET);
+    return {
+        separator: labels.methods_separator,
+        failed: labels.error_method_failed,
+        unavailable: labels.error_method_unavailable,
+    };
+}
+export const getPhiAccountLoginModalLabels = getPhiLoginFormLabels;

package/components/widgets/label-sets/admin-locales.d.ts

@@ -0,0 +1,55 @@
+import "server-only";
+import { type PhiGlobalTranslatorOptions } from "../../../gateway/tr";
+export declare function getPhiAdminLocalesWidgetLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    title: string;
+    description: string;
+    defaultLocaleLabel: string;
+    availableLocalesLabel: string;
+    saveLocalesLabel: string;
+    savedLabel: string;
+    translationsTitle: string;
+    translationsDescription: string;
+    footer: string;
+    languageLabel: string;
+    searchPlaceholder: string;
+    resetLabel: string;
+    refreshLabel: string;
+    deleteSelectedLabel: string;
+    deleteSiteKeysLabel: string;
+    deleteSiteKeysSuccessLabel: string;
+    columns: {
+        source: string;
+        context: string;
+        translation: string;
+        updated: string;
+        actions: string;
+    };
+    actions: {
+        edit: string;
+        delete: string;
+    };
+    edit: {
+        title: string;
+        translationLabel: string;
+        cancel: string;
+        save: string;
+    };
+    delete: {
+        title: string;
+        description: string;
+        siteKeysTitle: string;
+        siteKeysDescription: string;
+        selectedTitle: string;
+        selectedDescription: string;
+    };
+    empty: {
+        title: string;
+        text: string;
+    };
+    errors: {
+        load: string;
+        save: string;
+        delete: string;
+        deleteSiteKeys: string;
+    };
+}>;

package/components/widgets/label-sets/admin-locales.js

@@ -0,0 +1,104 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../gateway/tr";
+import { definePhiLabelSet, definePhiMessageLabel, getPhiLabelSet } from "../../../gateway/label-set";
+const PHI_ADMIN_LOCALES_WIDGET_LABEL_SET = definePhiLabelSet({
+    key: "widget:admin-locales",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        title: "Locales",
+        description: definePhiMessageLabel("Manage the current site's available languages and site translations."),
+        default_locale_label: "Default language",
+        available_locales_label: "Available languages",
+        save_locales_label: "Save languages",
+        saved_label: definePhiMessageLabel("Saved."),
+        translations_title: "Site translations",
+        translations_description: definePhiMessageLabel("Edit or delete translated variants for the selected site language."),
+        footer_count: "%1 translations of %2 total",
+        language_label: "Language",
+        search_placeholder: "Search source, context, or translation",
+        reset_label: "Reset",
+        refresh_label: "Refresh",
+        delete_selected_label: "Delete selected",
+        delete_site_keys_label: "Delete locale translations",
+        delete_site_keys_success_label: definePhiMessageLabel("Deleted."),
+        column_source: "Source",
+        column_context: "Context",
+        column_translation: "Translation",
+        column_updated: "Updated",
+        column_actions: "Actions",
+        action_edit: "Edit",
+        action_delete: "Delete",
+        edit_title: "Edit translation",
+        translation_label: "Translation",
+        cancel_label: "Cancel",
+        save_label: "Save",
+        delete_title: "Delete translation",
+        delete_description: definePhiMessageLabel("Delete this translated variant?"),
+        delete_site_keys_title: definePhiMessageLabel("Delete translations for %1?"),
+        delete_site_keys_description: definePhiMessageLabel("Only the translations for %1 will be deleted. Global translations are not affected."),
+        delete_selected_title: definePhiMessageLabel("Delete %1 selected translations?"),
+        delete_selected_description: definePhiMessageLabel("The selected translated variants will be deleted permanently."),
+        empty_title: definePhiMessageLabel("No translations found."),
+        empty_text: definePhiMessageLabel("No site translations exist for this language yet."),
+        load_error: definePhiMessageLabel("Failed to load locale data."),
+        save_error: definePhiMessageLabel("Failed to save locale data."),
+        delete_error: definePhiMessageLabel("Failed to delete translation."),
+        delete_site_keys_error: definePhiMessageLabel("Failed to delete site translation keys."),
+    },
+});
+export async function getPhiAdminLocalesWidgetLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_ADMIN_LOCALES_WIDGET_LABEL_SET);
+    return {
+        title: labels.title,
+        description: labels.description,
+        defaultLocaleLabel: labels.default_locale_label,
+        availableLocalesLabel: labels.available_locales_label,
+        saveLocalesLabel: labels.save_locales_label,
+        savedLabel: labels.saved_label,
+        translationsTitle: labels.translations_title,
+        translationsDescription: labels.translations_description,
+        footer: labels.footer_count,
+        languageLabel: labels.language_label,
+        searchPlaceholder: labels.search_placeholder,
+        resetLabel: labels.reset_label,
+        refreshLabel: labels.refresh_label,
+        deleteSelectedLabel: labels.delete_selected_label,
+        deleteSiteKeysLabel: labels.delete_site_keys_label,
+        deleteSiteKeysSuccessLabel: labels.delete_site_keys_success_label,
+        columns: {
+            source: labels.column_source,
+            context: labels.column_context,
+            translation: labels.column_translation,
+            updated: labels.column_updated,
+            actions: labels.column_actions,
+        },
+        actions: {
+            edit: labels.action_edit,
+            delete: labels.action_delete,
+        },
+        edit: {
+            title: labels.edit_title,
+            translationLabel: labels.translation_label,
+            cancel: labels.cancel_label,
+            save: labels.save_label,
+        },
+        delete: {
+            title: labels.delete_title,
+            description: labels.delete_description,
+            siteKeysTitle: labels.delete_site_keys_title,
+            siteKeysDescription: labels.delete_site_keys_description,
+            selectedTitle: labels.delete_selected_title,
+            selectedDescription: labels.delete_selected_description,
+        },
+        empty: {
+            title: labels.empty_title,
+            text: labels.empty_text,
+        },
+        errors: {
+            load: labels.load_error,
+            save: labels.save_error,
+            delete: labels.delete_error,
+            deleteSiteKeys: labels.delete_site_keys_error,
+        },
+    };
+}