@captiveorigins/payload-plugin-polyglot 0.0.0-stage → 0.1.0

package/dist/rsc/PolyglotView.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DefaultTemplate } from '@payloadcms/next/templates';
+import { PolyglotDashboard } from '../client/PolyglotDashboard.js';
+import { polyglotOf } from '../translate.js';
+const labelOf = (payload, slug) => {
+    const l = payload.collections[slug]?.config.labels?.plural;
+    return typeof l === 'string' ? l : slug;
+};
+/** /admin/polyglot: coverage per collection and language, Translate now. */
+export async function PolyglotView({ initPageResult, params, searchParams }) {
+    const { req, permissions, visibleEntities, locale } = initPageResult;
+    const o = polyglotOf(req.payload);
+    const allowed = Boolean(req.user) && (await (o.canManage ?? (() => true))({ req }));
+    const collections = Object.keys(o.collections);
+    return (_jsx(DefaultTemplate, { i18n: req.i18n, locale: locale, params: params, payload: req.payload, permissions: permissions, req: req, searchParams: searchParams, user: req.user ?? undefined, visibleEntities: visibleEntities, children: _jsxs("div", { className: "gutter--left gutter--right", style: { paddingBlock: 'calc(var(--base) * 2)' }, children: [_jsx("h1", { children: "Translations" }), allowed ? (_jsx(PolyglotDashboard, { apiRoute: req.payload.config.routes.api, collections: collections, labels: Object.fromEntries(collections.map((c) => [c, labelOf(req.payload, c)])) })) : (_jsx("p", { children: "You don\u2019t have access to translations." }))] }) }));
+}
+/** Nav link, for people who may manage translations. */
+export async function PolyglotNavLink({ payload, user }) {
+    const o = polyglotOf(payload);
+    if (!user || !(await (o.canManage ?? (() => true))({ req: { user, payload } })))
+        return null;
+    return (_jsx("a", { className: "nav__link", href: `${payload.config.routes.admin}/polyglot`, style: { display: 'block', marginTop: 'calc(var(--base) / 2)' }, children: _jsx("span", { className: "nav__link-label", children: "Translations" }) }));
+}

package/dist/rsc/index.d.ts

@@ -0,0 +1 @@
+export { PolyglotNavLink, PolyglotView } from './PolyglotView.js';

package/dist/rsc/index.js

@@ -0,0 +1 @@
+export { PolyglotNavLink, PolyglotView } from './PolyglotView.js';

package/dist/text.d.ts

@@ -0,0 +1,27 @@
+/** Default placeholder copy that is never translated (nor paid for). */
+export declare const FILLER: RegExp;
+/** Keys whose string values are never visible text. */
+export declare const SKIP_KEYS: string[];
+export type Json = string | number | boolean | null | Json[] | {
+    [k: string]: Json;
+};
+type Rules = {
+    skip: RegExp;
+    skipKeys: Set<string>;
+};
+/**
+ * Visits every visible string in a value: words of rich-text (Lexical) text
+ * nodes, and plain strings outside skipped keys. `set` replaces it in place.
+ */
+export declare function visitText(node: Json, rules: Rules, onText: (text: string, set: (t: string) => void) => void): void;
+/** All visible strings of the listed paths, in order. */
+export declare function textsOf(source: Record<string, Json>, paths: string[], rules: Rules): string[];
+export declare const fingerprint: (texts: string[]) => string;
+export declare const memoryKey: (locale: string, text: string) => string;
+/**
+ * Visits the text of exactly the listed paths of a document: `title` visits the
+ * whole field; `sections.heading` only the heading of each section (other fields
+ * of the rows, shared across languages, are never touched).
+ */
+export declare function visitPaths(source: Record<string, Json>, paths: string[], rules: Rules, onText: (text: string, set: (t: string) => void) => void): void;
+export {};

package/dist/text.js

@@ -0,0 +1,82 @@
+import crypto from 'node:crypto';
+/** Default placeholder copy that is never translated (nor paid for). */
+export const FILLER = /lorem ipsum|dolor sit amet|consectetur adipiscing|sed do eiusmod|ut labore et dolore/i;
+/** Keys whose string values are never visible text. */
+export const SKIP_KEYS = [
+    'id', 'url', 'href', 'slug', 'path', 'key', 'type', 'blockType', 'blockName', 'format', 'mode', 'direction', 'version',
+    'style', 'detail', 'relationTo', 'value', 'tag', 'listType', 'textFormat', 'textStyle', 'linkType', 'appearance',
+    'reference', 'icon', 'status', 'newTab', 'indent', 'start', 'checked', 'language', 'mediaType', 'collection',
+];
+/** Strings that are links, ids, slugs, option values or dates rather than text. */
+const NOT_TEXT = /^(https?:\/\/|mailto:|\/|#)|^[a-f0-9]{24}$|^[a-z0-9]+(-[a-z0-9]+)*$|^\d{4}-\d{2}-\d{2}/;
+const isText = (v, r) => Boolean(v.trim()) && !NOT_TEXT.test(v.trim()) && !r.skip.test(v);
+/**
+ * Visits every visible string in a value: words of rich-text (Lexical) text
+ * nodes, and plain strings outside skipped keys. `set` replaces it in place.
+ */
+export function visitText(node, rules, onText) {
+    if (Array.isArray(node)) {
+        node.forEach((child, i) => {
+            if (typeof child === 'string') {
+                if (isText(child, rules))
+                    onText(child, (t) => (node[i] = t));
+            }
+            else
+                visitText(child, rules, onText);
+        });
+        return;
+    }
+    if (!node || typeof node !== 'object')
+        return;
+    const lexicalText = node.type === 'text' && typeof node.text === 'string';
+    for (const [k, v] of Object.entries(node)) {
+        if (typeof v === 'string') {
+            const wanted = lexicalText ? k === 'text' && !rules.skip.test(v) && Boolean(v.trim()) : !rules.skipKeys.has(k) && isText(v, rules);
+            if (wanted)
+                onText(v, (t) => (node[k] = t));
+        }
+        else if (v && typeof v === 'object') {
+            if (lexicalText || rules.skipKeys.has(k))
+                continue;
+            visitText(v, rules, onText);
+        }
+    }
+}
+/** All visible strings of the listed paths, in order. */
+export function textsOf(source, paths, rules) {
+    const found = [];
+    visitPaths(source, paths, rules, (t) => found.push(t));
+    return found;
+}
+export const fingerprint = (texts) => crypto.createHash('sha256').update(JSON.stringify(texts)).digest('hex').slice(0, 32);
+export const memoryKey = (locale, text) => crypto.createHash('sha256').update(`${locale}\u0000${text}`).digest('hex');
+/**
+ * Visits the text of exactly the listed paths of a document: `title` visits the
+ * whole field; `sections.heading` only the heading of each section (other fields
+ * of the rows, shared across languages, are never touched).
+ */
+export function visitPaths(source, paths, rules, onText) {
+    const walk = (holder, segs) => {
+        const [head, ...rest] = segs;
+        if (!head || !(head in holder))
+            return;
+        const value = holder[head];
+        if (!rest.length) {
+            if (typeof value === 'string') {
+                if (isText(value, rules))
+                    onText(value, (t) => (holder[head] = t));
+            }
+            else if (value && typeof value === 'object')
+                visitText(value, rules, onText);
+            return;
+        }
+        if (Array.isArray(value))
+            for (const row of value)
+                if (row && typeof row === 'object' && !Array.isArray(row))
+                    walk(row, rest);
+                else if (value && typeof value === 'object' && !Array.isArray(value))
+                    walk(value, rest);
+    };
+    for (const p of paths)
+        walk(source, p.split('.'));
+}

package/dist/translate.d.ts

@@ -0,0 +1,67 @@
+import type { Payload } from 'payload';
+import { type DocumentResult, type ResolvedPolyglot } from './types.js';
+export declare const polyglotOf: (payload: Payload) => ResolvedPolyglot;
+/** Is this document one Polyglot translates? */
+export declare function included(o: ResolvedPolyglot, collection: string, doc: Record<string, unknown>): boolean;
+/** A per-run character budget (free tiers). */
+export declare class Budget {
+    private readonly max?;
+    used: number;
+    constructor(max?: number | undefined);
+    allows(chars: number): boolean;
+    spend(chars: number): void;
+}
+/**
+ * Bring one document up to date in every language (or `locales`). Unchanged
+ * source costs nothing (the fingerprint matches); known sentences come from
+ * memory; only new ones reach the translator. Reviewed languages are never
+ * overwritten: they are marked stale. Languages are written one at a time.
+ */
+export declare function translateDocument(payload: Payload, collection: string, id: string, opts?: {
+    locales?: string[];
+    dryRun?: boolean;
+    memoryOnly?: boolean;
+    inRequest?: boolean;
+    budget?: Budget;
+}): Promise<DocumentResult>;
+export type SyncReport = {
+    documents: number;
+    upToDate: number;
+    translated: number;
+    pending: number;
+    reviewedStale: number;
+    failed: number;
+    characters: number;
+    stopped: 'done' | 'budget' | 'quota';
+};
+/**
+ * Find all content and bring it up to date (the sweep). With a translator that
+ * has `batch` and `useBatch`, every missing sentence of every language goes in
+ * one batch first (cheaper), then documents are written from memory. Stops
+ * cleanly at `maxCharactersPerRun` or when the engine's quota is used up; the
+ * next run continues. `dryRun` only reports what is pending.
+ */
+export declare function syncAll(payload: Payload, opts?: {
+    dryRun?: boolean;
+    useBatch?: boolean;
+    limit?: number;
+    collections?: string[];
+    locales?: string[];
+}): Promise<SyncReport>;
+/** Translation status of one document in one language, for notices: source, reviewed, stale, machine or pending. */
+export declare function languageStatus(payload: Payload, collection: string, doc: Record<string, unknown>, locale: string): Promise<"source" | "stale" | "pending" | "reviewed" | "machine">;
+export type CoverageRow = {
+    collection: string;
+    documents: number;
+    /** Per language: up to date, waiting, reviewed by a human, reviewed but the source changed. */
+    locales: Record<string, {
+        translated: number;
+        pending: number;
+        reviewed: number;
+        stale: number;
+    }>;
+};
+/** Translation coverage per collection and language (for the admin view and reports). */
+export declare function coverage(payload: Payload, opts?: {
+    collections?: string[];
+}): Promise<CoverageRow[]>;

package/dist/translate.js

@@ -0,0 +1,300 @@
+import { fingerprint, memoryKey, textsOf, visitPaths } from './text.js';
+import { QuotaExceededError } from './types.js';
+export const polyglotOf = (payload) => payload.config.custom?.polyglot;
+const rulesOf = (o) => ({ skip: o.skip, skipKeys: new Set(o.skipKeys) });
+const topFields = (o, slug) => [...new Set((o.collections[slug] ?? []).map((p) => p.split('.')[0]))];
+const stateKey = (collection, id, locale) => `${collection}:${id}:${locale}`;
+const engineFor = (o, locale) => o.translatorFor?.(locale) ?? o.translator;
+/** Is this document one Polyglot translates? */
+export function included(o, collection, doc) {
+    if (!o.collections[collection])
+        return false;
+    if (o.include)
+        return o.include({ collection, doc });
+    return doc._status === undefined || doc._status === 'published';
+}
+async function loadSource(payload, o, slug, id) {
+    const doc = (await payload.findByID({
+        collection: slug,
+        id,
+        locale: o.defaultLocale,
+        depth: 0,
+        draft: false,
+        overrideAccess: true,
+        disableErrors: true,
+    }));
+    if (!doc || !included(o, slug, doc))
+        return null;
+    const source = Object.fromEntries(topFields(o, slug).filter((k) => doc[k] !== undefined && doc[k] !== null).map((k) => [k, structuredClone(doc[k])]));
+    const texts = textsOf(source, o.collections[slug], rulesOf(o));
+    const reviewed = new Set((doc[o.statusField]?.reviewed ?? []));
+    const { docs } = await payload.find({
+        collection: o.stateSlug,
+        where: { and: [{ collection: { equals: slug } }, { doc: { equals: id } }] },
+        pagination: false,
+        depth: 0,
+        overrideAccess: true,
+    });
+    const state = new Map(docs.map((r) => [r.locale, r]));
+    return { doc, source, texts, hash: fingerprint(texts), state, reviewed };
+}
+async function saveState(payload, o, collection, id, locale, hash, stale, existing) {
+    const data = { key: stateKey(collection, id, locale), collection, doc: id, locale, hash, stale, at: new Date().toISOString() };
+    if (existing)
+        await payload.update({ collection: o.stateSlug, id: existing.id, data: data, overrideAccess: true });
+    else
+        await payload.create({ collection: o.stateSlug, data: data, overrideAccess: true });
+}
+/** Translations known in memory for these texts in one language. */
+async function recall(payload, o, locale, texts) {
+    const known = new Map();
+    if (!texts.length)
+        return known;
+    const { docs } = await payload.find({
+        collection: o.memorySlug,
+        where: { key: { in: texts.map((t) => memoryKey(locale, t)) } },
+        pagination: false,
+        depth: 0,
+        overrideAccess: true,
+        select: { key: true, text: true },
+    });
+    const byKey = new Map(docs.map((d) => [d.key, d.text]));
+    for (const t of texts) {
+        const hit = byKey.get(memoryKey(locale, t));
+        if (hit)
+            known.set(t, hit);
+    }
+    return known;
+}
+async function remember(payload, o, locale, pairs) {
+    for (const [source, text] of pairs)
+        await payload
+            .create({ collection: o.memorySlug, data: { key: memoryKey(locale, source), locale, source, text }, overrideAccess: true })
+            .catch(() => undefined); // already remembered (unique key)
+}
+const CHUNK = 80;
+const chunks = (list) => Array.from({ length: Math.ceil(list.length / CHUNK) }, (_, i) => list.slice(i * CHUNK, (i + 1) * CHUNK));
+const argsFor = (o, locale, items, context) => ({
+    locale,
+    items,
+    context,
+    sourceLocale: o.defaultLocale,
+    keep: o.keep,
+});
+/** A per-run character budget (free tiers). */
+export class Budget {
+    max;
+    used = 0;
+    constructor(max) {
+        this.max = max;
+    }
+    allows(chars) {
+        return this.max === undefined || this.used + chars <= this.max;
+    }
+    spend(chars) {
+        this.used += chars;
+    }
+}
+/**
+ * Bring one document up to date in every language (or `locales`). Unchanged
+ * source costs nothing (the fingerprint matches); known sentences come from
+ * memory; only new ones reach the translator. Reviewed languages are never
+ * overwritten: they are marked stale. Languages are written one at a time.
+ */
+export async function translateDocument(payload, collection, id, opts = {}) {
+    const o = polyglotOf(payload);
+    const result = { translated: [], upToDate: [], reviewedStale: [], failed: [], pending: [] };
+    const src = await loadSource(payload, o, collection, id);
+    if (!src)
+        return result;
+    const todo = [];
+    for (const locale of opts.locales ?? o.locales) {
+        const row = src.state.get(locale);
+        if (row?.hash === src.hash)
+            result.upToDate.push(locale);
+        else if (src.reviewed.has(locale)) {
+            result.reviewedStale.push(locale);
+            if (!opts.dryRun && row && !row.stale)
+                await saveState(payload, o, collection, id, locale, row.hash, true, row);
+        }
+        else
+            todo.push(locale);
+    }
+    if (opts.dryRun)
+        return { ...result, pending: todo };
+    const unique = [...new Set(src.texts)];
+    const context = { ...(o.writeContext?.({ inRequest: Boolean(opts.inRequest) }) ?? {}), polyglot: true };
+    for (const [n, locale] of todo.entries()) {
+        try {
+            let known = await recall(payload, o, locale, unique);
+            const missing = unique.filter((t) => !known.has(t));
+            if (missing.length && !opts.memoryOnly) {
+                const chars = missing.reduce((s, t) => s + t.length, 0);
+                if (opts.budget && !opts.budget.allows(chars)) {
+                    result.pending.push(...todo.slice(n));
+                    break;
+                }
+                for (const part of chunks(missing)) {
+                    const items = part.map((text, i) => ({ key: String(i), text }));
+                    const out = await engineFor(o, locale).translate(argsFor(o, locale, items, o.describe?.(collection)));
+                    opts.budget?.spend(part.reduce((s, t) => s + t.length, 0));
+                    await remember(payload, o, locale, items.flatMap((it) => (out.get(it.key) ? [[it.text, out.get(it.key)]] : [])));
+                }
+                known = await recall(payload, o, locale, unique);
+            }
+            if (unique.some((t) => !known.has(t))) {
+                ;
+                (opts.memoryOnly ? result.pending : result.failed).push(locale);
+                continue;
+            }
+            const data = structuredClone(src.source);
+            visitPaths(data, o.collections[collection], rulesOf(o), (t, set) => set(known.get(t) ?? t));
+            await payload.update({
+                collection: collection,
+                id,
+                locale: locale,
+                data: { ...data, ...(src.doc._status ? { _status: 'published' } : {}) },
+                overrideAccess: true,
+                context,
+            });
+            await saveState(payload, o, collection, id, locale, src.hash, false, src.state.get(locale));
+            result.translated.push(locale);
+        }
+        catch (error) {
+            if (error instanceof QuotaExceededError) {
+                result.pending.push(...todo.slice(n));
+                throw Object.assign(error, { result });
+            }
+            payload.logger.error({ err: error, collection, id, locale }, 'Polyglot: translation failed');
+            result.failed.push(locale);
+        }
+    }
+    return result;
+}
+/**
+ * Find all content and bring it up to date (the sweep). With a translator that
+ * has `batch` and `useBatch`, every missing sentence of every language goes in
+ * one batch first (cheaper), then documents are written from memory. Stops
+ * cleanly at `maxCharactersPerRun` or when the engine's quota is used up; the
+ * next run continues. `dryRun` only reports what is pending.
+ */
+export async function syncAll(payload, opts = {}) {
+    const o = polyglotOf(payload);
+    const report = { documents: 0, upToDate: 0, translated: 0, pending: 0, reviewedStale: 0, failed: 0, characters: 0, stopped: 'done' };
+    const budget = new Budget(o.maxCharactersPerRun);
+    const targets = [];
+    for (const collection of Object.keys(o.collections).filter((c) => !opts.collections || opts.collections.includes(c))) {
+        const { docs } = await payload.find({ collection: collection, locale: o.defaultLocale, depth: 0, pagination: false, overrideAccess: true, draft: false });
+        for (const d of docs)
+            if (included(o, collection, d))
+                targets.push({ collection, id: String(d.id) });
+    }
+    const locales = opts.locales ?? o.locales;
+    const work = opts.limit ? targets.slice(0, opts.limit) : targets;
+    const batching = Boolean(opts.useBatch && o.translator.batch && !o.translatorFor && !opts.dryRun);
+    if (batching) {
+        const missing = new Map();
+        for (const t of work) {
+            const src = await loadSource(payload, o, t.collection, t.id);
+            if (!src)
+                continue;
+            for (const locale of locales) {
+                if (src.state.get(locale)?.hash === src.hash || src.reviewed.has(locale))
+                    continue;
+                const set = missing.get(locale) ?? new Set();
+                for (const text of src.texts)
+                    set.add(text);
+                missing.set(locale, set);
+            }
+        }
+        const requests = [];
+        for (const [locale, set] of missing) {
+            const known = await recall(payload, o, locale, [...set]);
+            for (const part of chunks([...set].filter((t) => !known.has(t)))) {
+                const chars = part.reduce((s, t) => s + t.length, 0);
+                if (!budget.allows(chars)) {
+                    report.stopped = 'budget';
+                    break;
+                }
+                budget.spend(chars);
+                requests.push(argsFor(o, locale, part.map((text, i) => ({ key: String(i), text }))));
+            }
+        }
+        if (requests.length) {
+            const results = await o.translator.batch(requests);
+            for (const [i, r] of requests.entries())
+                await remember(payload, o, r.locale, r.items.flatMap((it) => (results[i]?.get(it.key) ? [[it.text, results[i].get(it.key)]] : [])));
+        }
+    }
+    for (const t of work) {
+        let r;
+        try {
+            r = await translateDocument(payload, t.collection, t.id, { locales, dryRun: opts.dryRun, memoryOnly: batching, budget: batching ? undefined : budget });
+        }
+        catch (error) {
+            if (!(error instanceof QuotaExceededError))
+                throw error;
+            r = error.result;
+            report.stopped = 'quota';
+        }
+        report.documents++;
+        report.upToDate += r.upToDate.length;
+        report.translated += r.translated.length;
+        report.pending += r.pending.length;
+        report.reviewedStale += r.reviewedStale.length;
+        report.failed += r.failed.length;
+        if (report.stopped === 'quota')
+            break;
+        if (!batching && r.pending.length && !opts.dryRun)
+            report.stopped = 'budget';
+    }
+    report.characters = budget.used;
+    return report;
+}
+/** Translation status of one document in one language, for notices: source, reviewed, stale, machine or pending. */
+export async function languageStatus(payload, collection, doc, locale) {
+    const o = polyglotOf(payload);
+    if (locale === o.defaultLocale)
+        return 'source';
+    const reviewed = (doc[o.statusField]?.reviewed ?? []).includes(locale);
+    const { docs } = await payload.find({
+        collection: o.stateSlug,
+        where: { key: { equals: stateKey(collection, String(doc.id), locale) } },
+        limit: 1,
+        depth: 0,
+        overrideAccess: true,
+    });
+    const row = docs[0];
+    if (reviewed)
+        return row?.stale ? 'stale' : 'reviewed';
+    return row ? 'machine' : 'pending';
+}
+/** Translation coverage per collection and language (for the admin view and reports). */
+export async function coverage(payload, opts = {}) {
+    const o = polyglotOf(payload);
+    const rows = [];
+    for (const collection of Object.keys(o.collections).filter((c) => !opts.collections || opts.collections.includes(c))) {
+        const row = { collection, documents: 0, locales: Object.fromEntries(o.locales.map((l) => [l, { translated: 0, pending: 0, reviewed: 0, stale: 0 }])) };
+        const { docs } = await payload.find({ collection: collection, locale: o.defaultLocale, depth: 0, pagination: false, overrideAccess: true, draft: false });
+        for (const d of docs) {
+            if (!included(o, collection, d))
+                continue;
+            const src = await loadSource(payload, o, collection, String(d.id));
+            if (!src)
+                continue;
+            row.documents++;
+            for (const locale of o.locales) {
+                const r = src.state.get(locale);
+                const c = row.locales[locale];
+                if (src.reviewed.has(locale))
+                    r && r.hash !== src.hash ? c.stale++ : c.reviewed++;
+                else if (r?.hash === src.hash)
+                    c.translated++;
+                else
+                    c.pending++;
+            }
+        }
+        rows.push(row);
+    }
+    return rows;
+}

package/dist/types.d.ts

@@ -0,0 +1,84 @@
+import type { Payload, PayloadRequest, RequestContext } from 'payload';
+/** One piece of text to translate, with a caller-chosen key. */
+export type Item = {
+    key: string;
+    text: string;
+};
+/**
+ * A translation engine. `translate` returns translations by key (missing keys
+ * stay untranslated). `batch` (optional) translates many requests at once,
+ * usually at a lower price and more slowly; the sweep prefers it.
+ */
+export type TranslateArgs = {
+    locale: string;
+    items: Item[];
+    context?: string;
+    sourceLocale: string;
+    keep: string[];
+};
+export type Translator = {
+    translate: (args: TranslateArgs) => Promise<Map<string, string>>;
+    batch?: (requests: TranslateArgs[]) => Promise<Map<string, string>[]>;
+};
+/** Thrown by a translator when its quota (e.g. a free tier) is used up: the run stops and resumes next time. */
+export declare class QuotaExceededError extends Error {
+    constructor(message?: string);
+}
+export type PolyglotOptions = {
+    /** Fields to keep in every language, per collection. Dotted paths reach into arrays/groups: `sections.heading`. */
+    collections: Record<string, string[]>;
+    translator: Translator;
+    /** May this request/run call the translator? Default: always. Use it for keys, budgets or environments. */
+    enabled?: (args: {
+        payload: Payload;
+        req?: PayloadRequest;
+    }) => boolean | Promise<boolean>;
+    /** Which documents to translate. Default: published ones (or all, without drafts). */
+    include?: (args: {
+        collection: string;
+        doc: Record<string, unknown>;
+    }) => boolean;
+    /** Terms never translated: product names, brands, scientific names… */
+    keep?: string[];
+    /** Engine per language (e.g. DeepL for European languages, another for the rest). Default: `translator`. */
+    translatorFor?: (locale: string) => Translator | undefined;
+    /** Stop a sweep after sending this many characters (stay inside a free tier). Default: no cap. */
+    maxCharactersPerRun?: number;
+    /** Text never sent (placeholders). Default: lorem ipsum and friends. */
+    skip?: RegExp;
+    /** Keys whose string values are never text (urls, ids, option values…). Added to the defaults. */
+    skipKeys?: string[];
+    /** Fields that must never change when another language is saved (computed from the default language). */
+    identityFields?: string[];
+    /** Slug of the translation memory collection. Default `polyglot-memory`. */
+    memorySlug?: string;
+    /** Slug of the per-language fingerprint collection. Default `polyglot-state`. */
+    stateSlug?: string;
+    /** Name of the per-document status group (reviewed languages + fingerprints). Default `translations`. */
+    statusField?: string;
+    /** Context for writes of translated languages, e.g. `{ disableRevalidate: true }` outside a web request. */
+    writeContext?: (args: {
+        inRequest: boolean;
+    }) => RequestContext;
+    /** Short description for the translator ("Content of a page on a reptile-care website"). */
+    describe?: (collection: string) => string;
+    /** Who may see coverage and start translations in the admin. Default: any signed-in user. */
+    canManage?: (args: {
+        req: PayloadRequest;
+    }) => boolean | Promise<boolean>;
+    /** Add the Polyglot admin view (coverage per collection and language, Translate now). Default true. */
+    adminView?: boolean;
+    /** Translate after a document is published (in Next.js, after the response). Default true. */
+    onPublish?: boolean;
+};
+export type ResolvedPolyglot = Required<Omit<PolyglotOptions, 'enabled' | 'include' | 'writeContext' | 'describe' | 'translatorFor' | 'maxCharactersPerRun' | 'canManage'>> & Pick<PolyglotOptions, 'enabled' | 'include' | 'writeContext' | 'describe' | 'translatorFor' | 'maxCharactersPerRun' | 'canManage'> & {
+    defaultLocale: string;
+    locales: string[];
+};
+export type DocumentResult = {
+    translated: string[];
+    upToDate: string[];
+    reviewedStale: string[];
+    failed: string[];
+    pending: string[];
+};

package/dist/types.js

@@ -0,0 +1,7 @@
+/** Thrown by a translator when its quota (e.g. a free tier) is used up: the run stops and resumes next time. */
+export class QuotaExceededError extends Error {
+    constructor(message = 'Translation quota used up') {
+        super(message);
+        this.name = 'QuotaExceededError';
+    }
+}