payload 3.0.0-alpha.4 → 3.0.0-alpha.40

package/dist/config/createClientConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createClientConfig.d.ts","sourceRoot":"","sources":["../../src/config/createClientConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE5D,eAAO,MAAM,aAAa,iBA8CzB,CAAA;AA6DD,eAAO,MAAM,cAAc,WAAY,KAAK,EAAE,KAAG,KAAK,EAA+B,CAAA;AAErF,eAAO,MAAM,kBAAkB,kBACd,QAAQ,eAAe,CAAC,GAAG,eAAe,KACxD,QAAQ,YAAY,CAoBtB,CAAA"}
+{"version":3,"file":"createClientConfig.d.ts","sourceRoot":"","sources":["../../src/config/createClientConfig.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAA4B,MAAM,2BAA2B,CAAA;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAE/D,eAAO,MAAM,aAAa,MAAO,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDrC,CAAA;AAoFD,eAAO,MAAM,cAAc,WAAY,KAAK,EAAE,KAAG,KAAK,EAA+B,CAAA;AAErF,eAAO,MAAM,kBAAkB,kBACd,QAAQ,eAAe,CAAC,GAAG,eAAe,KACxD,QAAQ,YAAY,CAkDtB,CAAA"}

package/dist/config/createClientConfig.js

@@ -1,39 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createClientConfig: function() {
-        return createClientConfig;
-    },
-    sanitizeField: function() {
-        return sanitizeField;
-    },
-    sanitizeFields: function() {
-        return sanitizeFields;
-    }
-});
-const sanitizeField = (f)=>{
+export const sanitizeField = (f)=>{
     const field = {
         ...f
     };
-    if ('access' in field) delete field.access;
-    if ('hooks' in field) delete field.hooks;
-    if ('validate' in field) delete field.validate;
-    if ('defaultValue' in field) delete field.defaultValue;
-    if ('label' in field) delete field.label;
+    const serverOnlyFieldProperties = [
+        'hooks',
+        'access',
+        'validate',
+        'defaultValue',
+        'label',
+        // This is a `richText` only property
+        'editor'
+    ];
+    serverOnlyFieldProperties.forEach((key)=>{
+        if (key in field) {
+            delete field[key];
+        }
+    });
     if ('fields' in field) {
         field.fields = sanitizeFields(field.fields);
     }
-    if ('editor' in field) {
-        delete field.editor;
-    }
     if ('blocks' in field) {
         field.blocks = field.blocks.map((block)=>{
             const sanitized = {
@@ -44,21 +29,23 @@ const sanitizeField = (f)=>{
         });
     }
     if ('tabs' in field) {
+        // @ts-expect-error
         field.tabs = field.tabs.map((tab)=>sanitizeField(tab));
     }
     if ('admin' in field) {
         field.admin = {
             ...field.admin
         };
-        if ('components' in field.admin) {
-            delete field.admin.components;
-        }
-        if ('condition' in field.admin) {
-            delete field.admin.condition;
-        }
-        if ('description' in field.admin) {
-            delete field.admin.description;
-        }
+        const serverOnlyFieldAdminProperties = [
+            'components',
+            'condition',
+            'description'
+        ];
+        serverOnlyFieldAdminProperties.forEach((key)=>{
+            if (key in field.admin) {
+                delete field.admin[key];
+            }
+        });
     }
     return field;
 };
@@ -67,23 +54,36 @@ const sanitizeCollections = (collections)=>collections.map((collection)=>{
             ...collection
         };
         sanitized.fields = sanitizeFields(sanitized.fields);
-        delete sanitized.hooks;
-        delete sanitized.access;
-        delete sanitized.endpoints;
-        if ('editor' in sanitized) delete sanitized.editor;
+        const serverOnlyCollectionProperties = [
+            'hooks',
+            'access',
+            'endpoints'
+        ];
+        serverOnlyCollectionProperties.forEach((key)=>{
+            if (key in sanitized) {
+                delete sanitized[key];
+            }
+        });
+        if ('upload' in sanitized && typeof sanitized.upload === 'object') {
+            sanitized.upload = {
+                ...sanitized.upload
+            };
+            delete sanitized.upload.handlers;
+        }
         if ('admin' in sanitized) {
             sanitized.admin = {
                 ...sanitized.admin
             };
-            if ('components' in sanitized.admin) {
-                delete sanitized.admin.components;
-            }
-            if ('hidden' in sanitized.admin) {
-                delete sanitized.admin.hidden;
-            }
-            if ('preview' in sanitized.admin) {
-                delete sanitized.admin.preview;
-            }
+            const serverOnlyCollectionAdminProperties = [
+                'components',
+                'hidden',
+                'preview'
+            ];
+            serverOnlyCollectionAdminProperties.forEach((key)=>{
+                if (key in sanitized.admin) {
+                    delete sanitized.admin[key];
+                }
+            });
         }
         return sanitized;
     });
@@ -92,41 +92,76 @@ const sanitizeGlobals = (globals)=>globals.map((global)=>{
             ...global
         };
         sanitized.fields = sanitizeFields(sanitized.fields);
-        delete sanitized.hooks;
-        delete sanitized.access;
-        delete sanitized.endpoints;
+        const serverOnlyProperties = [
+            'hooks',
+            'access',
+            'endpoints'
+        ];
+        serverOnlyProperties.forEach((key)=>{
+            if (key in sanitized) {
+                delete sanitized[key];
+            }
+        });
         if ('admin' in sanitized) {
             sanitized.admin = {
                 ...sanitized.admin
             };
-            if ('components' in sanitized.admin) {
-                delete sanitized.admin.components;
-            }
-            if ('hidden' in sanitized.admin) {
-                delete sanitized.admin.hidden;
-            }
-            if ('preview' in sanitized.admin) {
-                delete sanitized.admin.preview;
-            }
+            const serverOnlyProperties = [
+                'components',
+                'hidden',
+                'preview'
+            ];
+            serverOnlyProperties.forEach((key)=>{
+                if (key in sanitized.admin) {
+                    delete sanitized.admin[key];
+                }
+            });
         }
         return sanitized;
     });
-const sanitizeFields = (fields)=>fields.map(sanitizeField);
-const createClientConfig = async (configPromise)=>{
+export const sanitizeFields = (fields)=>fields.map(sanitizeField);
+export const createClientConfig = async (configPromise)=>{
     const config = await configPromise;
     const clientConfig = {
         ...config
     };
-    delete clientConfig.endpoints;
-    delete clientConfig.db;
-    delete clientConfig.editor;
-    'localization' in clientConfig && clientConfig.localization && clientConfig.localization.locales.forEach((locale)=>{
-        delete locale.toString;
+    const serverOnlyConfigProperties = [
+        'endpoints',
+        'db',
+        'editor',
+        'plugins',
+        'sharp'
+    ];
+    serverOnlyConfigProperties.forEach((key)=>{
+        if (key in clientConfig) {
+            delete clientConfig[key];
+        }
     });
+    if ('localization' in clientConfig && clientConfig.localization) {
+        clientConfig.localization = {
+            ...clientConfig.localization
+        };
+        clientConfig.localization.locales.forEach((locale)=>{
+            delete locale.toString;
+        });
+    }
+    if ('admin' in clientConfig) {
+        clientConfig.admin = {
+            ...clientConfig.admin
+        };
+        const serverOnlyAdminProperties = [
+            'components'
+        ];
+        serverOnlyAdminProperties.forEach((key)=>{
+            if (key in clientConfig.admin) {
+                delete clientConfig.admin[key];
+            }
+        });
+    }
     clientConfig.onInit = undefined;
     clientConfig.collections = sanitizeCollections(clientConfig.collections);
     clientConfig.globals = sanitizeGlobals(clientConfig.globals);
     return clientConfig;
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/config/createClientConfig.ts"],"sourcesContent":["import type { Field } from '../fields/config/types'\nimport type { ClientConfig, SanitizedConfig } from './types'\n\nexport const sanitizeField = (f) => {\n  const field = { ...f }\n\n  if ('access' in field) delete field.access\n  if ('hooks' in field) delete field.hooks\n  if ('validate' in field) delete field.validate\n  if ('defaultValue' in field) delete field.defaultValue\n  if ('label' in field) delete field.label\n\n  if ('fields' in field) {\n    field.fields = sanitizeFields(field.fields)\n  }\n\n  if ('editor' in field) {\n    delete field.editor\n  }\n\n  if ('blocks' in field) {\n    field.blocks = field.blocks.map((block) => {\n      const sanitized = { ...block }\n      sanitized.fields = sanitizeFields(sanitized.fields)\n      return sanitized\n    })\n  }\n\n  if ('tabs' in field) {\n    field.tabs = field.tabs.map((tab) => sanitizeField(tab))\n  }\n\n  if ('admin' in field) {\n    field.admin = { ...field.admin }\n\n    if ('components' in field.admin) {\n      delete field.admin.components\n    }\n\n    if ('condition' in field.admin) {\n      delete field.admin.condition\n    }\n\n    if ('description' in field.admin) {\n      delete field.admin.description\n    }\n  }\n\n  return field\n}\n\nconst sanitizeCollections = (\n  collections: SanitizedConfig['collections'],\n): ClientConfig['collections'] =>\n  collections.map((collection) => {\n    const sanitized = { ...collection }\n    sanitized.fields = sanitizeFields(sanitized.fields)\n\n    delete sanitized.hooks\n    delete sanitized.access\n    delete sanitized.endpoints\n\n    if ('editor' in sanitized) delete sanitized.editor\n\n    if ('admin' in sanitized) {\n      sanitized.admin = { ...sanitized.admin }\n\n      if ('components' in sanitized.admin) {\n        delete sanitized.admin.components\n      }\n\n      if ('hidden' in sanitized.admin) {\n        delete sanitized.admin.hidden\n      }\n\n      if ('preview' in sanitized.admin) {\n        delete sanitized.admin.preview\n      }\n    }\n\n    return sanitized\n  })\n\nconst sanitizeGlobals = (globals: SanitizedConfig['globals']): ClientConfig['globals'] =>\n  globals.map((global) => {\n    const sanitized = { ...global }\n    sanitized.fields = sanitizeFields(sanitized.fields)\n    delete sanitized.hooks\n    delete sanitized.access\n    delete sanitized.endpoints\n\n    if ('admin' in sanitized) {\n      sanitized.admin = { ...sanitized.admin }\n\n      if ('components' in sanitized.admin) {\n        delete sanitized.admin.components\n      }\n\n      if ('hidden' in sanitized.admin) {\n        delete sanitized.admin.hidden\n      }\n\n      if ('preview' in sanitized.admin) {\n        delete sanitized.admin.preview\n      }\n    }\n\n    return sanitized\n  })\n\nexport const sanitizeFields = (fields: Field[]): Field[] => fields.map(sanitizeField)\n\nexport const createClientConfig = async (\n  configPromise: Promise<SanitizedConfig> | SanitizedConfig,\n): Promise<ClientConfig> => {\n  const config = await configPromise\n  const clientConfig = { ...config }\n\n  delete clientConfig.endpoints\n  delete clientConfig.db\n  delete clientConfig.editor\n\n  'localization' in clientConfig &&\n    clientConfig.localization &&\n    clientConfig.localization.locales.forEach((locale) => {\n      delete locale.toString\n    })\n\n  clientConfig.onInit = undefined\n\n  clientConfig.collections = sanitizeCollections(clientConfig.collections)\n  clientConfig.globals = sanitizeGlobals(clientConfig.globals)\n\n  return clientConfig\n}\n"],"names":["createClientConfig","sanitizeField","sanitizeFields","f","field","access","hooks","validate","defaultValue","label","fields","editor","blocks","map","block","sanitized","tabs","tab","admin","components","condition","description","sanitizeCollections","collections","collection","endpoints","hidden","preview","sanitizeGlobals","globals","global","configPromise","config","clientConfig","db","localization","locales","forEach","locale","toString","onInit","undefined"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/config/createClientConfig.ts"],"sourcesContent":["import type { SanitizedCollectionConfig, SanitizedGlobalConfig } from '../exports/types.js'\nimport type { Field, FieldBase, RichTextField } from '../fields/config/types.js'\nimport type { ClientConfig, SanitizedConfig } from './types.js'\n\nexport const sanitizeField = (f: Field) => {\n  const field = { ...f }\n\n  const serverOnlyFieldProperties: Partial<keyof FieldBase | keyof RichTextField>[] = [\n    'hooks',\n    'access',\n    'validate',\n    'defaultValue',\n    'label',\n    // This is a `richText` only property\n    'editor',\n    // `fields`\n    // `blocks`\n    // `tabs`\n    // `admin`\n    // are all handled separately\n  ]\n\n  serverOnlyFieldProperties.forEach((key) => {\n    if (key in field) {\n      delete field[key]\n    }\n  })\n\n  if ('fields' in field) {\n    field.fields = sanitizeFields(field.fields)\n  }\n\n  if ('blocks' in field) {\n    field.blocks = field.blocks.map((block) => {\n      const sanitized = { ...block }\n      sanitized.fields = sanitizeFields(sanitized.fields)\n      return sanitized\n    })\n  }\n\n  if ('tabs' in field) {\n    // @ts-expect-error\n    field.tabs = field.tabs.map((tab) => sanitizeField(tab))\n  }\n\n  if ('admin' in field) {\n    field.admin = { ...field.admin }\n\n    const serverOnlyFieldAdminProperties = ['components', 'condition', 'description']\n\n    serverOnlyFieldAdminProperties.forEach((key) => {\n      if (key in field.admin) {\n        delete field.admin[key]\n      }\n    })\n  }\n\n  return field\n}\n\nconst sanitizeCollections = (\n  collections: SanitizedConfig['collections'],\n): ClientConfig['collections'] =>\n  collections.map((collection) => {\n    const sanitized = { ...collection }\n    sanitized.fields = sanitizeFields(sanitized.fields)\n\n    const serverOnlyCollectionProperties: Partial<keyof SanitizedCollectionConfig>[] = [\n      'hooks',\n      'access',\n      'endpoints',\n      // `upload`\n      // `admin`\n      // are all handled separately\n    ]\n\n    serverOnlyCollectionProperties.forEach((key) => {\n      if (key in sanitized) {\n        delete sanitized[key]\n      }\n    })\n\n    if ('upload' in sanitized && typeof sanitized.upload === 'object') {\n      sanitized.upload = { ...sanitized.upload }\n      delete sanitized.upload.handlers\n    }\n\n    if ('admin' in sanitized) {\n      sanitized.admin = { ...sanitized.admin }\n\n      const serverOnlyCollectionAdminProperties: Partial<\n        keyof SanitizedCollectionConfig['admin']\n      >[] = ['components', 'hidden', 'preview']\n\n      serverOnlyCollectionAdminProperties.forEach((key) => {\n        if (key in sanitized.admin) {\n          delete sanitized.admin[key]\n        }\n      })\n    }\n\n    return sanitized\n  })\n\nconst sanitizeGlobals = (globals: SanitizedConfig['globals']): ClientConfig['globals'] =>\n  globals.map((global) => {\n    const sanitized = { ...global }\n    sanitized.fields = sanitizeFields(sanitized.fields)\n\n    const serverOnlyProperties: Partial<keyof SanitizedGlobalConfig>[] = [\n      'hooks',\n      'access',\n      'endpoints',\n      // `admin`\n      // is handled separately\n    ]\n\n    serverOnlyProperties.forEach((key) => {\n      if (key in sanitized) {\n        delete sanitized[key]\n      }\n    })\n\n    if ('admin' in sanitized) {\n      sanitized.admin = { ...sanitized.admin }\n\n      const serverOnlyProperties: Partial<keyof SanitizedGlobalConfig['admin']>[] = [\n        'components',\n        'hidden',\n        'preview',\n      ]\n\n      serverOnlyProperties.forEach((key) => {\n        if (key in sanitized.admin) {\n          delete sanitized.admin[key]\n        }\n      })\n    }\n\n    return sanitized\n  })\n\nexport const sanitizeFields = (fields: Field[]): Field[] => fields.map(sanitizeField)\n\nexport const createClientConfig = async (\n  configPromise: Promise<SanitizedConfig> | SanitizedConfig,\n): Promise<ClientConfig> => {\n  const config = await configPromise\n  const clientConfig = { ...config }\n\n  const serverOnlyConfigProperties: Partial<keyof SanitizedConfig>[] = [\n    'endpoints',\n    'db',\n    'editor',\n    'plugins',\n    'sharp',\n    // `admin`\n    // `onInit`\n    // `localization`\n    // `collections`\n    // `globals`\n    // are all handled separately\n  ]\n\n  serverOnlyConfigProperties.forEach((key) => {\n    if (key in clientConfig) {\n      delete clientConfig[key]\n    }\n  })\n\n  if ('localization' in clientConfig && clientConfig.localization) {\n    clientConfig.localization = { ...clientConfig.localization }\n\n    clientConfig.localization.locales.forEach((locale) => {\n      delete locale.toString\n    })\n  }\n\n  if ('admin' in clientConfig) {\n    clientConfig.admin = { ...clientConfig.admin }\n\n    const serverOnlyAdminProperties: Partial<keyof SanitizedConfig['admin']>[] = ['components']\n\n    serverOnlyAdminProperties.forEach((key) => {\n      if (key in clientConfig.admin) {\n        delete clientConfig.admin[key]\n      }\n    })\n  }\n\n  clientConfig.onInit = undefined\n\n  clientConfig.collections = sanitizeCollections(clientConfig.collections)\n  clientConfig.globals = sanitizeGlobals(clientConfig.globals)\n\n  return clientConfig\n}\n"],"names":["sanitizeField","f","field","serverOnlyFieldProperties","forEach","key","fields","sanitizeFields","blocks","map","block","sanitized","tabs","tab","admin","serverOnlyFieldAdminProperties","sanitizeCollections","collections","collection","serverOnlyCollectionProperties","upload","handlers","serverOnlyCollectionAdminProperties","sanitizeGlobals","globals","global","serverOnlyProperties","createClientConfig","configPromise","config","clientConfig","serverOnlyConfigProperties","localization","locales","locale","toString","serverOnlyAdminProperties","onInit","undefined"],"mappings":"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"}

package/dist/config/defaults.d.ts

@@ -1,3 +1,3 @@
-import type { Config } from './types';
+import type { Config } from './types.js';
 export declare const defaults: Omit<Config, 'db' | 'editor' | 'secret'>;
 //# sourceMappingURL=defaults.d.ts.map

package/dist/config/defaults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/config/defaults.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAErC,eAAO,MAAM,QAAQ,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,GAAG,QAAQ,GAAG,QAAQ,CA2C7D,CAAA"}
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/config/defaults.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC,eAAO,MAAM,QAAQ,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,GAAG,QAAQ,GAAG,QAAQ,CA2C7D,CAAA"}

package/dist/config/defaults.js

@@ -1,23 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "defaults", {
-    enumerable: true,
-    get: function() {
-        return defaults;
-    }
-});
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-const defaults = {
+import path from 'path';
+export const defaults = {
     admin: {
         avatar: 'default',
-        buildPath: _path.default.resolve(process.cwd(), './build'),
+        buildPath: path.resolve(process.cwd(), './build'),
         components: {},
         dateFormat: 'MMMM do yyyy, h:mm a',
         disable: false,
@@ -59,4 +44,4 @@ const defaults = {
     upload: {}
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/config/find.d.ts

@@ -3,6 +3,5 @@
  * @returns The absolute path to the Payload configuration file.
  * @throws An error if no configuration file is found.
  */
-declare const findConfig: () => string;
-export default findConfig;
+export declare const findConfig: () => string;
 //# sourceMappingURL=find.d.ts.map

package/dist/config/find.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../src/config/find.ts"],"names":[],"mappings":"AAmCA;;;;GAIG;AACH,QAAA,MAAM,UAAU,QAAO,MA8DtB,CAAA;AAED,eAAe,UAAU,CAAA"}
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../src/config/find.ts"],"names":[],"mappings":"AAmCA;;;;GAIG;AACH,eAAO,MAAM,UAAU,QAAO,MA8D7B,CAAA"}

package/dist/config/find.js

@@ -1,27 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-const _findup = /*#__PURE__*/ _interop_require_default(require("find-up"));
-const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
+import findUp from 'find-up';
+import fs from 'fs';
+import path from 'path';
 /**
  * Returns the source and output paths from the nearest tsconfig.json file.
  * If no tsconfig.json file is found, returns the current working directory.
  * @returns An object containing the source and output paths.
  */ const getTSConfigPaths = ()=>{
-    const tsConfigPath = _findup.default.sync('tsconfig.json');
+    const tsConfigPath = findUp.sync('tsconfig.json');
     if (!tsConfigPath) {
         return {
             outPath: process.cwd(),
@@ -30,7 +15,7 @@ function _interop_require_default(obj) {
     }
     try {
         // Read the file as a string and remove trailing commas
-        const rawTsConfig = _fs.default.readFileSync(tsConfigPath, 'utf-8').replace(/,\s*\]/g, ']').replace(/,\s*\}/g, '}');
+        const rawTsConfig = fs.readFileSync(tsConfigPath, 'utf-8').replace(/,\s*\]/g, ']').replace(/,\s*\}/g, '}');
         const tsConfig = JSON.parse(rawTsConfig);
         const srcPath = tsConfig.compilerOptions?.rootDir || process.cwd();
         const outPath = tsConfig.compilerOptions?.outDir || process.cwd();
@@ -51,14 +36,14 @@ function _interop_require_default(obj) {
  * Searches for a Payload configuration file.
  * @returns The absolute path to the Payload configuration file.
  * @throws An error if no configuration file is found.
- */ const findConfig = ()=>{
+ */ export const findConfig = ()=>{
     // If the developer has specified a config path,
     // format it if relative and use it directly if absolute
     if (process.env.PAYLOAD_CONFIG_PATH) {
-        if (_path.default.isAbsolute(process.env.PAYLOAD_CONFIG_PATH)) {
+        if (path.isAbsolute(process.env.PAYLOAD_CONFIG_PATH)) {
             return process.env.PAYLOAD_CONFIG_PATH;
         }
-        return _path.default.resolve(process.cwd(), process.env.PAYLOAD_CONFIG_PATH);
+        return path.resolve(process.cwd(), process.env.PAYLOAD_CONFIG_PATH);
     }
     const { outPath, srcPath } = getTSConfigPaths();
     const searchPaths = process.env.NODE_ENV === 'production' ? [
@@ -69,14 +54,14 @@ function _interop_require_default(obj) {
     ];
     // eslint-disable-next-line no-restricted-syntax
     for (const searchPath of searchPaths){
-        const configPath = _findup.default.sync((dir)=>{
-            const tsPath = _path.default.join(dir, 'payload.config.ts');
-            const hasTS = _findup.default.sync.exists(tsPath);
+        const configPath = findUp.sync((dir)=>{
+            const tsPath = path.join(dir, 'payload.config.ts');
+            const hasTS = findUp.sync.exists(tsPath);
             if (hasTS) {
                 return tsPath;
             }
-            const jsPath = _path.default.join(dir, 'payload.config.js');
-            const hasJS = _findup.default.sync.exists(jsPath);
+            const jsPath = path.join(dir, 'payload.config.js');
+            const hasJS = findUp.sync.exists(jsPath);
             if (hasJS) {
                 return jsPath;
             }
@@ -91,24 +76,23 @@ function _interop_require_default(obj) {
     // If no config file is found in the directories defined by tsconfig.json,
     // try searching in the 'src' and 'dist' directory as a last resort, as they are most commonly used
     if (process.env.NODE_ENV === 'production') {
-        const distConfigPath = _findup.default.sync([
+        const distConfigPath = findUp.sync([
             'payload.config.js',
             'payload.config.ts'
         ], {
-            cwd: _path.default.resolve(process.cwd(), 'dist')
+            cwd: path.resolve(process.cwd(), 'dist')
         });
         if (distConfigPath) return distConfigPath;
     } else {
-        const srcConfigPath = _findup.default.sync([
+        const srcConfigPath = findUp.sync([
             'payload.config.js',
             'payload.config.ts'
         ], {
-            cwd: _path.default.resolve(process.cwd(), 'src')
+            cwd: path.resolve(process.cwd(), 'src')
         });
         if (srcConfigPath) return srcConfigPath;
     }
     throw new Error('Error: cannot find Payload config. Please create a configuration file located at the root of your current working directory called "payload.config.js" or "payload.config.ts".');
 };
-const _default = findConfig;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/config/load.d.ts

@@ -1,6 +1,6 @@
 import type pino from 'pino';
-import type { SanitizedConfig } from './types';
-import Logger from '../utilities/logger';
+import type { SanitizedConfig } from './types.js';
+import Logger from '../utilities/logger.js';
 declare const loadConfig: (logger?: pino.Logger) => Promise<SanitizedConfig>;
 export default loadConfig;
 //# sourceMappingURL=load.d.ts.map

package/dist/config/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/config/load.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAA;AAK5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,MAAM,MAAM,qBAAqB,CAAA;AAKxC,QAAA,MAAM,UAAU,YAAmB,WAAW,KAAG,QAAQ,eAAe,CA4BvE,CAAA;AAED,eAAe,UAAU,CAAA"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/config/load.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAA;AAO5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAGjD,OAAO,MAAM,MAAM,wBAAwB,CAAA;AAM3C,QAAA,MAAM,UAAU,YAAmB,WAAW,KAAG,QAAQ,eAAe,CA2BvE,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/config/load.js

@@ -1,45 +1,32 @@
-/* eslint-disable import/no-dynamic-require */ /* eslint-disable global-require */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _logger = /*#__PURE__*/ _interop_require_default(require("../utilities/logger"));
-const _clientFiles = require("./clientFiles");
-const _find = /*#__PURE__*/ _interop_require_default(require("./find"));
-const _validate = /*#__PURE__*/ _interop_require_default(require("./validate"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
+/* eslint-disable import/no-dynamic-require */ /* eslint-disable global-require */ import { createRequire } from 'module';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import path from 'path';
+import { CLIENT_EXTENSIONS } from '../bin/register/clientExtensions.js';
+import Logger from '../utilities/logger.js';
+import { findConfig } from './find.js';
+import validate from './validate.js';
+const require = createRequire(import.meta.url);
 const loadConfig = async (logger)=>{
-    const localLogger = logger ?? (0, _logger.default)();
-    const configPath = (0, _find.default)();
-    _clientFiles.clientFiles.forEach((ext)=>{
+    const localLogger = logger ?? Logger();
+    const configPath = findConfig();
+    CLIENT_EXTENSIONS.forEach((ext)=>{
         require.extensions[ext] = ()=>null;
     });
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const configPromise = require(configPath);
+    const configPromise = await import(configPath);
     let config = await configPromise;
-    if (config.default) config = await config.default;
+    if ('default' in config) config = await config.default;
     if (process.env.NODE_ENV !== 'production') {
-        config = await (0, _validate.default)(config, localLogger);
+        config = await validate(config, localLogger);
     }
     return {
         ...config,
         paths: {
             config: configPath,
-            configDir: _path.default.dirname(configPath),
+            configDir: path.dirname(configPath),
             rawConfig: configPath
         }
     };
 };
-const _default = loadConfig;
+export default loadConfig;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/config/sanitize.d.ts

@@ -1,3 +1,3 @@
-import type { Config, SanitizedConfig } from './types';
+import type { Config, SanitizedConfig } from './types.js';
 export declare const sanitizeConfig: (incomingConfig: Config) => SanitizedConfig;
 //# sourceMappingURL=sanitize.d.ts.map

package/dist/config/sanitize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/config/sanitize.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,MAAM,EAGN,eAAe,EAChB,MAAM,SAAS,CAAA;AAkChB,eAAO,MAAM,cAAc,mBAAoB,MAAM,KAAG,eAoEvD,CAAA"}
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/config/sanitize.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,MAAM,EAGN,eAAe,EAChB,MAAM,YAAY,CAAA;AAmCnB,eAAO,MAAM,cAAc,mBAAoB,MAAM,KAAG,eAoEvD,CAAA"}