@payloadcms/next 3.0.0-alpha.0

package/dist/pages/Document/index.js

@@ -0,0 +1,237 @@
+"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, {
+    Document: function() {
+        return Document;
+    },
+    generateMetadata: function() {
+        return generateMetadata;
+    }
+});
+const _ui = require("@payloadcms/ui");
+const _navigation = require("next/navigation");
+const _qs = /*#__PURE__*/ _interop_require_default(require("qs"));
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _initPage = require("../../utilities/initPage");
+const _getMetaBySegmenttsx = require("./getMetaBySegment.tsx");
+const _getViewsFromConfig = require("./getViewsFromConfig");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const generateMetadata = async (args)=>(0, _getMetaBySegmenttsx.getMetaBySegment)(args);
+const Document = async ({ config: configPromise, params, searchParams })=>{
+    const collectionSlug = params.collection;
+    const globalSlug = params.global;
+    const isCreating = params.segments?.length === 1 && params.segments?.[0] === 'create';
+    const id = collectionSlug && !isCreating && params.segments[0] || undefined;
+    const isEditing = Boolean(globalSlug || collectionSlug && !!id);
+    const route = `/${collectionSlug || globalSlug + (params.segments?.length ? `/${params.segments.join('/')}` : '')}`;
+    const { collectionConfig, globalConfig, locale, permissions, req } = await (0, _initPage.initPage)({
+        collectionSlug,
+        config: configPromise,
+        globalSlug,
+        redirectUnauthenticatedUser: true,
+        route,
+        searchParams
+    });
+    if (!collectionConfig && !globalConfig) {
+        return (0, _navigation.notFound)();
+    }
+    const { i18n, payload, payload: { config }, user } = req;
+    const { routes: { api }, serverURL } = config;
+    let CustomView;
+    let DefaultView;
+    let data;
+    let docPermissions;
+    let preferencesKey;
+    let fields;
+    let hasSavePermission;
+    let apiURL;
+    let action;
+    if (collectionConfig) {
+        docPermissions = permissions?.collections?.[collectionSlug];
+        fields = collectionConfig.fields;
+        action = `${serverURL}${api}/${collectionSlug}${isEditing ? `/${id}` : ''}`;
+        hasSavePermission = isEditing && permissions?.collections?.[collectionSlug]?.update?.permission || !isEditing && permissions?.collections?.[collectionSlug]?.create?.permission;
+        apiURL = `${serverURL}${api}/${collectionSlug}/${id}?locale=${locale.code}${collectionConfig.versions?.drafts ? '&draft=true' : ''}`;
+        const collectionViews = await (0, _getViewsFromConfig.getViewsFromConfig)({
+            collectionConfig,
+            config,
+            docPermissions,
+            routeSegments: params.segments,
+            user
+        });
+        CustomView = collectionViews?.CustomView;
+        DefaultView = collectionViews?.DefaultView;
+        if (!CustomView && !DefaultView) {
+            return (0, _navigation.notFound)();
+        }
+        try {
+            data = await payload.findByID({
+                id,
+                collection: collectionSlug,
+                depth: 0,
+                locale: locale.code,
+                user
+            });
+        } catch (error) {}
+        if (id) {
+            preferencesKey = `collection-${collectionSlug}-${id}`;
+        }
+    }
+    if (globalConfig) {
+        docPermissions = permissions?.globals?.[globalSlug];
+        fields = globalConfig.fields;
+        hasSavePermission = isEditing && docPermissions?.update?.permission;
+        action = `${serverURL}${api}/${globalSlug}`;
+        apiURL = `${serverURL}${api}/${globalSlug}?locale=${locale.code}${globalConfig.versions?.drafts ? '&draft=true' : ''}`;
+        const globalViews = await (0, _getViewsFromConfig.getViewsFromConfig)({
+            config,
+            docPermissions,
+            globalConfig,
+            routeSegments: params.segments,
+            user
+        });
+        CustomView = globalViews?.CustomView;
+        DefaultView = globalViews?.DefaultView;
+        if (!CustomView && !DefaultView) {
+            return (0, _navigation.notFound)();
+        }
+        data = await payload.findGlobal({
+            slug: globalSlug,
+            depth: 0,
+            locale: locale.code,
+            user
+        });
+        preferencesKey = `global-${globalSlug}`;
+    }
+    const { docs: [{ value: docPreferences } = {
+        value: null
+    }] = [] } = await payload.find({
+        collection: 'payload-preferences',
+        depth: 0,
+        limit: 1,
+        where: {
+            key: {
+                equals: preferencesKey
+            }
+        }
+    });
+    const initialState = await (0, _ui.buildStateFromSchema)({
+        id,
+        data: data || {},
+        fieldSchema: (0, _ui.formatFields)(fields, isEditing),
+        operation: isEditing ? 'update' : 'create',
+        preferences: docPreferences,
+        req
+    });
+    const formQueryParams = {
+        depth: 0,
+        'fallback-locale': 'null',
+        locale: locale.code,
+        uploadEdits: undefined
+    };
+    const componentProps = {
+        id,
+        action: `${action}?${_qs.default.stringify(formQueryParams)}`,
+        apiURL,
+        canAccessAdmin: permissions?.canAccessAdmin,
+        collectionConfig,
+        collectionSlug,
+        config,
+        data,
+        docPermissions,
+        docPreferences,
+        globalConfig,
+        globalSlug,
+        hasSavePermission,
+        i18n,
+        initialState,
+        isEditing,
+        locale,
+        params,
+        payload,
+        permissions,
+        searchParams,
+        updatedAt: data?.updatedAt?.toString(),
+        user
+    };
+    return /*#__PURE__*/ _react.default.createElement(_react.Fragment, null, /*#__PURE__*/ _react.default.createElement(_ui.HydrateClientUser, {
+        permissions: permissions,
+        user: user
+    }), /*#__PURE__*/ _react.default.createElement(_ui.SetDocumentInfo, {
+        action: action,
+        apiURL: apiURL,
+        collectionSlug: collectionConfig?.slug,
+        disableActions: false,
+        docPermissions: docPermissions,
+        docPreferences: docPreferences,
+        globalSlug: globalConfig?.slug,
+        hasSavePermission: hasSavePermission,
+        id: id,
+        initialData: data,
+        initialState: initialState
+    }), /*#__PURE__*/ _react.default.createElement(_ui.EditDepthProvider, {
+        depth: 1,
+        key: `${collectionSlug || globalSlug}-${locale.code}`
+    }, /*#__PURE__*/ _react.default.createElement(_ui.FormQueryParamsProvider, {
+        formQueryParams: formQueryParams
+    }, /*#__PURE__*/ _react.default.createElement(_ui.RenderCustomComponent, {
+        CustomComponent: typeof CustomView === 'function' ? CustomView : undefined,
+        DefaultComponent: DefaultView,
+        componentProps: componentProps
+    }))));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/pages/Document/index.tsx"],"sourcesContent":["import type { QueryParamTypes } from '@payloadcms/ui'\nimport type { AdminViewComponent } from 'payload/config'\nimport type {\n  DocumentPreferences,\n  Document as DocumentType,\n  Field,\n  SanitizedConfig,\n} from 'payload/types'\nimport type { DocumentPermissions } from 'payload/types'\n\nimport {\n  EditDepthProvider,\n  FormQueryParamsProvider,\n  HydrateClientUser,\n  RenderCustomComponent,\n  SetDocumentInfo,\n  buildStateFromSchema,\n  formatFields,\n} from '@payloadcms/ui'\nimport { notFound } from 'next/navigation'\nimport queryString from 'qs'\nimport React, { Fragment } from 'react'\n\nimport type { ServerSideEditViewProps } from '../Edit/types'\n\nimport { initPage } from '../../utilities/initPage'\nimport { getMetaBySegment } from './getMetaBySegment.tsx'\nimport { getViewsFromConfig } from './getViewsFromConfig'\n\nexport const generateMetadata = async (args: {\n  config: Promise<SanitizedConfig>\n  params: {\n    collection?: string\n    global?: string\n    segments: string[]\n  }\n}) => getMetaBySegment(args)\n\nexport const Document = async ({\n  config: configPromise,\n  params,\n  searchParams,\n}: {\n  config: Promise<SanitizedConfig> | SanitizedConfig\n  params: {\n    collection?: string\n    global?: string\n    segments: string[]\n  }\n  searchParams: { [key: string]: string | string[] | undefined }\n}) => {\n  const collectionSlug = params.collection\n  const globalSlug = params.global\n  const isCreating = params.segments?.length === 1 && params.segments?.[0] === 'create'\n  const id = (collectionSlug && !isCreating && params.segments[0]) || undefined\n\n  const isEditing = Boolean(globalSlug || (collectionSlug && !!id))\n\n  const route = `/${collectionSlug || globalSlug + (params.segments?.length ? `/${params.segments.join('/')}` : '')}`\n\n  const { collectionConfig, globalConfig, locale, permissions, req } = await initPage({\n    collectionSlug,\n    config: configPromise,\n    globalSlug,\n    redirectUnauthenticatedUser: true,\n    route,\n    searchParams,\n  })\n\n  if (!collectionConfig && !globalConfig) {\n    return notFound()\n  }\n\n  const {\n    i18n,\n    payload,\n    payload: { config },\n    user,\n  } = req\n\n  const {\n    routes: { api },\n    serverURL,\n  } = config\n\n  let CustomView: SanitizedConfig['admin']['components']['views'][0]\n  let DefaultView: AdminViewComponent\n  let data: DocumentType\n  let docPermissions: DocumentPermissions\n  let preferencesKey: string\n  let fields: Field[]\n  let hasSavePermission: boolean\n  let apiURL: string\n  let action: string\n\n  if (collectionConfig) {\n    docPermissions = permissions?.collections?.[collectionSlug]\n    fields = collectionConfig.fields\n    action = `${serverURL}${api}/${collectionSlug}${isEditing ? `/${id}` : ''}`\n\n    hasSavePermission =\n      (isEditing && permissions?.collections?.[collectionSlug]?.update?.permission) ||\n      (!isEditing && permissions?.collections?.[collectionSlug]?.create?.permission)\n\n    apiURL = `${serverURL}${api}/${collectionSlug}/${id}?locale=${locale.code}${\n      collectionConfig.versions?.drafts ? '&draft=true' : ''\n    }`\n\n    const collectionViews = await getViewsFromConfig({\n      collectionConfig,\n      config,\n      docPermissions,\n      routeSegments: params.segments,\n      user,\n    })\n\n    CustomView = collectionViews?.CustomView\n    DefaultView = collectionViews?.DefaultView\n\n    if (!CustomView && !DefaultView) {\n      return notFound()\n    }\n\n    try {\n      data = await payload.findByID({\n        id,\n        collection: collectionSlug,\n        depth: 0,\n        locale: locale.code,\n        user,\n      })\n    } catch (error) {}\n\n    if (id) {\n      preferencesKey = `collection-${collectionSlug}-${id}`\n    }\n  }\n\n  if (globalConfig) {\n    docPermissions = permissions?.globals?.[globalSlug]\n    fields = globalConfig.fields\n    hasSavePermission = isEditing && docPermissions?.update?.permission\n    action = `${serverURL}${api}/${globalSlug}`\n\n    apiURL = `${serverURL}${api}/${globalSlug}?locale=${locale.code}${\n      globalConfig.versions?.drafts ? '&draft=true' : ''\n    }`\n\n    const globalViews = await getViewsFromConfig({\n      config,\n      docPermissions,\n      globalConfig,\n      routeSegments: params.segments,\n      user,\n    })\n\n    CustomView = globalViews?.CustomView\n    DefaultView = globalViews?.DefaultView\n\n    if (!CustomView && !DefaultView) {\n      return notFound()\n    }\n\n    data = await payload.findGlobal({\n      slug: globalSlug,\n      depth: 0,\n      locale: locale.code,\n      user,\n    })\n\n    preferencesKey = `global-${globalSlug}`\n  }\n\n  const { docs: [{ value: docPreferences } = { value: null }] = [] } = (await payload.find({\n    collection: 'payload-preferences',\n    depth: 0,\n    limit: 1,\n    where: {\n      key: {\n        equals: preferencesKey,\n      },\n    },\n  })) as any as { docs: { value: DocumentPreferences }[] }\n\n  const initialState = await buildStateFromSchema({\n    id,\n    data: data || {},\n    fieldSchema: formatFields(fields, isEditing),\n    operation: isEditing ? 'update' : 'create',\n    preferences: docPreferences,\n    req,\n  })\n\n  const formQueryParams: QueryParamTypes = {\n    depth: 0,\n    'fallback-locale': 'null',\n    locale: locale.code,\n    uploadEdits: undefined,\n  }\n\n  const componentProps: ServerSideEditViewProps = {\n    id,\n    action: `${action}?${queryString.stringify(formQueryParams)}`,\n    apiURL,\n    canAccessAdmin: permissions?.canAccessAdmin,\n    collectionConfig,\n    collectionSlug,\n    config,\n    data,\n    docPermissions,\n    docPreferences,\n    globalConfig,\n    globalSlug,\n    hasSavePermission,\n    i18n,\n    initialState,\n    isEditing,\n    locale,\n    params,\n    payload,\n    permissions,\n    searchParams,\n    updatedAt: data?.updatedAt?.toString(),\n    user,\n  }\n\n  return (\n    <Fragment>\n      <HydrateClientUser permissions={permissions} user={user} />\n      <SetDocumentInfo\n        action={action}\n        apiURL={apiURL}\n        collectionSlug={collectionConfig?.slug}\n        disableActions={false}\n        docPermissions={docPermissions}\n        docPreferences={docPreferences}\n        globalSlug={globalConfig?.slug}\n        hasSavePermission={hasSavePermission}\n        id={id}\n        initialData={data}\n        initialState={initialState}\n      />\n      <EditDepthProvider depth={1} key={`${collectionSlug || globalSlug}-${locale.code}`}>\n        <FormQueryParamsProvider formQueryParams={formQueryParams}>\n          <RenderCustomComponent\n            CustomComponent={typeof CustomView === 'function' ? CustomView : undefined}\n            DefaultComponent={DefaultView}\n            componentProps={componentProps}\n          />\n        </FormQueryParamsProvider>\n      </EditDepthProvider>\n    </Fragment>\n  )\n}\n"],"names":["Document","generateMetadata","args","getMetaBySegment","config","configPromise","params","searchParams","collectionSlug","collection","globalSlug","global","isCreating","segments","length","id","undefined","isEditing","Boolean","route","join","collectionConfig","globalConfig","locale","permissions","req","initPage","redirectUnauthenticatedUser","notFound","i18n","payload","user","routes","api","serverURL","CustomView","DefaultView","data","docPermissions","preferencesKey","fields","hasSavePermission","apiURL","action","collections","update","permission","create","code","versions","drafts","collectionViews","getViewsFromConfig","routeSegments","findByID","depth","error","globals","globalViews","findGlobal","slug","docs","value","docPreferences","find","limit","where","key","equals","initialState","buildStateFromSchema","fieldSchema","formatFields","operation","preferences","formQueryParams","uploadEdits","componentProps","queryString","stringify","canAccessAdmin","updatedAt","toString","Fragment","HydrateClientUser","SetDocumentInfo","disableActions","initialData","EditDepthProvider","FormQueryParamsProvider","RenderCustomComponent","CustomComponent","DefaultComponent"],"mappings":"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"}

package/dist/pages/Edit/Default/Auth/APIKey.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare const APIKey: React.FC<{
+    readOnly?: boolean;
+}>;
+export default APIKey;
+//# sourceMappingURL=APIKey.d.ts.map

package/dist/pages/Edit/Default/Auth/APIKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APIKey.d.ts","sourceRoot":"","sources":["../../../../../src/pages/Edit/Default/Auth/APIKey.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAuC,MAAM,OAAO,CAAA;AAM3D,QAAA,MAAM,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAkF5C,CAAA;AAED,eAAe,MAAM,CAAA"}

package/dist/pages/Edit/Default/Auth/APIKey.js

@@ -0,0 +1,140 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _ui = require("@payloadcms/ui");
+const _validations = require("payload/fields/validations");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _uuid = require("uuid");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const path = 'apiKey';
+const baseClass = 'api-key';
+const APIKey = ({ readOnly })=>{
+    const [initialAPIKey, setInitialAPIKey] = (0, _react.useState)(null);
+    const [highlightedField, setHighlightedField] = (0, _react.useState)(false);
+    const { t } = (0, _ui.useTranslation)();
+    const apiKey = (0, _ui.useFormFields)(([fields])=>fields[path]);
+    const validate = (val)=>(0, _validations.text)(val, {
+            name: 'apiKey',
+            type: 'text',
+            data: {},
+            maxLength: 48,
+            minLength: 24,
+            req: {
+                t
+            },
+            siblingData: {}
+        });
+    const apiKeyValue = apiKey?.value;
+    const APIKeyLabel = (0, _react.useMemo)(()=>/*#__PURE__*/ _react.default.createElement("div", {
+            className: `${baseClass}__label`
+        }, /*#__PURE__*/ _react.default.createElement("span", null, "API Key"), /*#__PURE__*/ _react.default.createElement(_ui.CopyToClipboard, {
+            value: apiKeyValue
+        })), [
+        apiKeyValue
+    ]);
+    const fieldType = (0, _ui.useField)({
+        path: 'apiKey',
+        validate
+    });
+    const highlightField = ()=>{
+        if (highlightedField) {
+            setHighlightedField(false);
+        }
+        setTimeout(()=>{
+            setHighlightedField(true);
+        }, 1);
+    };
+    const { setValue, value } = fieldType;
+    (0, _react.useEffect)(()=>{
+        setInitialAPIKey((0, _uuid.v4)());
+    }, []);
+    (0, _react.useEffect)(()=>{
+        if (!apiKeyValue) {
+            setValue(initialAPIKey);
+        }
+    }, [
+        apiKeyValue,
+        setValue,
+        initialAPIKey
+    ]);
+    (0, _react.useEffect)(()=>{
+        if (highlightedField) {
+            setTimeout(()=>{
+                setHighlightedField(false);
+            }, 10000);
+        }
+    }, [
+        highlightedField
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement("div", {
+        className: [
+            _ui.fieldBaseClass,
+            'api-key',
+            'read-only'
+        ].filter(Boolean).join(' ')
+    }, /*#__PURE__*/ _react.default.createElement(_ui.Label, {
+        htmlFor: path,
+        label: APIKeyLabel
+    }), /*#__PURE__*/ _react.default.createElement("input", {
+        className: highlightedField ? 'highlight' : undefined,
+        disabled: true,
+        id: "apiKey",
+        name: "apiKey",
+        type: "text",
+        value: value || ''
+    })), !readOnly && /*#__PURE__*/ _react.default.createElement(_ui.GenerateConfirmation, {
+        highlightField: highlightField,
+        setKey: ()=>setValue((0, _uuid.v4)())
+    }));
+};
+const _default = APIKey;
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/pages/Edit/Default/Auth/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { Props } from './types';
+import './index.scss';
+declare const Auth: React.FC<Props>;
+export default Auth;
+//# sourceMappingURL=index.d.ts.map

package/dist/pages/Edit/Default/Auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/pages/Edit/Default/Auth/index.tsx"],"names":[],"mappings":"AAYA,OAAO,KAA2C,MAAM,OAAO,CAAA;AAG/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAGpC,OAAO,cAAc,CAAA;AAIrB,QAAA,MAAM,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CA8IzB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/pages/Edit/Default/Auth/index.js

@@ -0,0 +1,180 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _ui = require("@payloadcms/ui");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacttoastify = require("react-toastify");
+const _APIKey = /*#__PURE__*/ _interop_require_default(require("./APIKey"));
+require("./index.scss");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'auth-fields';
+const Auth = (props)=>{
+    const { className, collectionSlug, disableLocalStrategy, email, operation, readOnly, requirePassword, useAPIKey, verify } = props;
+    const [changingPassword, setChangingPassword] = (0, _react.useState)(requirePassword);
+    const enableAPIKey = (0, _ui.useFormFields)(([fields])=>fields.enableAPIKey);
+    const dispatchFields = (0, _ui.useFormFields)((reducer)=>reducer[1]);
+    const modified = (0, _ui.useFormModified)();
+    const { i18n, t } = (0, _ui.useTranslation)();
+    const { routes: { api }, serverURL } = (0, _ui.useConfig)();
+    const handleChangePassword = (0, _react.useCallback)(async (state)=>{
+        if (!state) {
+            dispatchFields({
+                path: 'password',
+                type: 'REMOVE'
+            });
+            dispatchFields({
+                path: 'confirm-password',
+                type: 'REMOVE'
+            });
+        }
+        setChangingPassword(state);
+    }, [
+        dispatchFields
+    ]);
+    const unlock = (0, _react.useCallback)(async ()=>{
+        const url = `${serverURL}${api}/${collectionSlug}/unlock`;
+        const response = await fetch(url, {
+            body: JSON.stringify({
+                email
+            }),
+            credentials: 'include',
+            headers: {
+                'Accept-Language': i18n.language,
+                'Content-Type': 'application/json'
+            },
+            method: 'post'
+        });
+        if (response.status === 200) {
+            _reacttoastify.toast.success(t('authentication:successfullyUnlocked'), {
+                autoClose: 3000
+            });
+        } else {
+            _reacttoastify.toast.error(t('authentication:failedToUnlock'));
+        }
+    }, [
+        i18n,
+        serverURL,
+        api,
+        collectionSlug,
+        email,
+        t
+    ]);
+    (0, _react.useEffect)(()=>{
+        if (!modified) {
+            setChangingPassword(false);
+        }
+    }, [
+        modified
+    ]);
+    if (disableLocalStrategy && !useAPIKey) {
+        return null;
+    }
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: [
+            baseClass,
+            className
+        ].filter(Boolean).join(' ')
+    }, !disableLocalStrategy && /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement(_ui.Email, {
+        autoComplete: "email",
+        label: t('general:email'),
+        name: "email",
+        readOnly: readOnly,
+        required: true
+    }), (changingPassword || requirePassword) && /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__changing-password`
+    }, /*#__PURE__*/ _react.default.createElement(_ui.Password, {
+        autoComplete: "off",
+        disabled: readOnly,
+        label: t('authentication:newPassword'),
+        name: "password",
+        required: true
+    }), /*#__PURE__*/ _react.default.createElement(_ui.ConfirmPassword, {
+        disabled: readOnly
+    }), !requirePassword && /*#__PURE__*/ _react.default.createElement(_ui.Button, {
+        buttonStyle: "secondary",
+        disabled: readOnly,
+        onClick: ()=>handleChangePassword(false),
+        size: "small"
+    }, t('general:cancel'))), (!changingPassword && !requirePassword || operation === 'update') && /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__controls`
+    }, !changingPassword && !requirePassword && /*#__PURE__*/ _react.default.createElement(_ui.Button, {
+        buttonStyle: "secondary",
+        disabled: readOnly,
+        id: "change-password",
+        onClick: ()=>handleChangePassword(true),
+        size: "small"
+    }, t('authentication:changePassword')), operation === 'update' && /*#__PURE__*/ _react.default.createElement(_ui.Button, {
+        buttonStyle: "secondary",
+        disabled: readOnly,
+        onClick: ()=>unlock(),
+        size: "small"
+    }, t('authentication:forceUnlock')))), useAPIKey && /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__api-key`
+    }, /*#__PURE__*/ _react.default.createElement(_ui.Checkbox, {
+        label: t('authentication:enableAPIKey'),
+        name: "enableAPIKey",
+        readOnly: readOnly
+    }), enableAPIKey?.value && /*#__PURE__*/ _react.default.createElement(_APIKey.default, {
+        readOnly: readOnly
+    })), verify && /*#__PURE__*/ _react.default.createElement(_ui.Checkbox, {
+        label: t('authentication:verified'),
+        name: "_verified",
+        readOnly: readOnly
+    }));
+};
+const _default = Auth;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/pages/Edit/Default/Auth/index.tsx"],"sourcesContent":["'use client'\nimport {\n  Button,\n  Checkbox,\n  ConfirmPassword,\n  Email,\n  Password,\n  useConfig,\n  useFormFields,\n  useFormModified,\n  useTranslation,\n} from '@payloadcms/ui'\nimport React, { useCallback, useEffect, useState } from 'react'\nimport { toast } from 'react-toastify'\n\nimport type { Props } from './types'\n\nimport APIKey from './APIKey'\nimport './index.scss'\n\nconst baseClass = 'auth-fields'\n\nconst Auth: React.FC<Props> = (props) => {\n  const {\n    className,\n    collectionSlug,\n    disableLocalStrategy,\n    email,\n    operation,\n    readOnly,\n    requirePassword,\n    useAPIKey,\n    verify,\n  } = props\n\n  const [changingPassword, setChangingPassword] = useState(requirePassword)\n  const enableAPIKey = useFormFields(([fields]) => fields.enableAPIKey)\n  const dispatchFields = useFormFields((reducer) => reducer[1])\n  const modified = useFormModified()\n  const { i18n, t } = useTranslation()\n\n  const {\n    routes: { api },\n    serverURL,\n  } = useConfig()\n\n  const handleChangePassword = useCallback(\n    async (state: boolean) => {\n      if (!state) {\n        dispatchFields({ path: 'password', type: 'REMOVE' })\n        dispatchFields({ path: 'confirm-password', type: 'REMOVE' })\n      }\n\n      setChangingPassword(state)\n    },\n    [dispatchFields],\n  )\n\n  const unlock = useCallback(async () => {\n    const url = `${serverURL}${api}/${collectionSlug}/unlock`\n    const response = await fetch(url, {\n      body: JSON.stringify({\n        email,\n      }),\n      credentials: 'include',\n      headers: {\n        'Accept-Language': i18n.language,\n        'Content-Type': 'application/json',\n      },\n      method: 'post',\n    })\n\n    if (response.status === 200) {\n      toast.success(t('authentication:successfullyUnlocked'), { autoClose: 3000 })\n    } else {\n      toast.error(t('authentication:failedToUnlock'))\n    }\n  }, [i18n, serverURL, api, collectionSlug, email, t])\n\n  useEffect(() => {\n    if (!modified) {\n      setChangingPassword(false)\n    }\n  }, [modified])\n\n  if (disableLocalStrategy && !useAPIKey) {\n    return null\n  }\n\n  return (\n    <div className={[baseClass, className].filter(Boolean).join(' ')}>\n      {!disableLocalStrategy && (\n        <React.Fragment>\n          <Email\n            autoComplete=\"email\"\n            label={t('general:email')}\n            name=\"email\"\n            readOnly={readOnly}\n            required\n          />\n          {(changingPassword || requirePassword) && (\n            <div className={`${baseClass}__changing-password`}>\n              <Password\n                autoComplete=\"off\"\n                disabled={readOnly}\n                label={t('authentication:newPassword')}\n                name=\"password\"\n                required\n              />\n              <ConfirmPassword disabled={readOnly} />\n              {!requirePassword && (\n                <Button\n                  buttonStyle=\"secondary\"\n                  disabled={readOnly}\n                  onClick={() => handleChangePassword(false)}\n                  size=\"small\"\n                >\n                  {t('general:cancel')}\n                </Button>\n              )}\n            </div>\n          )}\n          {((!changingPassword && !requirePassword) || operation === 'update') && (\n            <div className={`${baseClass}__controls`}>\n              {!changingPassword && !requirePassword && (\n                <Button\n                  buttonStyle=\"secondary\"\n                  disabled={readOnly}\n                  id=\"change-password\"\n                  onClick={() => handleChangePassword(true)}\n                  size=\"small\"\n                >\n                  {t('authentication:changePassword')}\n                </Button>\n              )}\n              {operation === 'update' && (\n                <Button\n                  buttonStyle=\"secondary\"\n                  disabled={readOnly}\n                  onClick={() => unlock()}\n                  size=\"small\"\n                >\n                  {t('authentication:forceUnlock')}\n                </Button>\n              )}\n            </div>\n          )}\n        </React.Fragment>\n      )}\n      {useAPIKey && (\n        <div className={`${baseClass}__api-key`}>\n          <Checkbox\n            label={t('authentication:enableAPIKey')}\n            name=\"enableAPIKey\"\n            readOnly={readOnly}\n          />\n          {enableAPIKey?.value && <APIKey readOnly={readOnly} />}\n        </div>\n      )}\n      {verify && (\n        <Checkbox label={t('authentication:verified')} name=\"_verified\" readOnly={readOnly} />\n      )}\n    </div>\n  )\n}\n\nexport default Auth\n"],"names":["baseClass","Auth","props","className","collectionSlug","disableLocalStrategy","email","operation","readOnly","requirePassword","useAPIKey","verify","changingPassword","setChangingPassword","useState","enableAPIKey","useFormFields","fields","dispatchFields","reducer","modified","useFormModified","i18n","t","useTranslation","routes","api","serverURL","useConfig","handleChangePassword","useCallback","state","path","type","unlock","url","response","fetch","body","JSON","stringify","credentials","headers","language","method","status","toast","success","autoClose","error","useEffect","div","filter","Boolean","join","React","Fragment","Email","autoComplete","label","name","required","Password","disabled","ConfirmPassword","Button","buttonStyle","onClick","size","id","Checkbox","value","APIKey"],"mappings":"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"}