payload 4.0.0-internal.e55ccef → 4.0.0-internal.ea6e8f8

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

@@ -0,0 +1,65 @@
+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, overrideAccess = false, 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,
+                overrideAccess,
+                req,
+                value: derived
+            }) : await getSlugFallbackValue({
+                collection,
+                field: field.name,
+                locale,
+                overrideAccess,
+                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  overrideAccess?: boolean\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  overrideAccess = false,\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            overrideAccess,\n            req,\n            value: derived as string,\n          })\n        : await getSlugFallbackValue({\n            collection,\n            field: field.name,\n            locale,\n            overrideAccess,\n            req,\n            slugify,\n          })\n    }\n\n    data[field.name] = localeValues\n  }\n\n  return data\n}\n"],"names":["getUniqueFieldValue","hasDraftsEnabled","slugify","defaultSlugify","getSlugFallbackValue","hasValue","fillEmptyLocalizedSlugs","collection","data","overrideAccess","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;AAUxC;;;;;;;;;;CAUC,GACD,OAAO,MAAMC,0BAA0B,OAAO,EAC5CC,UAAU,EACVC,IAAI,EACJC,iBAAiB,KAAK,EACtBC,GAAG,EACE;IACL,MAAM,EAAEC,YAAY,EAAE,GAAGD,IAAIE,OAAO,CAACC,MAAM;IAE3C,IAAI,CAACF,gBAAgBA,aAAaG,WAAW,CAACC,MAAM,GAAG,GAAG;QACxD,OAAOP;IACT;IAEA,MAAMQ,gBAAgBf,iBAAiBM;IAEvC,KAAK,MAAMU,SAASV,WAAWW,eAAe,CAAE;QAC9C,IAAID,MAAME,IAAI,KAAK,UAAU,CAACF,MAAMG,SAAS,EAAE;YAC7C;QACF;QAEA,MAAMC,gBAAgBJ,MAAMK,MAAM,EAAEpB;QAEpC,MAAMA,UAAU,CAACqB,iBACfF,gBACIA,cAAc;gBAAEb;gBAAME;gBAAKa;YAAe,KAC1CpB,eAAeoB;QAErB,8FAA8F;QAC9F,2FAA2F;QAC3F,MAAMC,cAAcP,MAAMQ,SAAS,GAC/BlB,WAAWW,eAAe,CAACQ,IAAI,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAKX,MAAMQ,SAAS,IACjEI;QACJ,MAAMC,SAASb,MAAMQ,SAAS,GAAGjB,IAAI,CAACS,MAAMQ,SAAS,CAAC,GAAGI;QAEzD,MAAME,eAAgBvB,IAAI,CAACS,MAAMW,IAAI,CAAC,IAAI,CAAC;QAE3C,KAAK,MAAMI,UAAUrB,aAAaG,WAAW,CAAE;YAC7C,IAAIT,SAAS0B,YAAY,CAACC,OAAO,GAAG;gBAClC;YACF;YAEA,MAAMC,kBAAkBT,aAAaJ,YAChCU,QAAgD,CAACE,OAAO,GACzDF;YAEJ,MAAMI,UAAUD,kBAAkB,MAAM/B,QAAQ+B,mBAAmBJ;YAEnEE,YAAY,CAACC,OAAO,GAAG3B,SAAS6B,WAC5B,MAAMlC,oBAAoB;gBACxBO,YAAYA,WAAW4B,IAAI;gBAC3BnB;gBACAC,OAAOA,MAAMW,IAAI;gBACjBI;gBACAvB;gBACAC;gBACA0B,OAAOF;YACT,KACA,MAAM9B,qBAAqB;gBACzBG;gBACAU,OAAOA,MAAMW,IAAI;gBACjBI;gBACAvB;gBACAC;gBACAR;YACF;QACN;QAEAM,IAAI,CAACS,MAAMW,IAAI,CAAC,GAAGG;IACrB;IAEA,OAAOvB;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,SAyH/D,CAAA"}

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

@@ -1,64 +1,121 @@
-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, overrideAccess = false, 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,
+                overrideAccess,
+                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,
+                    overrideAccess,
+                    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,
+                overrideAccess,
+                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,
+            overrideAccess,
+            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 ({\n    collection,\n    context,\n    data,\n    operation,\n    originalDoc,\n    overrideAccess = false,\n    req,\n    value,\n  }) => {\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({\n        collection,\n        field: name,\n        locale,\n        overrideAccess,\n        req,\n        slugify,\n      })\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            overrideAccess,\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        overrideAccess,\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({\n      collection,\n      field: name,\n      locale,\n      overrideAccess,\n      req,\n      slugify,\n    })\n  }\n"],"names":["ValidationError","fieldValueExists","getUniqueFieldValue","hasDraftsEnabled","slugify","defaultSlugify","consumeSlugDuplicateFallback","getSlugFallbackValue","hasValue","generateSlug","name","localized","customSlugify","useAsSlug","collection","context","data","operation","originalDoc","overrideAccess","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,EACLC,UAAU,EACVC,OAAO,EACPC,IAAI,EACJC,SAAS,EACTC,WAAW,EACXC,iBAAiB,KAAK,EACtBC,GAAG,EACHC,KAAK,EACN;QACC,MAAMjB,UAAU,CAACkB,iBACfV,gBACIA,cAAc;gBAAEI,MAAOA,QAAQ,CAAC;gBAAkBI;gBAAKE;YAAe,KACtEjB,eAAeiB;QAErB,+FAA+F;QAC/F,+BAA+B;QAC/B,MAAMC,SAASZ,YAAaS,IAAIG,MAAM,IAAIC,YAAaA;QAEvD,yBAAyB;QACzB,iGAAiG;QACjG,iFAAiF;QACjF,IAAIV,cAAcR,6BAA6BS,SAASL,OAAO;YAC7D,OAAO,MAAMH,qBAAqB;gBAChCO;gBACAW,OAAOf;gBACPa;gBACAJ;gBACAC;gBACAhB;YACF;QACF;QAEA,MAAMsB,aAAaR,aAAa,CAACR,KAAK;QAEtC,MAAMiB,qBAAqBnB,SAASkB;QAEpC,gFAAgF;QAChF,0EAA0E;QAC1E,mDAAmD;QACnD,sEAAsE;QACtE,yEAAyE;QACzE,IAAIlB,SAASa,QAAQ;YACnB,MAAMO,YAAY,MAAMxB,QAAQiB;YAEhC,IAAIb,SAASoB,YAAY;gBACvB,uFAAuF;gBACvF,uFAAuF;gBACvF,IAAIA,cAAcF,YAAY;oBAC5B,OAAOA;gBACT;gBAEA,IACEZ,cACC,MAAMb,iBAAiB;oBACtB4B,IAAIX,aAAaW;oBACjBf,YAAYA,WAAWgB,IAAI;oBAC3BC,eAAe5B,iBAAiBW;oBAChCW,OAAOf;oBACPa;oBACAJ;oBACAC;oBACAC,OAAOO;gBACT,IACA;oBACA,MAAM,IAAI5B,gBACR;wBAAEgC,QAAQ;4BAAC;gCAAEC,SAASb,IAAIc,CAAC,CAAC;gCAA4BC,MAAMzB;4BAAK;yBAAE;oBAAC,GACtEU,IAAIc,CAAC;gBAET;gBAEA,OAAON;YACT;QACF;QAEA,6EAA6E;QAC7E,IAAIX,cAAc,YAAYU,oBAAoB;YAChD,OAAOD;QACT;QAEA,sDAAsD;QACtD,kFAAkF;QAClF,gDAAgD;QAChD,MAAMU,SAASvB,YAAYG,MAAM,CAACH,UAAU,GAAGW;QAC/C,MAAMa,UAAUD,SAAS,MAAMhC,QAAQgC,UAAUZ;QAEjD,IAAIhB,SAAS6B,UAAU;YACrB,IAAI,CAACvB,YAAY;gBACf,OAAOuB;YACT;YAEA,OAAO,MAAMnC,oBAAoB;gBAC/B2B,IAAIX,aAAaW;gBACjBf,YAAYA,WAAWgB,IAAI;gBAC3BC,eAAe5B,iBAAiBW;gBAChCW,OAAOf;gBACPa;gBACAJ;gBACAC;gBACAC,OAAOgB;YACT;QACF;QAEA,kFAAkF;QAClF,IAAIV,oBAAoB;YACtB,OAAOD;QACT;QAEA,IAAI,CAACZ,YAAY;YACf,OAAOU;QACT;QAEA,OAAO,MAAMjB,qBAAqB;YAChCO;YACAW,OAAOf;YACPa;YACAJ;YACAC;YACAhB;QACF;IACF,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,23 @@
+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'];
+    overrideAccess?: boolean;
+    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, overrideAccess, 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,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,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,qEAQ9B,IAAI,KAAG,OAAO,CAAC,MAAM,CAevB,CAAA"}

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

@@ -0,0 +1,24 @@
+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, overrideAccess = false, 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,
+        overrideAccess,
+        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  overrideAccess?: boolean\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  overrideAccess = false,\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    overrideAccess,\n    req,\n    startIndex: 1,\n    value: (await slugify(base)) || collection.slug,\n  })\n}\n"],"names":["getUniqueFieldValue","hasDraftsEnabled","getSlugFallbackValue","id","collection","field","locale","overrideAccess","req","slugify","singularLabel","labels","singular","base","slug","draftsEnabled","startIndex","value"],"mappings":"AAIA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,gBAAgB,QAAQ,0CAAyC;AAc1E;;;;;CAKC,GACD,OAAO,MAAMC,uBAAuB,OAAO,EACzCC,EAAE,EACFC,UAAU,EACVC,KAAK,EACLC,MAAM,EACNC,iBAAiB,KAAK,EACtBC,GAAG,EACHC,OAAO,EACF;IACL,MAAMC,gBAAgBN,WAAWO,MAAM,EAAEC;IACzC,MAAMC,OAAO,OAAOH,kBAAkB,WAAWA,gBAAgBN,WAAWU,IAAI;IAEhF,OAAOd,oBAAoB;QACzBG;QACAC,YAAYA,WAAWU,IAAI;QAC3BC,eAAed,iBAAiBG;QAChCC;QACAC;QACAC;QACAC;QACAQ,YAAY;QACZC,OAAO,AAAC,MAAMR,QAAQI,SAAUT,WAAWU,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"}

package/dist/fields/config/client.d.ts

@@ -1,5 +1,5 @@
 import type { I18nClient } from '@payloadcms/translations';
-import type { ImportMap } from '../../bin/generateImportMap/index.js';
+import type { ImportMap } from '../../cli/commands/generateImportMap/generateImportMap.js';
 import type { Block, ClientBlock, ClientField, Field, FieldBase } from '../../fields/config/types.js';
 import type { Payload } from '../../types/index.js';
 export { ClientField };

package/dist/fields/config/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/fields/config/client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAyB,UAAU,EAAa,MAAM,0BAA0B,CAAA;AAE5F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAA;AAErE,OAAO,KAAK,EAGV,KAAK,EAGL,WAAW,EACX,WAAW,EAEX,KAAK,EACL,SAAS,EAOV,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAUnD,OAAO,EAAE,WAAW,EAAE,CAAA;AAEtB,MAAM,MAAM,yBAAyB,GACjC,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,eAAe,GACf,SAAS,GACT,YAAY,GACZ,OAAO,GACP,SAAS,GACT,UAAU,GACV,MAAM,IAAI,CAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,cAAc,GAAG,OAAO,CAAC,CAAA;AAEzE,MAAM,MAAM,8BAA8B,GAAG,MAAM,IAAI,CACrD,SAAS,CAAC,OAAO,CAAC,EAElB,YAAY,GAAG,WAAW,CAC3B,CAAA;AAgCD,eAAO,MAAM,kBAAkB,gDAK5B;IACD,MAAM,EAAE,CAAC,KAAK,GAAG,MAAM,CAAC,EAAE,CAAA;IAC1B,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,CAAA;IACvD,IAAI,EAAE,UAAU,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;CACrB,KAAG,CAAC,WAAW,GAAG,MAAM,CAAC,EAiFzB,CAAA;AAED,eAAO,MAAM,iBAAiB,8DAK3B;IACD,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,CAAA;IACvD,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,UAAU,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;CACrB,KAAG,WAmSH,CAAA;AAED,eAAO,MAAM,kBAAkB,iEAM5B;IACD,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,CAAA;IACvD,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,IAAI,EAAE,UAAU,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;CACrB,KAAG,WAAW,EAiCd,CAAA"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/fields/config/client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAyB,UAAU,EAAa,MAAM,0BAA0B,CAAA;AAE5F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2DAA2D,CAAA;AAE1F,OAAO,KAAK,EAGV,KAAK,EAGL,WAAW,EACX,WAAW,EAEX,KAAK,EACL,SAAS,EAOV,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAUnD,OAAO,EAAE,WAAW,EAAE,CAAA;AAEtB,MAAM,MAAM,yBAAyB,GACjC,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,eAAe,GACf,SAAS,GACT,YAAY,GACZ,OAAO,GACP,SAAS,GACT,UAAU,GACV,MAAM,IAAI,CAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,cAAc,GAAG,OAAO,CAAC,CAAA;AAEzE,MAAM,MAAM,8BAA8B,GAAG,MAAM,IAAI,CACrD,SAAS,CAAC,OAAO,CAAC,EAElB,YAAY,GAAG,WAAW,CAC3B,CAAA;AAgCD,eAAO,MAAM,kBAAkB,gDAK5B;IACD,MAAM,EAAE,CAAC,KAAK,GAAG,MAAM,CAAC,EAAE,CAAA;IAC1B,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,CAAA;IACvD,IAAI,EAAE,UAAU,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;CACrB,KAAG,CAAC,WAAW,GAAG,MAAM,CAAC,EAiFzB,CAAA;AAED,eAAO,MAAM,iBAAiB,8DAK3B;IACD,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,CAAA;IACvD,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,UAAU,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;CACrB,KAAG,WAmSH,CAAA;AAED,eAAO,MAAM,kBAAkB,iEAM5B;IACD,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC,CAAA;IACvD,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,IAAI,EAAE,UAAU,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;CACrB,KAAG,WAAW,EAiCd,CAAA"}

package/dist/fields/config/client.js

@@ -1,6 +1,6 @@
 // @ts-strict-ignore
 /* eslint-disable perfectionist/sort-switch-case */ // Keep perfectionist/sort-switch-case disabled - it incorrectly messes up the ordering of the switch cases, causing it to break
-import { getFromImportMap } from '../../bin/generateImportMap/utilities/getFromImportMap.js';
+import { getFromImportMap } from '../../cli/commands/generateImportMap/utilities/getFromImportMap.js';
 import { MissingEditorProp } from '../../errors/MissingEditorProp.js';
 import { fieldAffectsData } from '../../fields/config/types.js';
 import { flattenTopLevelFields } from '../../utilities/flattenTopLevelFields.js';