@focus-reactive/payload-plugin-translator 0.10.3 → 0.10.4

package/dist/core/domain/locales/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Namespace re-export: callers `import { Locales }` and use `Locales.dedupe(...)`,
+ * `Locales.resolveTargets(...)`, etc. Grouped this way (rather than loose named exports) so the domain
+ * reads at the call site; `export * as` keeps each member individually tree-shakeable.
+ */
+export * as Locales from "./resolveLocales";

package/dist/core/domain/locales/index.js

@@ -0,0 +1,7 @@
+/**
+ * Namespace re-export: callers `import { Locales }` and use `Locales.dedupe(...)`,
+ * `Locales.resolveTargets(...)`, etc. Grouped this way (rather than loose named exports) so the domain
+ * reads at the call site; `export * as` keeps each member individually tree-shakeable.
+ */ export * as Locales from "./resolveLocales";
+
+//# sourceMappingURL=index.js.map

package/dist/core/domain/locales/resolveLocales.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The single, canonical home for the locale-set invariants shared by every enqueue path: dedup,
+ * unknown-locale dropping, and source-locale exclusion. Previously each was hand-written in 2–3 places
+ * (the manual `/enqueue` resolver, the auto-translate config-time filter, and the auto-translate runtime
+ * task builder), which risked silent drift if one copy changed. These are the primitives; each path
+ * composes the ones it needs at whatever phase it runs (manual: one shot at request time; auto: dedup +
+ * unknown-drop at config time, source-exclusion per-document at runtime).
+ *
+ * Consumed as a namespace — the barrel re-exports this module as `Locales`, so call sites read
+ * `Locales.dedupe(...)` / `Locales.resolveTargets(...)`. Members are named for that dotted form (no
+ * `Locales` suffix), since the namespace carries the domain.
+ *
+ * Payload-free (plain `string[]` / `Set<string>`), so it stays a pure kernel usable from both the
+ * server features and the auto-translate module without pulling framework types in. Not part of the
+ * plugin's public API — an implementation detail of the enqueue paths.
+ *
+ * @internal
+ */
+/** Whether a single locale code is one of the configured locales. The atomic "is this known?" check
+ * that {@link dropUnknown} is built on — shared so "unknown locale" means one thing everywhere. */
+export declare function isKnown(locale: string, known: Set<string>): boolean;
+/** Remove duplicate locale codes, preserving first-seen order. */
+export declare function dedupe(locales: string[]): string[];
+/** Split a locale list into those that are configured (`kept`) and those that are not (`dropped`),
+ * preserving order within each. */
+export declare function dropUnknown(locales: string[], known: Set<string>): {
+    kept: string[];
+    dropped: string[];
+};
+/** Remove the source locale from a target list; report whether it was present (so the caller can note
+ * it was excluded). */
+export declare function excludeSource(targets: string[], source: string): {
+    kept: string[];
+    wasPresent: boolean;
+};
+/**
+ * Resolved target locales for a manual enqueue, plus what was dropped so the handler can log precisely.
+ */
+export type ResolvedTargets = {
+    /** The concrete locales to fan out to — de-duplicated, source excluded, unknown removed. */
+    targets: string[];
+    /** Requested locales that are not configured (dropped). */
+    droppedUnknown: string[];
+    /** Whether the source locale was requested as a target and excluded. */
+    droppedSource: boolean;
+};
+/**
+ * One-shot resolution for the manual enqueue path: coerce scalar→array, then dedup → exclude source →
+ * drop unknown, in that order. A pure composition of the primitives above.
+ *
+ * @param knownLocales - the configured locale codes. Never null: the caller must reject a
+ *   localization-less config before reaching here (translating without localization has no valid target
+ *   and would corrupt data), so "no localization" is not representable as an input.
+ */
+export declare function resolveTargets(args: {
+    target_lng: string | string[];
+    source_lng: string;
+    knownLocales: Set<string>;
+}): ResolvedTargets;

package/dist/core/domain/locales/resolveLocales.js

@@ -0,0 +1,68 @@
+/**
+ * The single, canonical home for the locale-set invariants shared by every enqueue path: dedup,
+ * unknown-locale dropping, and source-locale exclusion. Previously each was hand-written in 2–3 places
+ * (the manual `/enqueue` resolver, the auto-translate config-time filter, and the auto-translate runtime
+ * task builder), which risked silent drift if one copy changed. These are the primitives; each path
+ * composes the ones it needs at whatever phase it runs (manual: one shot at request time; auto: dedup +
+ * unknown-drop at config time, source-exclusion per-document at runtime).
+ *
+ * Consumed as a namespace — the barrel re-exports this module as `Locales`, so call sites read
+ * `Locales.dedupe(...)` / `Locales.resolveTargets(...)`. Members are named for that dotted form (no
+ * `Locales` suffix), since the namespace carries the domain.
+ *
+ * Payload-free (plain `string[]` / `Set<string>`), so it stays a pure kernel usable from both the
+ * server features and the auto-translate module without pulling framework types in. Not part of the
+ * plugin's public API — an implementation detail of the enqueue paths.
+ *
+ * @internal
+ */ /** Whether a single locale code is one of the configured locales. The atomic "is this known?" check
+ * that {@link dropUnknown} is built on — shared so "unknown locale" means one thing everywhere. */ export function isKnown(locale, known) {
+    return known.has(locale);
+}
+/** Remove duplicate locale codes, preserving first-seen order. */ export function dedupe(locales) {
+    return [
+        ...new Set(locales)
+    ];
+}
+/** Split a locale list into those that are configured (`kept`) and those that are not (`dropped`),
+ * preserving order within each. */ export function dropUnknown(locales, known) {
+    const kept = [];
+    const dropped = [];
+    for (const locale of locales){
+        (isKnown(locale, known) ? kept : dropped).push(locale);
+    }
+    return {
+        kept,
+        dropped
+    };
+}
+/** Remove the source locale from a target list; report whether it was present (so the caller can note
+ * it was excluded). */ export function excludeSource(targets, source) {
+    const kept = targets.filter((target)=>target !== source);
+    return {
+        kept,
+        wasPresent: kept.length !== targets.length
+    };
+}
+/**
+ * One-shot resolution for the manual enqueue path: coerce scalar→array, then dedup → exclude source →
+ * drop unknown, in that order. A pure composition of the primitives above.
+ *
+ * @param knownLocales - the configured locale codes. Never null: the caller must reject a
+ *   localization-less config before reaching here (translating without localization has no valid target
+ *   and would corrupt data), so "no localization" is not representable as an input.
+ */ export function resolveTargets(args) {
+    const { target_lng, source_lng, knownLocales } = args;
+    const requested = Array.isArray(target_lng) ? target_lng : [
+        target_lng
+    ];
+    const { kept: withoutSource, wasPresent: droppedSource } = excludeSource(dedupe(requested), source_lng);
+    const { kept: targets, dropped: droppedUnknown } = dropUnknown(withoutSource, knownLocales);
+    return {
+        targets,
+        droppedUnknown,
+        droppedSource
+    };
+}
+
+//# sourceMappingURL=resolveLocales.js.map

package/dist/server/features/enqueue-translation/handler.js

@@ -1,8 +1,8 @@
 import { ServerResponse } from "../../shared";
 import { extractLocaleCodes } from "../../modules/auto-translate";
 import { isCollectionAvailable, getAllCollectionIds } from "../_lib/collection-utils";
+import { Locales } from "../../../core/domain/locales";
 import { EnqueueInputSchema } from "./model";
-import { resolveTargetLocales } from "./resolveTargetLocales";
 /**
  * Enqueues translation tasks for documents
  */ export class EnqueueTranslationHandler {
@@ -26,7 +26,7 @@ import { resolveTargetLocales } from "./resolveTargetLocales";
         if (!knownLocales) return ServerResponse.badRequest("Localization is not enabled in this Payload config; there are no target locales to translate into");
         // Normalize the scalar-or-array target into the concrete locales to fan out to: de-dup, exclude the
         // source, and drop locales that are not configured.
-        const { targets, droppedUnknown } = resolveTargetLocales({
+        const { targets, droppedUnknown } = Locales.resolveTargets({
             target_lng,
             source_lng,
             knownLocales

package/dist/server/modules/auto-translate/AutoTranslate.policy.js

@@ -1,10 +1,9 @@
+import { Locales } from "../../../core/domain/locales";
 /** Apply defaults to a raw config: strategy → "overwrite", debounce → 0. Duplicate target locales are
  * de-duplicated so a misconfigured `targets: ["de","de"]` never enqueues two racing jobs for the same
  * (document, locale) in one batch (the runner's supersession only dedupes against already-stored jobs). */ export function normalizeAutoTranslateConfig(config) {
     return {
-        targets: [
-            ...new Set(config.targets)
-        ],
+        targets: Locales.dedupe(config.targets),
         strategy: config.strategy ?? "overwrite",
         debounceMs: config.debounceMs ?? 0,
         sourceLocale: config.sourceLocale
@@ -20,15 +19,15 @@
  * either error at the DB (Postgres locale enum) or write orphaned, invisible data (Mongo/SQLite). Pure:
  * returns a new policy and reports the drops; the caller (config-time wiring) emits the warning.
  */ export function filterPolicyToKnownLocales(policy, knownLocales) {
-    const droppedTargets = policy.targets.filter((target)=>!knownLocales.has(target));
-    const sourceUnknown = policy.sourceLocale !== undefined && !knownLocales.has(policy.sourceLocale);
+    const { kept, dropped } = Locales.dropUnknown(policy.targets, knownLocales);
+    const sourceUnknown = policy.sourceLocale !== undefined && !Locales.isKnown(policy.sourceLocale, knownLocales);
     return {
         policy: {
             ...policy,
-            targets: policy.targets.filter((target)=>knownLocales.has(target)),
+            targets: kept,
             sourceLocale: sourceUnknown ? undefined : policy.sourceLocale
         },
-        droppedTargets,
+        droppedTargets: dropped,
         droppedSourceLocale: sourceUnknown ? policy.sourceLocale ?? null : null
     };
 }
@@ -63,7 +62,7 @@
     const { policy, collectionSlug, documentId, sourceLocale, doc, hasDrafts, now } = args;
     const publishOnTranslation = resolvePublishOnTranslation(doc, hasDrafts);
     const waitUntil = policy.debounceMs > 0 ? new Date(now + policy.debounceMs) : undefined;
-    return policy.targets.filter((target)=>target !== sourceLocale).map((target)=>({
+    return Locales.excludeSource(policy.targets, sourceLocale).kept.map((target)=>({
             collectionSlug,
             collectionId: documentId,
             sourceLng: sourceLocale,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@focus-reactive/payload-plugin-translator",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "description": "Translation plugin for Payload CMS 3.x. Automatically translate your localized content using any translation provider.",
   "type": "module",
   "license": "MIT",

package/dist/server/features/enqueue-translation/resolveTargetLocales.d.ts

@@ -1,30 +0,0 @@
-/**
- * Resolved target locales for a manual enqueue, plus what was dropped so the handler can log precisely.
- */
-export type ResolvedTargetLocales = {
-    /** The concrete locales to fan out to — de-duplicated, source excluded, unknown removed. */
-    targets: string[];
-    /** Requested locales that are not configured (dropped). */
-    droppedUnknown: string[];
-    /** Whether the source locale was requested as a target and excluded. */
-    droppedSource: boolean;
-};
-/**
- * Normalize the enqueue `target_lng` input (scalar or array) into the concrete list of target locales
- * to translate into. Applies, in order: array-coercion, de-duplication (first-seen order preserved),
- * source-locale exclusion, and dropping unknown (unconfigured) locales.
- *
- * De-dup and unknown-dropping are the manual-enqueue counterparts of the auto-translate policy filter:
- * the runner only supersedes against already-stored jobs, so duplicates within one enqueue must be
- * collapsed here; and an unknown locale must never reach the pipeline — it burns a provider call and
- * either errors on a Postgres locale enum or writes orphaned, invisible data on Mongo/SQLite.
- *
- * @param knownLocales - the configured locale codes. Never null: the caller must reject a
- *   localization-less config before reaching here (translating without localization has no valid
- *   target and would corrupt data), so "no localization" is not representable as an input.
- */
-export declare function resolveTargetLocales(args: {
-    target_lng: string | string[];
-    source_lng: string;
-    knownLocales: Set<string>;
-}): ResolvedTargetLocales;

package/dist/server/features/enqueue-translation/resolveTargetLocales.js

@@ -1,35 +0,0 @@
-/**
- * Resolved target locales for a manual enqueue, plus what was dropped so the handler can log precisely.
- */ /**
- * Normalize the enqueue `target_lng` input (scalar or array) into the concrete list of target locales
- * to translate into. Applies, in order: array-coercion, de-duplication (first-seen order preserved),
- * source-locale exclusion, and dropping unknown (unconfigured) locales.
- *
- * De-dup and unknown-dropping are the manual-enqueue counterparts of the auto-translate policy filter:
- * the runner only supersedes against already-stored jobs, so duplicates within one enqueue must be
- * collapsed here; and an unknown locale must never reach the pipeline — it burns a provider call and
- * either errors on a Postgres locale enum or writes orphaned, invisible data on Mongo/SQLite.
- *
- * @param knownLocales - the configured locale codes. Never null: the caller must reject a
- *   localization-less config before reaching here (translating without localization has no valid
- *   target and would corrupt data), so "no localization" is not representable as an input.
- */ export function resolveTargetLocales(args) {
-    const { target_lng, source_lng, knownLocales } = args;
-    const requested = Array.isArray(target_lng) ? target_lng : [
-        target_lng
-    ];
-    const deduped = [
-        ...new Set(requested)
-    ];
-    const droppedSource = deduped.includes(source_lng);
-    const withoutSource = deduped.filter((target)=>target !== source_lng);
-    const droppedUnknown = withoutSource.filter((target)=>!knownLocales.has(target));
-    const targets = withoutSource.filter((target)=>knownLocales.has(target));
-    return {
-        targets,
-        droppedUnknown,
-        droppedSource
-    };
-}
-
-//# sourceMappingURL=resolveTargetLocales.js.map