payload 4.0.0-internal.2fddfc0 → 4.0.0-internal.31ba7ee

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,aAAa,EAAW,MAAM,YAAY,CAAA;AAMxD,KAAK,QAAQ,GAAG;IACd,aAAa,EAAE,WAAW,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAA;CAClD,GAAG,IAAI,CAAC,aAAa,EAAE,SAAS,CAAC,GAChC,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,CAAA;AAoB5C;;;GAGG;AACH,eAAO,MAAM,YAAY,GACtB,sDAAsD,QAAQ,KAAG,SA6EjE,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,84 +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';
-const slugify = ({ customSlugify, data, req, valueToSlugify })=>{
-    if (customSlugify) {
-        return customSlugify({
-            data,
-            req,
-            valueToSlugify
-        });
-    }
-    return defaultSlugify(valueToSlugify);
-};
+import { consumeSlugDuplicateFallback } from './duplicateContext.js';
+import { getSlugFallbackValue } from './getSlugFallbackValue.js';
+import { hasValue } from './hasValue.js';
 /**
- * This is a `BeforeChange` field hook used to auto-generate the `slug` field.
- * See `slugField` for more details.
- */ export const generateSlug = ({ slugFieldName, slugify: customSlugify, useAsSlug })=>async ({ collection, data, global, operation, originalDoc, req, value: isChecked })=>{
-        if (operation === 'create') {
-            if (data) {
-                data[slugFieldName] = slugify({
-                    customSlugify,
-                    data,
-                    req,
-                    // Ensure user-defined slugs are not overwritten during create
-                    // Use a generic falsy check here to include empty strings
-                    valueToSlugify: data?.[slugFieldName] || data?.[useAsSlug]
-                });
-            }
-            return Boolean(!data?.[slugFieldName]);
+ * `beforeChange` hook for the native `slug` field.
+ *
+ * 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);
+        // 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
+            });
         }
-        if (operation === 'update') {
-            // Early return to avoid additional processing
-            if (!isChecked) {
-                return false;
-            }
-            if (!hasAutosaveEnabled(collection || global)) {
-                // We can generate the slug at this point
-                if (data) {
-                    data[slugFieldName] = slugify({
-                        customSlugify,
-                        data,
-                        req,
-                        valueToSlugify: data?.[useAsSlug]
-                    });
-                }
-                return Boolean(!data?.[slugFieldName]);
-            } else {
-                // If we're publishing, we can avoid querying as we can safely assume we've exceeded the version threshold (2)
-                const isPublishing = data?._status === 'published';
-                // Ensure the user can take over the generated slug themselves without it ever being overridden back
-                const userOverride = data?.[slugFieldName] !== originalDoc?.[slugFieldName];
-                if (!userOverride) {
-                    if (data) {
-                        // If the fallback is an empty string, we want the slug to return to `null`
-                        // This will ensure that live preview conditions continue to run as expected
-                        data[slugFieldName] = data?.[useAsSlug] ? slugify({
-                            customSlugify,
-                            data,
-                            req,
-                            valueToSlugify: data?.[useAsSlug]
-                        }) : null;
-                    }
+        const storedSlug = originalDoc?.[name];
+        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 (isPublishing || userOverride) {
-                    return false;
-                }
-                // Important: ensure `countVersions` is not called unnecessarily often
-                // That is why this is buried beneath all these conditions
-                const versionCount = await countVersions({
-                    collectionSlug: collection?.slug,
-                    globalSlug: global?.slug,
-                    parentID: originalDoc?.id,
-                    req
-                });
-                if (versionCount <= 2) {
-                    return true;
-                } else {
-                    return false;
+                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;
             }
         }
+        // On update, preserve a slug that is already set — only fill it while empty.
+        if (operation !== 'create' && storedSlugHasValue) {
+            return storedSlug;
+        }
+        // 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
+            });
+        }
+        // No usable source: keep a stored value, otherwise fall back to `<singular>-<N>`.
+        if (storedSlugHasValue) {
+            return storedSlug;
+        }
+        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 { PayloadRequest } from '../../../types/index.js'\nimport type { FieldHook } from '../../config/types.js'\nimport type { SlugFieldArgs, Slugify } from './index.js'\n\nimport { hasAutosaveEnabled } from '../../../utilities/getVersionsConfig.js'\nimport { slugify as defaultSlugify } from '../../../utilities/slugify.js'\nimport { countVersions } from './countVersions.js'\n\ntype HookArgs = {\n  slugFieldName: NonNullable<SlugFieldArgs['name']>\n} & Pick<SlugFieldArgs, 'slugify'> &\n  Required<Pick<SlugFieldArgs, 'useAsSlug'>>\n\nconst slugify = ({\n  customSlugify,\n  data,\n  req,\n  valueToSlugify,\n}: {\n  customSlugify?: Slugify\n  data: Record<string, unknown>\n  req: PayloadRequest\n  valueToSlugify?: string\n}) => {\n  if (customSlugify) {\n    return customSlugify({ data, req, valueToSlugify })\n  }\n\n  return defaultSlugify(valueToSlugify)\n}\n\n/**\n * This is a `BeforeChange` field hook used to auto-generate the `slug` field.\n * See `slugField` for more details.\n */\nexport const generateSlug =\n  ({ slugFieldName, slugify: customSlugify, useAsSlug }: HookArgs): FieldHook =>\n  async ({ collection, data, global, operation, originalDoc, req, value: isChecked }) => {\n    if (operation === 'create') {\n      if (data) {\n        data[slugFieldName] = slugify({\n          customSlugify,\n          data,\n          req,\n          // Ensure user-defined slugs are not overwritten during create\n          // Use a generic falsy check here to include empty strings\n          valueToSlugify: data?.[slugFieldName] || data?.[useAsSlug],\n        })\n      }\n\n      return Boolean(!data?.[slugFieldName])\n    }\n\n    if (operation === 'update') {\n      // Early return to avoid additional processing\n      if (!isChecked) {\n        return false\n      }\n\n      if (!hasAutosaveEnabled(collection || global!)) {\n        // We can generate the slug at this point\n        if (data) {\n          data[slugFieldName] = slugify({\n            customSlugify,\n            data,\n            req,\n            valueToSlugify: data?.[useAsSlug],\n          })\n        }\n\n        return Boolean(!data?.[slugFieldName])\n      } else {\n        // If we're publishing, we can avoid querying as we can safely assume we've exceeded the version threshold (2)\n        const isPublishing = data?._status === 'published'\n\n        // Ensure the user can take over the generated slug themselves without it ever being overridden back\n        const userOverride = data?.[slugFieldName] !== originalDoc?.[slugFieldName]\n\n        if (!userOverride) {\n          if (data) {\n            // If the fallback is an empty string, we want the slug to return to `null`\n            // This will ensure that live preview conditions continue to run as expected\n            data[slugFieldName] = data?.[useAsSlug]\n              ? slugify({\n                  customSlugify,\n                  data,\n                  req,\n                  valueToSlugify: data?.[useAsSlug],\n                })\n              : null\n          }\n        }\n\n        if (isPublishing || userOverride) {\n          return false\n        }\n\n        // Important: ensure `countVersions` is not called unnecessarily often\n        // That is why this is buried beneath all these conditions\n        const versionCount = await countVersions({\n          collectionSlug: collection?.slug,\n          globalSlug: global?.slug,\n          parentID: originalDoc?.id,\n          req,\n        })\n\n        if (versionCount <= 2) {\n          return true\n        } else {\n          return false\n        }\n      }\n    }\n  }\n"],"names":["hasAutosaveEnabled","slugify","defaultSlugify","countVersions","customSlugify","data","req","valueToSlugify","generateSlug","slugFieldName","useAsSlug","collection","global","operation","originalDoc","value","isChecked","Boolean","isPublishing","_status","userOverride","versionCount","collectionSlug","slug","globalSlug","parentID","id"],"mappings":"AAIA,SAASA,kBAAkB,QAAQ,0CAAyC;AAC5E,SAASC,WAAWC,cAAc,QAAQ,gCAA+B;AACzE,SAASC,aAAa,QAAQ,qBAAoB;AAOlD,MAAMF,UAAU,CAAC,EACfG,aAAa,EACbC,IAAI,EACJC,GAAG,EACHC,cAAc,EAMf;IACC,IAAIH,eAAe;QACjB,OAAOA,cAAc;YAAEC;YAAMC;YAAKC;QAAe;IACnD;IAEA,OAAOL,eAAeK;AACxB;AAEA;;;CAGC,GACD,OAAO,MAAMC,eACX,CAAC,EAAEC,aAAa,EAAER,SAASG,aAAa,EAAEM,SAAS,EAAY,GAC/D,OAAO,EAAEC,UAAU,EAAEN,IAAI,EAAEO,MAAM,EAAEC,SAAS,EAAEC,WAAW,EAAER,GAAG,EAAES,OAAOC,SAAS,EAAE;QAChF,IAAIH,cAAc,UAAU;YAC1B,IAAIR,MAAM;gBACRA,IAAI,CAACI,cAAc,GAAGR,QAAQ;oBAC5BG;oBACAC;oBACAC;oBACA,8DAA8D;oBAC9D,0DAA0D;oBAC1DC,gBAAgBF,MAAM,CAACI,cAAc,IAAIJ,MAAM,CAACK,UAAU;gBAC5D;YACF;YAEA,OAAOO,QAAQ,CAACZ,MAAM,CAACI,cAAc;QACvC;QAEA,IAAII,cAAc,UAAU;YAC1B,8CAA8C;YAC9C,IAAI,CAACG,WAAW;gBACd,OAAO;YACT;YAEA,IAAI,CAAChB,mBAAmBW,cAAcC,SAAU;gBAC9C,yCAAyC;gBACzC,IAAIP,MAAM;oBACRA,IAAI,CAACI,cAAc,GAAGR,QAAQ;wBAC5BG;wBACAC;wBACAC;wBACAC,gBAAgBF,MAAM,CAACK,UAAU;oBACnC;gBACF;gBAEA,OAAOO,QAAQ,CAACZ,MAAM,CAACI,cAAc;YACvC,OAAO;gBACL,8GAA8G;gBAC9G,MAAMS,eAAeb,MAAMc,YAAY;gBAEvC,oGAAoG;gBACpG,MAAMC,eAAef,MAAM,CAACI,cAAc,KAAKK,aAAa,CAACL,cAAc;gBAE3E,IAAI,CAACW,cAAc;oBACjB,IAAIf,MAAM;wBACR,2EAA2E;wBAC3E,4EAA4E;wBAC5EA,IAAI,CAACI,cAAc,GAAGJ,MAAM,CAACK,UAAU,GACnCT,QAAQ;4BACNG;4BACAC;4BACAC;4BACAC,gBAAgBF,MAAM,CAACK,UAAU;wBACnC,KACA;oBACN;gBACF;gBAEA,IAAIQ,gBAAgBE,cAAc;oBAChC,OAAO;gBACT;gBAEA,sEAAsE;gBACtE,0DAA0D;gBAC1D,MAAMC,eAAe,MAAMlB,cAAc;oBACvCmB,gBAAgBX,YAAYY;oBAC5BC,YAAYZ,QAAQW;oBACpBE,UAAUX,aAAaY;oBACvBpB;gBACF;gBAEA,IAAIe,gBAAgB,GAAG;oBACrB,OAAO;gBACT,OAAO;oBACL,OAAO;gBACT;YACF;QACF;IACF,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/baseFields/slug/types.d.ts

@@ -0,0 +1,14 @@
+import type { TextFieldClientProps } from '../../../admin/types.js';
+import type { TypeWithID } from '../../../collections/config/types.js';
+import type { PayloadRequest } from '../../../types/index.js';
+export type Slugify<T extends TypeWithID = any> = (args: {
+    data: T;
+    req: PayloadRequest;
+    valueToSlugify?: any;
+}) => Promise<string | undefined> | string | undefined;
+/**
+ * Props the `SlugField` client component receives. The slug-specific `useAsSlug`
+ * arrives on the client field config (it is not a server-only property).
+ */
+export type SlugFieldClientProps = TextFieldClientProps;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/fields/baseFields/slug/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAA;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAE7D,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,UAAU,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE;IACvD,IAAI,EAAE,CAAC,CAAA;IACP,GAAG,EAAE,cAAc,CAAA;IACnB,cAAc,CAAC,EAAE,GAAG,CAAA;CACrB,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,SAAS,CAAA;AAEtD;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,oBAAoB,CAAA"}

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

@@ -0,0 +1,6 @@
+/**
+ * Props the `SlugField` client component receives. The slug-specific `useAsSlug`
+ * arrives on the client field config (it is not a server-only property).
+ */ export { };
+
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/fields/baseFields/slug/types.ts"],"sourcesContent":["import type { TextFieldClientProps } from '../../../admin/types.js'\nimport type { TypeWithID } from '../../../collections/config/types.js'\nimport type { PayloadRequest } from '../../../types/index.js'\n\nexport type Slugify<T extends TypeWithID = any> = (args: {\n  data: T\n  req: PayloadRequest\n  valueToSlugify?: any\n}) => Promise<string | undefined> | string | undefined\n\n/**\n * Props the `SlugField` client component receives. The slug-specific `useAsSlug`\n * arrives on the client field config (it is not a server-only property).\n */\nexport type SlugFieldClientProps = TextFieldClientProps\n"],"names":[],"mappings":"AAUA;;;CAGC,GACD,WAAuD"}

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

@@ -1,24 +1,24 @@
 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 };
-export type ServerOnlyFieldProperties = 'dbName' | 'editor' | 'enumName' | 'filterOptions' | 'graphQL' | 'jsonSchema' | 'label' | 'validate' | keyof Pick<FieldBase, 'access' | 'custom' | 'defaultValue' | 'hooks'>;
+export type ServerOnlyFieldProperties = 'dbName' | 'editor' | 'enumName' | 'filterOptions' | 'graphQL' | 'jsonSchema' | 'label' | 'slugify' | 'validate' | keyof Pick<FieldBase, 'access' | 'custom' | 'defaultValue' | 'hooks'>;
 export type ServerOnlyFieldAdminProperties = keyof Pick<FieldBase['admin'], 'components' | 'condition'>;
 export declare const createClientBlocks: ({ blocks, defaultIDType, i18n, importMap, }: {
     blocks: (Block | string)[];
-    defaultIDType: Payload["config"]["db"]["defaultIDType"];
+    defaultIDType: Payload['config']['db']['defaultIDType'];
     i18n: I18nClient;
     importMap: ImportMap;
 }) => (ClientBlock | string)[];
 export declare const createClientField: ({ defaultIDType, field: incomingField, i18n, importMap, }: {
-    defaultIDType: Payload["config"]["db"]["defaultIDType"];
+    defaultIDType: Payload['config']['db']['defaultIDType'];
     field: Field;
     i18n: I18nClient;
     importMap: ImportMap;
 }) => ClientField;
 export declare const createClientFields: ({ defaultIDType, disableAddingID, fields, i18n, importMap, }: {
-    defaultIDType: Payload["config"]["db"]["defaultIDType"];
+    defaultIDType: Payload['config']['db']['defaultIDType'];
     disableAddingID?: boolean;
     fields: Field[];
     i18n: I18nClient;

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,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;AA+BD,eAAO,MAAM,kBAAkB,GAAI,6CAKhC;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,GAAI,2DAK/B;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,GAAI,8DAMhC;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';
@@ -15,7 +15,8 @@ const serverOnlyFieldProperties = [
     'jsonSchema',
     'dbName',
     'enumName',
-    'graphQL'
+    'graphQL',
+    'slugify'
 ];
 const serverOnlyFieldAdminProperties = [
     'condition',