payload 4.0.0-internal.cd69eef → 4.0.0-internal.d1cc1d3

package/dist/exports/internal.d.ts

@@ -1,7 +1,9 @@
 /**
  * Modules exported here are not part of the public API and are subject to change without notice and without a major version bump.
  */
+export { getUploadInstructions } from '../uploads/endpoints/uploadInstructions.js';
 export { getExternalFile } from '../uploads/getExternalFile.js';
+export { getFileFromUploadInstructions } from '../uploads/getFileFromUploadInstructions.js';
 export { getRangeRequestInfo } from '../uploads/getRangeRequestInfo.js';
 export { getSafeFileName } from '../uploads/getSafeFilename.js';
 export { parseRangeHeader } from '../uploads/parseRangeHeader.js';

package/dist/exports/internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/exports/internal.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2DAA2D,CAAA;AAChG,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA"}
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/exports/internal.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAA;AAClF,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,6BAA6B,EAAE,MAAM,6CAA6C,CAAA;AAC3F,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2DAA2D,CAAA;AAChG,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA"}

package/dist/exports/internal.js

@@ -1,6 +1,8 @@
 /**
  * Modules exported here are not part of the public API and are subject to change without notice and without a major version bump.
- */ export { getExternalFile } from '../uploads/getExternalFile.js';
+ */ export { getUploadInstructions } from '../uploads/endpoints/uploadInstructions.js';
+export { getExternalFile } from '../uploads/getExternalFile.js';
+export { getFileFromUploadInstructions } from '../uploads/getFileFromUploadInstructions.js';
 export { getRangeRequestInfo } from '../uploads/getRangeRequestInfo.js';
 export { getSafeFileName } from '../uploads/getSafeFilename.js';
 export { parseRangeHeader } from '../uploads/parseRangeHeader.js';

package/dist/exports/internal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/exports/internal.ts"],"sourcesContent":["/**\n * Modules exported here are not part of the public API and are subject to change without notice and without a major version bump.\n */\n\nexport { getExternalFile } from '../uploads/getExternalFile.js'\nexport { getRangeRequestInfo } from '../uploads/getRangeRequestInfo.js'\nexport { getSafeFileName } from '../uploads/getSafeFilename.js'\nexport { parseRangeHeader } from '../uploads/parseRangeHeader.js'\nexport { getEntityPermissions } from '../utilities/getEntityPermissions/getEntityPermissions.js'\nexport { isURLAllowed } from '../utilities/isURLAllowed.js'\nexport { sanitizePermissions } from '../utilities/sanitizePermissions.js'\nexport { sendTelemetryEvent } from '../utilities/telemetry/index.js'\n"],"names":["getExternalFile","getRangeRequestInfo","getSafeFileName","parseRangeHeader","getEntityPermissions","isURLAllowed","sanitizePermissions","sendTelemetryEvent"],"mappings":"AAAA;;CAEC,GAED,SAASA,eAAe,QAAQ,gCAA+B;AAC/D,SAASC,mBAAmB,QAAQ,oCAAmC;AACvE,SAASC,eAAe,QAAQ,gCAA+B;AAC/D,SAASC,gBAAgB,QAAQ,iCAAgC;AACjE,SAASC,oBAAoB,QAAQ,4DAA2D;AAChG,SAASC,YAAY,QAAQ,+BAA8B;AAC3D,SAASC,mBAAmB,QAAQ,sCAAqC;AACzE,SAASC,kBAAkB,QAAQ,kCAAiC"}
+{"version":3,"sources":["../../src/exports/internal.ts"],"sourcesContent":["/**\n * Modules exported here are not part of the public API and are subject to change without notice and without a major version bump.\n */\n\nexport { getUploadInstructions } from '../uploads/endpoints/uploadInstructions.js'\nexport { getExternalFile } from '../uploads/getExternalFile.js'\nexport { getFileFromUploadInstructions } from '../uploads/getFileFromUploadInstructions.js'\nexport { getRangeRequestInfo } from '../uploads/getRangeRequestInfo.js'\nexport { getSafeFileName } from '../uploads/getSafeFilename.js'\nexport { parseRangeHeader } from '../uploads/parseRangeHeader.js'\nexport { getEntityPermissions } from '../utilities/getEntityPermissions/getEntityPermissions.js'\nexport { isURLAllowed } from '../utilities/isURLAllowed.js'\nexport { sanitizePermissions } from '../utilities/sanitizePermissions.js'\nexport { sendTelemetryEvent } from '../utilities/telemetry/index.js'\n"],"names":["getUploadInstructions","getExternalFile","getFileFromUploadInstructions","getRangeRequestInfo","getSafeFileName","parseRangeHeader","getEntityPermissions","isURLAllowed","sanitizePermissions","sendTelemetryEvent"],"mappings":"AAAA;;CAEC,GAED,SAASA,qBAAqB,QAAQ,6CAA4C;AAClF,SAASC,eAAe,QAAQ,gCAA+B;AAC/D,SAASC,6BAA6B,QAAQ,8CAA6C;AAC3F,SAASC,mBAAmB,QAAQ,oCAAmC;AACvE,SAASC,eAAe,QAAQ,gCAA+B;AAC/D,SAASC,gBAAgB,QAAQ,iCAAgC;AACjE,SAASC,oBAAoB,QAAQ,4DAA2D;AAChG,SAASC,YAAY,QAAQ,+BAA8B;AAC3D,SAASC,mBAAmB,QAAQ,sCAAqC;AACzE,SAASC,kBAAkB,QAAQ,kCAAiC"}

package/dist/fields/baseFields/slug/duplicateContext.d.ts

@@ -0,0 +1,11 @@
+import type { RequestContext } from '../../../index.js';
+/**
+ * Bridges the two hooks in a duplicate: `beforeDuplicate` marks a slug field, and the copy's
+ * `beforeChange` reads the mark to take a fresh `<singular>-<N>` fallback — skipping both the
+ * explicit-collision check (the copy isn't a user-typed value) and source derivation (which would
+ * drift toward the original's slug).
+ */
+export declare const markSlugForDuplicateFallback: (context: RequestContext, name: string) => void;
+/** Reads and clears the mark so it can't leak into a later operation on the same request. */
+export declare const consumeSlugDuplicateFallback: (context: RequestContext, name: string) => boolean;
+//# sourceMappingURL=duplicateContext.d.ts.map

package/dist/fields/baseFields/slug/duplicateContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicateContext.d.ts","sourceRoot":"","sources":["../../../../src/fields/baseFields/slug/duplicateContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAIvD;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,YAAa,cAAc,QAAQ,MAAM,KAAG,IAIpF,CAAA;AAED,6FAA6F;AAC7F,eAAO,MAAM,4BAA4B,YAAa,cAAc,QAAQ,MAAM,KAAG,OASpF,CAAA"}

package/dist/fields/baseFields/slug/duplicateContext.js

@@ -0,0 +1,21 @@
+const CONTEXT_KEY = '_slugDuplicateFallbackFields';
+/**
+ * Bridges the two hooks in a duplicate: `beforeDuplicate` marks a slug field, and the copy's
+ * `beforeChange` reads the mark to take a fresh `<singular>-<N>` fallback — skipping both the
+ * explicit-collision check (the copy isn't a user-typed value) and source derivation (which would
+ * drift toward the original's slug).
+ */ export const markSlugForDuplicateFallback = (context, name)=>{
+    const fields = context[CONTEXT_KEY] ?? {};
+    fields[name] = true;
+    context[CONTEXT_KEY] = fields;
+};
+/** Reads and clears the mark so it can't leak into a later operation on the same request. */ export const consumeSlugDuplicateFallback = (context, name)=>{
+    const fields = context[CONTEXT_KEY];
+    if (!fields?.[name]) {
+        return false;
+    }
+    delete fields[name];
+    return true;
+};
+
+//# sourceMappingURL=duplicateContext.js.map

package/dist/fields/baseFields/slug/duplicateContext.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/fields/baseFields/slug/duplicateContext.ts"],"sourcesContent":["import type { RequestContext } from '../../../index.js'\n\nconst CONTEXT_KEY = '_slugDuplicateFallbackFields'\n\n/**\n * Bridges the two hooks in a duplicate: `beforeDuplicate` marks a slug field, and the copy's\n * `beforeChange` reads the mark to take a fresh `<singular>-<N>` fallback — skipping both the\n * explicit-collision check (the copy isn't a user-typed value) and source derivation (which would\n * drift toward the original's slug).\n */\nexport const markSlugForDuplicateFallback = (context: RequestContext, name: string): void => {\n  const fields = (context[CONTEXT_KEY] as Record<string, boolean> | undefined) ?? {}\n  fields[name] = true\n  context[CONTEXT_KEY] = fields\n}\n\n/** Reads and clears the mark so it can't leak into a later operation on the same request. */\nexport const consumeSlugDuplicateFallback = (context: RequestContext, name: string): boolean => {\n  const fields = context[CONTEXT_KEY] as Record<string, boolean> | undefined\n\n  if (!fields?.[name]) {\n    return false\n  }\n\n  delete fields[name]\n  return true\n}\n"],"names":["CONTEXT_KEY","markSlugForDuplicateFallback","context","name","fields","consumeSlugDuplicateFallback"],"mappings":"AAEA,MAAMA,cAAc;AAEpB;;;;;CAKC,GACD,OAAO,MAAMC,+BAA+B,CAACC,SAAyBC;IACpE,MAAMC,SAAS,AAACF,OAAO,CAACF,YAAY,IAA4C,CAAC;IACjFI,MAAM,CAACD,KAAK,GAAG;IACfD,OAAO,CAACF,YAAY,GAAGI;AACzB,EAAC;AAED,2FAA2F,GAC3F,OAAO,MAAMC,+BAA+B,CAACH,SAAyBC;IACpE,MAAMC,SAASF,OAAO,CAACF,YAAY;IAEnC,IAAI,CAACI,QAAQ,CAACD,KAAK,EAAE;QACnB,OAAO;IACT;IAEA,OAAOC,MAAM,CAACD,KAAK;IACnB,OAAO;AACT,EAAC"}

package/dist/fields/baseFields/slug/fillEmptyLocalizedSlugs.d.ts

@@ -0,0 +1,22 @@
+import type { SanitizedCollectionConfig } from '../../../collections/config/types.js';
+import type { JsonObject, PayloadRequest } from '../../../types/index.js';
+type Args = {
+    collection: SanitizedCollectionConfig;
+    /** The post-`beforeChange` data, with localized fields already keyed by locale. */
+    data: JsonObject;
+    req: PayloadRequest;
+};
+/**
+ * On create, seed every locale of a localized slug field so switching locales never lands on an
+ * empty slug. Each empty locale derives from its own source value — a non-localized source applies
+ * to every locale, so they follow it just like the active locale did — and falls back to a per-locale
+ * `<singular>-<N>` only when that locale has no source. Both are deduped within the locale, so one
+ * document never claims another's per-locale value.
+ *
+ * Runs after field `beforeChange` (similar to the localized `_status` treatment). The slug field hook
+ * only sees the active locale, so the other locales are filled here at the operation level. A slug
+ * is static once set, so this is create-only; per-locale edits afterward stay scoped to their locale.
+ */
+export declare const fillEmptyLocalizedSlugs: ({ collection, data, req, }: Args) => Promise<JsonObject>;
+export {};
+//# sourceMappingURL=fillEmptyLocalizedSlugs.d.ts.map

package/dist/fields/baseFields/slug/fillEmptyLocalizedSlugs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fillEmptyLocalizedSlugs.d.ts","sourceRoot":"","sources":["../../../../src/fields/baseFields/slug/fillEmptyLocalizedSlugs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAA;AACrF,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AASzE,KAAK,IAAI,GAAG;IACV,UAAU,EAAE,yBAAyB,CAAA;IACrC,mFAAmF;IACnF,IAAI,EAAE,UAAU,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,+BAIjC,IAAI,KAAG,OAAO,CAAC,UAAU,CAyD3B,CAAA"}

package/dist/fields/baseFields/slug/fillEmptyLocalizedSlugs.js

@@ -0,0 +1,63 @@
+import { getUniqueFieldValue } from '../../../utilities/getUniqueFieldValue.js';
+import { hasDraftsEnabled } from '../../../utilities/getVersionsConfig.js';
+import { slugify as defaultSlugify } from '../../../utilities/slugify.js';
+import { getSlugFallbackValue } from './getSlugFallbackValue.js';
+import { hasValue } from './hasValue.js';
+/**
+ * On create, seed every locale of a localized slug field so switching locales never lands on an
+ * empty slug. Each empty locale derives from its own source value — a non-localized source applies
+ * to every locale, so they follow it just like the active locale did — and falls back to a per-locale
+ * `<singular>-<N>` only when that locale has no source. Both are deduped within the locale, so one
+ * document never claims another's per-locale value.
+ *
+ * Runs after field `beforeChange` (similar to the localized `_status` treatment). The slug field hook
+ * only sees the active locale, so the other locales are filled here at the operation level. A slug
+ * is static once set, so this is create-only; per-locale edits afterward stay scoped to their locale.
+ */ export const fillEmptyLocalizedSlugs = async ({ collection, data, req })=>{
+    const { localization } = req.payload.config;
+    if (!localization || localization.localeCodes.length < 2) {
+        return data;
+    }
+    const draftsEnabled = hasDraftsEnabled(collection);
+    for (const field of collection.flattenedFields){
+        if (field.type !== 'slug' || !field.localized) {
+            continue;
+        }
+        const customSlugify = field.custom?.slugify;
+        const slugify = (valueToSlugify)=>customSlugify ? customSlugify({
+                data,
+                req,
+                valueToSlugify
+            }) : defaultSlugify(valueToSlugify);
+        // The source value for a given locale: a non-localized source is shared across all locales, a
+        // localized one is read per-locale (only the locales present in this create have a value).
+        const sourceField = field.useAsSlug ? collection.flattenedFields.find((f)=>f.name === field.useAsSlug) : undefined;
+        const source = field.useAsSlug ? data[field.useAsSlug] : undefined;
+        const localeValues = data[field.name] ?? {};
+        for (const locale of localization.localeCodes){
+            if (hasValue(localeValues[locale])) {
+                continue;
+            }
+            const sourceForLocale = sourceField?.localized ? source?.[locale] : source;
+            const derived = sourceForLocale ? await slugify(sourceForLocale) : undefined;
+            localeValues[locale] = hasValue(derived) ? await getUniqueFieldValue({
+                collection: collection.slug,
+                draftsEnabled,
+                field: field.name,
+                locale,
+                req,
+                value: derived
+            }) : await getSlugFallbackValue({
+                collection,
+                field: field.name,
+                locale,
+                req,
+                slugify
+            });
+        }
+        data[field.name] = localeValues;
+    }
+    return data;
+};
+
+//# sourceMappingURL=fillEmptyLocalizedSlugs.js.map

package/dist/fields/baseFields/slug/fillEmptyLocalizedSlugs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/fields/baseFields/slug/fillEmptyLocalizedSlugs.ts"],"sourcesContent":["import type { SanitizedCollectionConfig } from '../../../collections/config/types.js'\nimport type { JsonObject, PayloadRequest } from '../../../types/index.js'\nimport type { Slugify } from './types.js'\n\nimport { getUniqueFieldValue } from '../../../utilities/getUniqueFieldValue.js'\nimport { hasDraftsEnabled } from '../../../utilities/getVersionsConfig.js'\nimport { slugify as defaultSlugify } from '../../../utilities/slugify.js'\nimport { getSlugFallbackValue } from './getSlugFallbackValue.js'\nimport { hasValue } from './hasValue.js'\n\ntype Args = {\n  collection: SanitizedCollectionConfig\n  /** The post-`beforeChange` data, with localized fields already keyed by locale. */\n  data: JsonObject\n  req: PayloadRequest\n}\n\n/**\n * On create, seed every locale of a localized slug field so switching locales never lands on an\n * empty slug. Each empty locale derives from its own source value — a non-localized source applies\n * to every locale, so they follow it just like the active locale did — and falls back to a per-locale\n * `<singular>-<N>` only when that locale has no source. Both are deduped within the locale, so one\n * document never claims another's per-locale value.\n *\n * Runs after field `beforeChange` (similar to the localized `_status` treatment). The slug field hook\n * only sees the active locale, so the other locales are filled here at the operation level. A slug\n * is static once set, so this is create-only; per-locale edits afterward stay scoped to their locale.\n */\nexport const fillEmptyLocalizedSlugs = async ({\n  collection,\n  data,\n  req,\n}: Args): Promise<JsonObject> => {\n  const { localization } = req.payload.config\n\n  if (!localization || localization.localeCodes.length < 2) {\n    return data\n  }\n\n  const draftsEnabled = hasDraftsEnabled(collection)\n\n  for (const field of collection.flattenedFields) {\n    if (field.type !== 'slug' || !field.localized) {\n      continue\n    }\n\n    const customSlugify = field.custom?.slugify as Slugify | undefined\n\n    const slugify = (valueToSlugify: unknown) =>\n      customSlugify\n        ? customSlugify({ data, req, valueToSlugify })\n        : defaultSlugify(valueToSlugify as string)\n\n    // The source value for a given locale: a non-localized source is shared across all locales, a\n    // localized one is read per-locale (only the locales present in this create have a value).\n    const sourceField = field.useAsSlug\n      ? collection.flattenedFields.find((f) => f.name === field.useAsSlug)\n      : undefined\n    const source = field.useAsSlug ? data[field.useAsSlug] : undefined\n\n    const localeValues = (data[field.name] ?? {}) as Record<string, unknown>\n\n    for (const locale of localization.localeCodes) {\n      if (hasValue(localeValues[locale])) {\n        continue\n      }\n\n      const sourceForLocale = sourceField?.localized\n        ? (source as Record<string, unknown> | undefined)?.[locale]\n        : source\n\n      const derived = sourceForLocale ? await slugify(sourceForLocale) : undefined\n\n      localeValues[locale] = hasValue(derived)\n        ? await getUniqueFieldValue({\n            collection: collection.slug,\n            draftsEnabled,\n            field: field.name,\n            locale,\n            req,\n            value: derived as string,\n          })\n        : await getSlugFallbackValue({ collection, field: field.name, locale, req, slugify })\n    }\n\n    data[field.name] = localeValues\n  }\n\n  return data\n}\n"],"names":["getUniqueFieldValue","hasDraftsEnabled","slugify","defaultSlugify","getSlugFallbackValue","hasValue","fillEmptyLocalizedSlugs","collection","data","req","localization","payload","config","localeCodes","length","draftsEnabled","field","flattenedFields","type","localized","customSlugify","custom","valueToSlugify","sourceField","useAsSlug","find","f","name","undefined","source","localeValues","locale","sourceForLocale","derived","slug","value"],"mappings":"AAIA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,gBAAgB,QAAQ,0CAAyC;AAC1E,SAASC,WAAWC,cAAc,QAAQ,gCAA+B;AACzE,SAASC,oBAAoB,QAAQ,4BAA2B;AAChE,SAASC,QAAQ,QAAQ,gBAAe;AASxC;;;;;;;;;;CAUC,GACD,OAAO,MAAMC,0BAA0B,OAAO,EAC5CC,UAAU,EACVC,IAAI,EACJC,GAAG,EACE;IACL,MAAM,EAAEC,YAAY,EAAE,GAAGD,IAAIE,OAAO,CAACC,MAAM;IAE3C,IAAI,CAACF,gBAAgBA,aAAaG,WAAW,CAACC,MAAM,GAAG,GAAG;QACxD,OAAON;IACT;IAEA,MAAMO,gBAAgBd,iBAAiBM;IAEvC,KAAK,MAAMS,SAAST,WAAWU,eAAe,CAAE;QAC9C,IAAID,MAAME,IAAI,KAAK,UAAU,CAACF,MAAMG,SAAS,EAAE;YAC7C;QACF;QAEA,MAAMC,gBAAgBJ,MAAMK,MAAM,EAAEnB;QAEpC,MAAMA,UAAU,CAACoB,iBACfF,gBACIA,cAAc;gBAAEZ;gBAAMC;gBAAKa;YAAe,KAC1CnB,eAAemB;QAErB,8FAA8F;QAC9F,2FAA2F;QAC3F,MAAMC,cAAcP,MAAMQ,SAAS,GAC/BjB,WAAWU,eAAe,CAACQ,IAAI,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAKX,MAAMQ,SAAS,IACjEI;QACJ,MAAMC,SAASb,MAAMQ,SAAS,GAAGhB,IAAI,CAACQ,MAAMQ,SAAS,CAAC,GAAGI;QAEzD,MAAME,eAAgBtB,IAAI,CAACQ,MAAMW,IAAI,CAAC,IAAI,CAAC;QAE3C,KAAK,MAAMI,UAAUrB,aAAaG,WAAW,CAAE;YAC7C,IAAIR,SAASyB,YAAY,CAACC,OAAO,GAAG;gBAClC;YACF;YAEA,MAAMC,kBAAkBT,aAAaJ,YAChCU,QAAgD,CAACE,OAAO,GACzDF;YAEJ,MAAMI,UAAUD,kBAAkB,MAAM9B,QAAQ8B,mBAAmBJ;YAEnEE,YAAY,CAACC,OAAO,GAAG1B,SAAS4B,WAC5B,MAAMjC,oBAAoB;gBACxBO,YAAYA,WAAW2B,IAAI;gBAC3BnB;gBACAC,OAAOA,MAAMW,IAAI;gBACjBI;gBACAtB;gBACA0B,OAAOF;YACT,KACA,MAAM7B,qBAAqB;gBAAEG;gBAAYS,OAAOA,MAAMW,IAAI;gBAAEI;gBAAQtB;gBAAKP;YAAQ;QACvF;QAEAM,IAAI,CAACQ,MAAMW,IAAI,CAAC,GAAGG;IACrB;IAEA,OAAOtB;AACT,EAAC"}

package/dist/fields/baseFields/slug/generateSlug.d.ts

@@ -1,19 +1,24 @@
 import type { FieldHook } from '../../config/types.js';
 import type { Slugify } from './types.js';
 type Args = {
+    localized?: boolean;
     name: string;
     slugify?: Slugify;
-    useAsSlug: string;
+    useAsSlug?: string;
 };
 /**
- * Field `beforeChange` hook for the native `slug` field. Returns the slug value.
+ * `beforeChange` hook for the native `slug` field.
  *
- * Auto-tracking is derived statelessly: the slug follows its source while it is
- * empty or still equals `slugify(storedSource)`. Once it diverges (the admin
- * overwrites it), it freezes — and stays frozen, because the stored value keeps
- * differing from `slugify(source)`. Re-aligning (the UI generate button) resumes
- * tracking.
+ * Fills the slug only while empty and never rewrites one that's set, so a lagging autosave can't
+ * clobber it with a stale value:
+ *   - empty with no source falls back to `<singular>-<N>`, e.g. `posts-1` (see {@link getSlugFallbackValue})
+ *   - explicit input and the source field are slugified, e.g. "Hello World" → "hello-world"
+ *   - an already-set slug is preserved as-is
+ *
+ * Generated values dedupe against existing slugs; a localized slug is unique per-locale, so its
+ * dedupe and fallback are scoped to the locale being written. Globals have no collection to dedupe
+ * against, so their slug is left as-is.
  */
-export declare const generateSlug: ({ name, slugify: customSlugify, useAsSlug }: Args) => FieldHook;
+export declare const generateSlug: ({ name, localized, slugify: customSlugify, useAsSlug }: Args) => FieldHook;
 export {};
 //# sourceMappingURL=generateSlug.d.ts.map

package/dist/fields/baseFields/slug/generateSlug.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateSlug.d.ts","sourceRoot":"","sources":["../../../../src/fields/baseFields/slug/generateSlug.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAMzC,KAAK,IAAI,GAAG;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,gDACuB,IAAI,KAAG,SA+DpD,CAAA"}
+{"version":3,"file":"generateSlug.d.ts","sourceRoot":"","sources":["../../../../src/fields/baseFields/slug/generateSlug.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAWzC,KAAK,IAAI,GAAG;IACV,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,2DACkC,IAAI,KAAG,SAgG/D,CAAA"}

package/dist/fields/baseFields/slug/generateSlug.js

@@ -1,64 +1,117 @@
-import { hasAutosaveEnabled } from '../../../utilities/getVersionsConfig.js';
+import { ValidationError } from '../../../errors/index.js';
+import { fieldValueExists } from '../../../utilities/fieldValueExists.js';
+import { getUniqueFieldValue } from '../../../utilities/getUniqueFieldValue.js';
+import { hasDraftsEnabled } from '../../../utilities/getVersionsConfig.js';
 import { slugify as defaultSlugify } from '../../../utilities/slugify.js';
-import { countVersions } from './countVersions.js';
+import { consumeSlugDuplicateFallback } from './duplicateContext.js';
+import { getSlugFallbackValue } from './getSlugFallbackValue.js';
+import { hasValue } from './hasValue.js';
 /**
- * Field `beforeChange` hook for the native `slug` field. Returns the slug value.
+ * `beforeChange` hook for the native `slug` field.
  *
- * Auto-tracking is derived statelessly: the slug follows its source while it is
- * empty or still equals `slugify(storedSource)`. Once it diverges (the admin
- * overwrites it), it freezes — and stays frozen, because the stored value keeps
- * differing from `slugify(source)`. Re-aligning (the UI generate button) resumes
- * tracking.
- */ export const generateSlug = ({ name, slugify: customSlugify, useAsSlug })=>async ({ collection, data, global, operation, originalDoc, req, value })=>{
-        const source = data?.[useAsSlug];
+ * Fills the slug only while empty and never rewrites one that's set, so a lagging autosave can't
+ * clobber it with a stale value:
+ *   - empty with no source falls back to `<singular>-<N>`, e.g. `posts-1` (see {@link getSlugFallbackValue})
+ *   - explicit input and the source field are slugified, e.g. "Hello World" → "hello-world"
+ *   - an already-set slug is preserved as-is
+ *
+ * Generated values dedupe against existing slugs; a localized slug is unique per-locale, so its
+ * dedupe and fallback are scoped to the locale being written. Globals have no collection to dedupe
+ * against, so their slug is left as-is.
+ */ export const generateSlug = ({ name, localized, slugify: customSlugify, useAsSlug })=>async ({ collection, context, data, operation, originalDoc, req, value })=>{
         const slugify = (valueToSlugify)=>customSlugify ? customSlugify({
                 data: data ?? {},
                 req,
                 valueToSlugify
             }) : defaultSlugify(valueToSlugify);
-        const entity = collection || global;
-        if (operation === 'create') {
-            // Autosave drafts: do not auto-generate on the initial draft — the user is still entering content.
-            // Keep the explicit non-slugified value (if any); generation begins on a later autosave.
-            if (hasAutosaveEnabled(entity) && data?._status === 'draft') {
-                return value || null;
-            }
-            // Keep an explicitly provided slug; otherwise generate from the source.
-            return await slugify(value || source);
+        // A localized slug is unique only within its locale, so every uniqueness query below is scoped
+        // to the locale being written.
+        const locale = localized ? req.locale ?? undefined : undefined;
+        // A duplicated document:
+        //  - Takes a fresh `<singular>-<N>` fallback — not the original's slug, not a source-derived one
+        //  - Skips the explicit-collision check below (see generateSlugBeforeDuplicate).
+        if (collection && consumeSlugDuplicateFallback(context, name)) {
+            return await getSlugFallbackValue({
+                collection,
+                field: name,
+                locale,
+                req,
+                slugify
+            });
         }
         const storedSlug = originalDoc?.[name];
-        const originalSource = originalDoc?.[useAsSlug];
-        // User explicitly edited the slug (or cleared the value): respect it.
-        if (value !== undefined && value !== storedSlug) {
-            return value;
+        const storedSlugHasValue = hasValue(storedSlug);
+        // Explicit value from the client wins — normalized through the field's slugify.
+        // It must be unique: reject a collision rather than silently changing it,
+        // only generated values are automatically deduped.
+        // A value that slugifies to nothing (e.g. "!!!") isn't a usable slug,
+        // so fall through to the source/fallback rather than store an empty one.
+        if (hasValue(value)) {
+            const slugified = await slugify(value);
+            if (hasValue(slugified)) {
+                // Unchanged from what's stored — already unique, so skip the collision query. Autosave
+                // resends the current slug on every tick; without this each tick runs a needless read.
+                if (slugified === storedSlug) {
+                    return storedSlug;
+                }
+                if (collection && await fieldValueExists({
+                    id: originalDoc?.id,
+                    collection: collection.slug,
+                    draftsEnabled: hasDraftsEnabled(collection),
+                    field: name,
+                    locale,
+                    req,
+                    value: slugified
+                })) {
+                    throw new ValidationError({
+                        errors: [
+                            {
+                                message: req.t('error:valueMustBeUnique'),
+                                path: name
+                            }
+                        ]
+                    }, req.t);
+                }
+                return slugified;
+            }
         }
-        // No explicit edit this save. If the stored slug doesn't match what its source
-        // would generate, it was customized on an earlier save — keep it frozen.
-        const storedSlugIsCustom = storedSlug && storedSlug !== await slugify(originalSource);
-        if (storedSlugIsCustom) {
+        // On update, preserve a slug that is already set — only fill it while empty.
+        if (operation !== 'create' && storedSlugHasValue) {
             return storedSlug;
         }
-        if (!hasAutosaveEnabled(entity)) {
-            // Non-autosave: generate once while empty, then freeze.
-            return storedSlug || await slugify(source);
-        }
-        // Autosave / drafts
-        const priorVersions = await countVersions({
-            collectionSlug: collection?.slug,
-            globalSlug: global?.slug,
-            parentID: originalDoc?.id,
-            req
-        });
-        // Do not generate on the very first draft (no prior version yet).
-        if (priorVersions === 0) {
-            return storedSlug ?? null;
+        // Derive an empty slug from its source, when present.
+        // Dedupe so two documents don't both claim it if they have the same source value.
+        // Globals have no collection to dedupe against.
+        const source = useAsSlug ? data?.[useAsSlug] : undefined;
+        const derived = source ? await slugify(source) : undefined;
+        if (hasValue(derived)) {
+            if (!collection) {
+                return derived;
+            }
+            return await getUniqueFieldValue({
+                id: originalDoc?.id,
+                collection: collection.slug,
+                draftsEnabled: hasDraftsEnabled(collection),
+                field: name,
+                locale,
+                req,
+                value: derived
+            });
         }
-        // Stabilize after publish to protect live URLs.
-        if (data?._status === 'published' || originalDoc?._status === 'published') {
+        // No usable source: keep a stored value, otherwise fall back to `<singular>-<N>`.
+        if (storedSlugHasValue) {
             return storedSlug;
         }
-        // Still auto-tracking an unpublished draft with content.
-        return source ? await slugify(source) : null;
+        if (!collection) {
+            return undefined;
+        }
+        return await getSlugFallbackValue({
+            collection,
+            field: name,
+            locale,
+            req,
+            slugify
+        });
     };
 
 //# sourceMappingURL=generateSlug.js.map

package/dist/fields/baseFields/slug/generateSlug.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/fields/baseFields/slug/generateSlug.ts"],"sourcesContent":["import type { TypeWithID } from '../../../collections/config/types.js'\nimport type { FieldHook } from '../../config/types.js'\nimport type { Slugify } from './types.js'\n\nimport { hasAutosaveEnabled } from '../../../utilities/getVersionsConfig.js'\nimport { slugify as defaultSlugify } from '../../../utilities/slugify.js'\nimport { countVersions } from './countVersions.js'\n\ntype Args = {\n  name: string\n  slugify?: Slugify\n  useAsSlug: string\n}\n\n/**\n * Field `beforeChange` hook for the native `slug` field. Returns the slug value.\n *\n * Auto-tracking is derived statelessly: the slug follows its source while it is\n * empty or still equals `slugify(storedSource)`. Once it diverges (the admin\n * overwrites it), it freezes — and stays frozen, because the stored value keeps\n * differing from `slugify(source)`. Re-aligning (the UI generate button) resumes\n * tracking.\n */\nexport const generateSlug =\n  ({ name, slugify: customSlugify, useAsSlug }: Args): FieldHook =>\n  async ({ collection, data, global, operation, originalDoc, req, value }) => {\n    const source = data?.[useAsSlug]\n\n    const slugify = (valueToSlugify: unknown) =>\n      customSlugify\n        ? customSlugify({ data: (data ?? {}) as TypeWithID, req, valueToSlugify })\n        : defaultSlugify(valueToSlugify as string)\n\n    const entity = collection || global!\n\n    if (operation === 'create') {\n      // Autosave drafts: do not auto-generate on the initial draft — the user is still entering content.\n      // Keep the explicit non-slugified value (if any); generation begins on a later autosave.\n      if (hasAutosaveEnabled(entity) && data?._status === 'draft') {\n        return value || null\n      }\n\n      // Keep an explicitly provided slug; otherwise generate from the source.\n      return await slugify(value || source)\n    }\n\n    const storedSlug = originalDoc?.[name]\n    const originalSource = originalDoc?.[useAsSlug]\n\n    // User explicitly edited the slug (or cleared the value): respect it.\n    if (value !== undefined && value !== storedSlug) {\n      return value\n    }\n\n    // No explicit edit this save. If the stored slug doesn't match what its source\n    // would generate, it was customized on an earlier save — keep it frozen.\n    const storedSlugIsCustom = storedSlug && storedSlug !== (await slugify(originalSource))\n\n    if (storedSlugIsCustom) {\n      return storedSlug\n    }\n\n    if (!hasAutosaveEnabled(entity)) {\n      // Non-autosave: generate once while empty, then freeze.\n      return storedSlug || (await slugify(source))\n    }\n\n    // Autosave / drafts\n    const priorVersions = await countVersions({\n      collectionSlug: collection?.slug,\n      globalSlug: global?.slug,\n      parentID: originalDoc?.id,\n      req,\n    })\n\n    // Do not generate on the very first draft (no prior version yet).\n    if (priorVersions === 0) {\n      return storedSlug ?? null\n    }\n\n    // Stabilize after publish to protect live URLs.\n    if (data?._status === 'published' || originalDoc?._status === 'published') {\n      return storedSlug\n    }\n\n    // Still auto-tracking an unpublished draft with content.\n    return source ? await slugify(source) : null\n  }\n"],"names":["hasAutosaveEnabled","slugify","defaultSlugify","countVersions","generateSlug","name","customSlugify","useAsSlug","collection","data","global","operation","originalDoc","req","value","source","valueToSlugify","entity","_status","storedSlug","originalSource","undefined","storedSlugIsCustom","priorVersions","collectionSlug","slug","globalSlug","parentID","id"],"mappings":"AAIA,SAASA,kBAAkB,QAAQ,0CAAyC;AAC5E,SAASC,WAAWC,cAAc,QAAQ,gCAA+B;AACzE,SAASC,aAAa,QAAQ,qBAAoB;AAQlD;;;;;;;;CAQC,GACD,OAAO,MAAMC,eACX,CAAC,EAAEC,IAAI,EAAEJ,SAASK,aAAa,EAAEC,SAAS,EAAQ,GAClD,OAAO,EAAEC,UAAU,EAAEC,IAAI,EAAEC,MAAM,EAAEC,SAAS,EAAEC,WAAW,EAAEC,GAAG,EAAEC,KAAK,EAAE;QACrE,MAAMC,SAASN,MAAM,CAACF,UAAU;QAEhC,MAAMN,UAAU,CAACe,iBACfV,gBACIA,cAAc;gBAAEG,MAAOA,QAAQ,CAAC;gBAAkBI;gBAAKG;YAAe,KACtEd,eAAec;QAErB,MAAMC,SAAST,cAAcE;QAE7B,IAAIC,cAAc,UAAU;YAC1B,mGAAmG;YACnG,yFAAyF;YACzF,IAAIX,mBAAmBiB,WAAWR,MAAMS,YAAY,SAAS;gBAC3D,OAAOJ,SAAS;YAClB;YAEA,wEAAwE;YACxE,OAAO,MAAMb,QAAQa,SAASC;QAChC;QAEA,MAAMI,aAAaP,aAAa,CAACP,KAAK;QACtC,MAAMe,iBAAiBR,aAAa,CAACL,UAAU;QAE/C,sEAAsE;QACtE,IAAIO,UAAUO,aAAaP,UAAUK,YAAY;YAC/C,OAAOL;QACT;QAEA,+EAA+E;QAC/E,yEAAyE;QACzE,MAAMQ,qBAAqBH,cAAcA,eAAgB,MAAMlB,QAAQmB;QAEvE,IAAIE,oBAAoB;YACtB,OAAOH;QACT;QAEA,IAAI,CAACnB,mBAAmBiB,SAAS;YAC/B,wDAAwD;YACxD,OAAOE,cAAe,MAAMlB,QAAQc;QACtC;QAEA,oBAAoB;QACpB,MAAMQ,gBAAgB,MAAMpB,cAAc;YACxCqB,gBAAgBhB,YAAYiB;YAC5BC,YAAYhB,QAAQe;YACpBE,UAAUf,aAAagB;YACvBf;QACF;QAEA,kEAAkE;QAClE,IAAIU,kBAAkB,GAAG;YACvB,OAAOJ,cAAc;QACvB;QAEA,gDAAgD;QAChD,IAAIV,MAAMS,YAAY,eAAeN,aAAaM,YAAY,aAAa;YACzE,OAAOC;QACT;QAEA,yDAAyD;QACzD,OAAOJ,SAAS,MAAMd,QAAQc,UAAU;IAC1C,EAAC"}
+{"version":3,"sources":["../../../../src/fields/baseFields/slug/generateSlug.ts"],"sourcesContent":["import type { TypeWithID } from '../../../collections/config/types.js'\nimport type { FieldHook } from '../../config/types.js'\nimport type { Slugify } from './types.js'\n\nimport { ValidationError } from '../../../errors/index.js'\nimport { fieldValueExists } from '../../../utilities/fieldValueExists.js'\nimport { getUniqueFieldValue } from '../../../utilities/getUniqueFieldValue.js'\nimport { hasDraftsEnabled } from '../../../utilities/getVersionsConfig.js'\nimport { slugify as defaultSlugify } from '../../../utilities/slugify.js'\nimport { consumeSlugDuplicateFallback } from './duplicateContext.js'\nimport { getSlugFallbackValue } from './getSlugFallbackValue.js'\nimport { hasValue } from './hasValue.js'\n\ntype Args = {\n  localized?: boolean\n  name: string\n  slugify?: Slugify\n  useAsSlug?: string\n}\n\n/**\n * `beforeChange` hook for the native `slug` field.\n *\n * Fills the slug only while empty and never rewrites one that's set, so a lagging autosave can't\n * clobber it with a stale value:\n *   - empty with no source falls back to `<singular>-<N>`, e.g. `posts-1` (see {@link getSlugFallbackValue})\n *   - explicit input and the source field are slugified, e.g. \"Hello World\" → \"hello-world\"\n *   - an already-set slug is preserved as-is\n *\n * Generated values dedupe against existing slugs; a localized slug is unique per-locale, so its\n * dedupe and fallback are scoped to the locale being written. Globals have no collection to dedupe\n * against, so their slug is left as-is.\n */\nexport const generateSlug =\n  ({ name, localized, slugify: customSlugify, useAsSlug }: Args): FieldHook =>\n  async ({ collection, context, data, operation, originalDoc, req, value }) => {\n    const slugify = (valueToSlugify: unknown) =>\n      customSlugify\n        ? customSlugify({ data: (data ?? {}) as TypeWithID, req, valueToSlugify })\n        : defaultSlugify(valueToSlugify as string)\n\n    // A localized slug is unique only within its locale, so every uniqueness query below is scoped\n    // to the locale being written.\n    const locale = localized ? (req.locale ?? undefined) : undefined\n\n    // A duplicated document:\n    //  - Takes a fresh `<singular>-<N>` fallback — not the original's slug, not a source-derived one\n    //  - Skips the explicit-collision check below (see generateSlugBeforeDuplicate).\n    if (collection && consumeSlugDuplicateFallback(context, name)) {\n      return await getSlugFallbackValue({ collection, field: name, locale, req, slugify })\n    }\n\n    const storedSlug = originalDoc?.[name]\n\n    const storedSlugHasValue = hasValue(storedSlug)\n\n    // Explicit value from the client wins — normalized through the field's slugify.\n    // It must be unique: reject a collision rather than silently changing it,\n    // only generated values are automatically deduped.\n    // A value that slugifies to nothing (e.g. \"!!!\") isn't a usable slug,\n    // so fall through to the source/fallback rather than store an empty one.\n    if (hasValue(value)) {\n      const slugified = await slugify(value)\n\n      if (hasValue(slugified)) {\n        // Unchanged from what's stored — already unique, so skip the collision query. Autosave\n        // resends the current slug on every tick; without this each tick runs a needless read.\n        if (slugified === storedSlug) {\n          return storedSlug\n        }\n\n        if (\n          collection &&\n          (await fieldValueExists({\n            id: originalDoc?.id,\n            collection: collection.slug,\n            draftsEnabled: hasDraftsEnabled(collection),\n            field: name,\n            locale,\n            req,\n            value: slugified,\n          }))\n        ) {\n          throw new ValidationError(\n            { errors: [{ message: req.t('error:valueMustBeUnique'), path: name }] },\n            req.t,\n          )\n        }\n\n        return slugified\n      }\n    }\n\n    // On update, preserve a slug that is already set — only fill it while empty.\n    if (operation !== 'create' && storedSlugHasValue) {\n      return storedSlug\n    }\n\n    // Derive an empty slug from its source, when present.\n    // Dedupe so two documents don't both claim it if they have the same source value.\n    // Globals have no collection to dedupe against.\n    const source = useAsSlug ? data?.[useAsSlug] : undefined\n    const derived = source ? await slugify(source) : undefined\n\n    if (hasValue(derived)) {\n      if (!collection) {\n        return derived\n      }\n\n      return await getUniqueFieldValue({\n        id: originalDoc?.id,\n        collection: collection.slug,\n        draftsEnabled: hasDraftsEnabled(collection),\n        field: name,\n        locale,\n        req,\n        value: derived as string,\n      })\n    }\n\n    // No usable source: keep a stored value, otherwise fall back to `<singular>-<N>`.\n    if (storedSlugHasValue) {\n      return storedSlug\n    }\n\n    if (!collection) {\n      return undefined\n    }\n\n    return await getSlugFallbackValue({ collection, field: name, locale, req, slugify })\n  }\n"],"names":["ValidationError","fieldValueExists","getUniqueFieldValue","hasDraftsEnabled","slugify","defaultSlugify","consumeSlugDuplicateFallback","getSlugFallbackValue","hasValue","generateSlug","name","localized","customSlugify","useAsSlug","collection","context","data","operation","originalDoc","req","value","valueToSlugify","locale","undefined","field","storedSlug","storedSlugHasValue","slugified","id","slug","draftsEnabled","errors","message","t","path","source","derived"],"mappings":"AAIA,SAASA,eAAe,QAAQ,2BAA0B;AAC1D,SAASC,gBAAgB,QAAQ,yCAAwC;AACzE,SAASC,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,gBAAgB,QAAQ,0CAAyC;AAC1E,SAASC,WAAWC,cAAc,QAAQ,gCAA+B;AACzE,SAASC,4BAA4B,QAAQ,wBAAuB;AACpE,SAASC,oBAAoB,QAAQ,4BAA2B;AAChE,SAASC,QAAQ,QAAQ,gBAAe;AASxC;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC,eACX,CAAC,EAAEC,IAAI,EAAEC,SAAS,EAAEP,SAASQ,aAAa,EAAEC,SAAS,EAAQ,GAC7D,OAAO,EAAEC,UAAU,EAAEC,OAAO,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,GAAG,EAAEC,KAAK,EAAE;QACtE,MAAMhB,UAAU,CAACiB,iBACfT,gBACIA,cAAc;gBAAEI,MAAOA,QAAQ,CAAC;gBAAkBG;gBAAKE;YAAe,KACtEhB,eAAegB;QAErB,+FAA+F;QAC/F,+BAA+B;QAC/B,MAAMC,SAASX,YAAaQ,IAAIG,MAAM,IAAIC,YAAaA;QAEvD,yBAAyB;QACzB,iGAAiG;QACjG,iFAAiF;QACjF,IAAIT,cAAcR,6BAA6BS,SAASL,OAAO;YAC7D,OAAO,MAAMH,qBAAqB;gBAAEO;gBAAYU,OAAOd;gBAAMY;gBAAQH;gBAAKf;YAAQ;QACpF;QAEA,MAAMqB,aAAaP,aAAa,CAACR,KAAK;QAEtC,MAAMgB,qBAAqBlB,SAASiB;QAEpC,gFAAgF;QAChF,0EAA0E;QAC1E,mDAAmD;QACnD,sEAAsE;QACtE,yEAAyE;QACzE,IAAIjB,SAASY,QAAQ;YACnB,MAAMO,YAAY,MAAMvB,QAAQgB;YAEhC,IAAIZ,SAASmB,YAAY;gBACvB,uFAAuF;gBACvF,uFAAuF;gBACvF,IAAIA,cAAcF,YAAY;oBAC5B,OAAOA;gBACT;gBAEA,IACEX,cACC,MAAMb,iBAAiB;oBACtB2B,IAAIV,aAAaU;oBACjBd,YAAYA,WAAWe,IAAI;oBAC3BC,eAAe3B,iBAAiBW;oBAChCU,OAAOd;oBACPY;oBACAH;oBACAC,OAAOO;gBACT,IACA;oBACA,MAAM,IAAI3B,gBACR;wBAAE+B,QAAQ;4BAAC;gCAAEC,SAASb,IAAIc,CAAC,CAAC;gCAA4BC,MAAMxB;4BAAK;yBAAE;oBAAC,GACtES,IAAIc,CAAC;gBAET;gBAEA,OAAON;YACT;QACF;QAEA,6EAA6E;QAC7E,IAAIV,cAAc,YAAYS,oBAAoB;YAChD,OAAOD;QACT;QAEA,sDAAsD;QACtD,kFAAkF;QAClF,gDAAgD;QAChD,MAAMU,SAAStB,YAAYG,MAAM,CAACH,UAAU,GAAGU;QAC/C,MAAMa,UAAUD,SAAS,MAAM/B,QAAQ+B,UAAUZ;QAEjD,IAAIf,SAAS4B,UAAU;YACrB,IAAI,CAACtB,YAAY;gBACf,OAAOsB;YACT;YAEA,OAAO,MAAMlC,oBAAoB;gBAC/B0B,IAAIV,aAAaU;gBACjBd,YAAYA,WAAWe,IAAI;gBAC3BC,eAAe3B,iBAAiBW;gBAChCU,OAAOd;gBACPY;gBACAH;gBACAC,OAAOgB;YACT;QACF;QAEA,kFAAkF;QAClF,IAAIV,oBAAoB;YACtB,OAAOD;QACT;QAEA,IAAI,CAACX,YAAY;YACf,OAAOS;QACT;QAEA,OAAO,MAAMhB,qBAAqB;YAAEO;YAAYU,OAAOd;YAAMY;YAAQH;YAAKf;QAAQ;IACpF,EAAC"}

package/dist/fields/baseFields/slug/generateSlugBeforeDuplicate.d.ts

@@ -0,0 +1,18 @@
+import type { FieldHook } from '../../config/types.js';
+type Args = {
+    name: string;
+};
+/**
+ * `beforeDuplicate` hook for the native `slug` field.
+ *
+ * Marks the slug so the copy's `beforeChange` takes a fresh `<singular>-<N>` fallback instead of the
+ * original's slug or a source-derived one — see {@link consumeSlugDuplicateFallback} and
+ * {@link generateSlug}. Deferring to that path keeps the fallback deduped in one place.
+ *
+ * Returns `undefined` (not `''`) so a localized slug's non-active locales are dropped rather than
+ * stored as `''`, which two copies of the same source would collide on under the unique index. The
+ * active locale is regenerated by `beforeChange` via the mark.
+ */
+export declare const generateSlugBeforeDuplicate: ({ name }: Args) => FieldHook;
+export {};
+//# sourceMappingURL=generateSlugBeforeDuplicate.d.ts.map

package/dist/fields/baseFields/slug/generateSlugBeforeDuplicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateSlugBeforeDuplicate.d.ts","sourceRoot":"","sources":["../../../../src/fields/baseFields/slug/generateSlugBeforeDuplicate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAItD,KAAK,IAAI,GAAG;IACV,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,aAC3B,IAAI,KAAG,SAQjB,CAAA"}

package/dist/fields/baseFields/slug/generateSlugBeforeDuplicate.js

@@ -0,0 +1,20 @@
+import { markSlugForDuplicateFallback } from './duplicateContext.js';
+/**
+ * `beforeDuplicate` hook for the native `slug` field.
+ *
+ * Marks the slug so the copy's `beforeChange` takes a fresh `<singular>-<N>` fallback instead of the
+ * original's slug or a source-derived one — see {@link consumeSlugDuplicateFallback} and
+ * {@link generateSlug}. Deferring to that path keeps the fallback deduped in one place.
+ *
+ * Returns `undefined` (not `''`) so a localized slug's non-active locales are dropped rather than
+ * stored as `''`, which two copies of the same source would collide on under the unique index. The
+ * active locale is regenerated by `beforeChange` via the mark.
+ */ export const generateSlugBeforeDuplicate = ({ name })=>({ collection, context })=>{
+        if (!collection) {
+            return undefined;
+        }
+        markSlugForDuplicateFallback(context, name);
+        return undefined;
+    };
+
+//# sourceMappingURL=generateSlugBeforeDuplicate.js.map

package/dist/fields/baseFields/slug/generateSlugBeforeDuplicate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/fields/baseFields/slug/generateSlugBeforeDuplicate.ts"],"sourcesContent":["import type { FieldHook } from '../../config/types.js'\n\nimport { markSlugForDuplicateFallback } from './duplicateContext.js'\n\ntype Args = {\n  name: string\n}\n\n/**\n * `beforeDuplicate` hook for the native `slug` field.\n *\n * Marks the slug so the copy's `beforeChange` takes a fresh `<singular>-<N>` fallback instead of the\n * original's slug or a source-derived one — see {@link consumeSlugDuplicateFallback} and\n * {@link generateSlug}. Deferring to that path keeps the fallback deduped in one place.\n *\n * Returns `undefined` (not `''`) so a localized slug's non-active locales are dropped rather than\n * stored as `''`, which two copies of the same source would collide on under the unique index. The\n * active locale is regenerated by `beforeChange` via the mark.\n */\nexport const generateSlugBeforeDuplicate =\n  ({ name }: Args): FieldHook =>\n  ({ collection, context }) => {\n    if (!collection) {\n      return undefined\n    }\n\n    markSlugForDuplicateFallback(context, name)\n    return undefined\n  }\n"],"names":["markSlugForDuplicateFallback","generateSlugBeforeDuplicate","name","collection","context","undefined"],"mappings":"AAEA,SAASA,4BAA4B,QAAQ,wBAAuB;AAMpE;;;;;;;;;;CAUC,GACD,OAAO,MAAMC,8BACX,CAAC,EAAEC,IAAI,EAAQ,GACf,CAAC,EAAEC,UAAU,EAAEC,OAAO,EAAE;QACtB,IAAI,CAACD,YAAY;YACf,OAAOE;QACT;QAEAL,6BAA6BI,SAASF;QACtC,OAAOG;IACT,EAAC"}

package/dist/fields/baseFields/slug/getSlugFallbackValue.d.ts

@@ -0,0 +1,22 @@
+import type { SanitizedCollectionConfig } from '../../../collections/config/types.js';
+import type { DefaultDocumentIDType, Locale } from '../../../index.js';
+import type { PayloadRequest } from '../../../types/index.js';
+type Args = {
+    collection: SanitizedCollectionConfig;
+    field: string;
+    /** Exclude this doc from the check, so a regenerate can reuse its own value. */
+    id?: DefaultDocumentIDType;
+    /** Locale to scope the uniqueness check to, for a localized slug. */
+    locale?: Locale['code'];
+    req: PayloadRequest;
+    slugify: (value: unknown) => Promise<string | undefined> | string | undefined;
+};
+/**
+ * The slug a document falls back to when it has no source to derive from, e.g. `useAsSlug` is empty or missing.
+ * The fallback is unique within the collection and locale, so two documents never claim the same value.
+ * The format is: `<singular>-<N>`, where `N` is the first available integer. Uses the collection's singular
+ * label when it resolves to a plain string, otherwise the collection slug. See {@link getUniqueFieldValue}.
+ */
+export declare const getSlugFallbackValue: ({ id, collection, field, locale, req, slugify, }: Args) => Promise<string>;
+export {};
+//# sourceMappingURL=getSlugFallbackValue.d.ts.map

package/dist/fields/baseFields/slug/getSlugFallbackValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSlugFallbackValue.d.ts","sourceRoot":"","sources":["../../../../src/fields/baseFields/slug/getSlugFallbackValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAA;AACrF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAK7D,KAAK,IAAI,GAAG;IACV,UAAU,EAAE,yBAAyB,CAAA;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,gFAAgF;IAChF,EAAE,CAAC,EAAE,qBAAqB,CAAA;IAC1B,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;IACnB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,SAAS,CAAA;CAC9E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,qDAO9B,IAAI,KAAG,OAAO,CAAC,MAAM,CAcvB,CAAA"}

package/dist/fields/baseFields/slug/getSlugFallbackValue.js

@@ -0,0 +1,23 @@
+import { getUniqueFieldValue } from '../../../utilities/getUniqueFieldValue.js';
+import { hasDraftsEnabled } from '../../../utilities/getVersionsConfig.js';
+/**
+ * The slug a document falls back to when it has no source to derive from, e.g. `useAsSlug` is empty or missing.
+ * The fallback is unique within the collection and locale, so two documents never claim the same value.
+ * The format is: `<singular>-<N>`, where `N` is the first available integer. Uses the collection's singular
+ * label when it resolves to a plain string, otherwise the collection slug. See {@link getUniqueFieldValue}.
+ */ export const getSlugFallbackValue = async ({ id, collection, field, locale, req, slugify })=>{
+    const singularLabel = collection.labels?.singular;
+    const base = typeof singularLabel === 'string' ? singularLabel : collection.slug;
+    return getUniqueFieldValue({
+        id,
+        collection: collection.slug,
+        draftsEnabled: hasDraftsEnabled(collection),
+        field,
+        locale,
+        req,
+        startIndex: 1,
+        value: await slugify(base) || collection.slug
+    });
+};
+
+//# sourceMappingURL=getSlugFallbackValue.js.map

package/dist/fields/baseFields/slug/getSlugFallbackValue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/fields/baseFields/slug/getSlugFallbackValue.ts"],"sourcesContent":["import type { SanitizedCollectionConfig } from '../../../collections/config/types.js'\nimport type { DefaultDocumentIDType, Locale } from '../../../index.js'\nimport type { PayloadRequest } from '../../../types/index.js'\n\nimport { getUniqueFieldValue } from '../../../utilities/getUniqueFieldValue.js'\nimport { hasDraftsEnabled } from '../../../utilities/getVersionsConfig.js'\n\ntype Args = {\n  collection: SanitizedCollectionConfig\n  field: string\n  /** Exclude this doc from the check, so a regenerate can reuse its own value. */\n  id?: DefaultDocumentIDType\n  /** Locale to scope the uniqueness check to, for a localized slug. */\n  locale?: Locale['code']\n  req: PayloadRequest\n  slugify: (value: unknown) => Promise<string | undefined> | string | undefined\n}\n\n/**\n * The slug a document falls back to when it has no source to derive from, e.g. `useAsSlug` is empty or missing.\n * The fallback is unique within the collection and locale, so two documents never claim the same value.\n * The format is: `<singular>-<N>`, where `N` is the first available integer. Uses the collection's singular\n * label when it resolves to a plain string, otherwise the collection slug. See {@link getUniqueFieldValue}.\n */\nexport const getSlugFallbackValue = async ({\n  id,\n  collection,\n  field,\n  locale,\n  req,\n  slugify,\n}: Args): Promise<string> => {\n  const singularLabel = collection.labels?.singular\n  const base = typeof singularLabel === 'string' ? singularLabel : collection.slug\n\n  return getUniqueFieldValue({\n    id,\n    collection: collection.slug,\n    draftsEnabled: hasDraftsEnabled(collection),\n    field,\n    locale,\n    req,\n    startIndex: 1,\n    value: (await slugify(base)) || collection.slug,\n  })\n}\n"],"names":["getUniqueFieldValue","hasDraftsEnabled","getSlugFallbackValue","id","collection","field","locale","req","slugify","singularLabel","labels","singular","base","slug","draftsEnabled","startIndex","value"],"mappings":"AAIA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,gBAAgB,QAAQ,0CAAyC;AAa1E;;;;;CAKC,GACD,OAAO,MAAMC,uBAAuB,OAAO,EACzCC,EAAE,EACFC,UAAU,EACVC,KAAK,EACLC,MAAM,EACNC,GAAG,EACHC,OAAO,EACF;IACL,MAAMC,gBAAgBL,WAAWM,MAAM,EAAEC;IACzC,MAAMC,OAAO,OAAOH,kBAAkB,WAAWA,gBAAgBL,WAAWS,IAAI;IAEhF,OAAOb,oBAAoB;QACzBG;QACAC,YAAYA,WAAWS,IAAI;QAC3BC,eAAeb,iBAAiBG;QAChCC;QACAC;QACAC;QACAQ,YAAY;QACZC,OAAO,AAAC,MAAMR,QAAQI,SAAUR,WAAWS,IAAI;IACjD;AACF,EAAC"}

package/dist/fields/baseFields/slug/hasValue.d.ts

@@ -0,0 +1,3 @@
+/** A slug counts as set only when non-empty; `null`/`undefined`/`''` all mean "no slug yet". */
+export declare const hasValue: (value: unknown) => boolean;
+//# sourceMappingURL=hasValue.d.ts.map

package/dist/fields/baseFields/slug/hasValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasValue.d.ts","sourceRoot":"","sources":["../../../../src/fields/baseFields/slug/hasValue.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,eAAO,MAAM,QAAQ,UAAW,OAAO,KAAG,OACa,CAAA"}

package/dist/fields/baseFields/slug/hasValue.js

@@ -0,0 +1,3 @@
+/** A slug counts as set only when non-empty; `null`/`undefined`/`''` all mean "no slug yet". */ export const hasValue = (value)=>value !== undefined && value !== null && value !== '';
+
+//# sourceMappingURL=hasValue.js.map

package/dist/fields/baseFields/slug/hasValue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/fields/baseFields/slug/hasValue.ts"],"sourcesContent":["/** A slug counts as set only when non-empty; `null`/`undefined`/`''` all mean \"no slug yet\". */\nexport const hasValue = (value: unknown): boolean =>\n  value !== undefined && value !== null && value !== ''\n"],"names":["hasValue","value","undefined"],"mappings":"AAAA,8FAA8F,GAC9F,OAAO,MAAMA,WAAW,CAACC,QACvBA,UAAUC,aAAaD,UAAU,QAAQA,UAAU,GAAE"}