payload 1.15.7 → 1.15.9

package/packages/payload/dist/admin/components/utilities/Theme/index.js

@@ -0,0 +1,114 @@
+"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, {
+    ThemeProvider: function() {
+        return ThemeProvider;
+    },
+    default: function() {
+        return _default;
+    },
+    useTheme: function() {
+        return useTheme;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+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 initialContext = {
+    autoMode: true,
+    setTheme: ()=>null,
+    theme: 'light'
+};
+const Context = /*#__PURE__*/ (0, _react.createContext)(initialContext);
+const localStorageKey = 'payload-theme';
+const getTheme = ()=>{
+    let theme;
+    const themeFromStorage = window.localStorage.getItem(localStorageKey);
+    if (themeFromStorage === 'light' || themeFromStorage === 'dark') {
+        theme = themeFromStorage;
+    } else {
+        theme = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+    }
+    document.documentElement.setAttribute('data-theme', theme);
+    return theme;
+};
+const ThemeProvider = ({ children })=>{
+    const [theme, setThemeState] = (0, _react.useState)(getTheme);
+    const [autoMode, setAutoMode] = (0, _react.useState)(()=>{
+        const themeFromStorage = window.localStorage.getItem(localStorageKey);
+        return !themeFromStorage;
+    });
+    const setTheme = (0, _react.useCallback)((themeToSet)=>{
+        if (themeToSet === 'light' || themeToSet === 'dark') {
+            setThemeState(themeToSet);
+            setAutoMode(false);
+            window.localStorage.setItem(localStorageKey, themeToSet);
+            document.documentElement.setAttribute('data-theme', themeToSet);
+        } else if (themeToSet === 'auto') {
+            const existingThemeFromStorage = window.localStorage.getItem(localStorageKey);
+            if (existingThemeFromStorage) window.localStorage.removeItem(localStorageKey);
+            const themeFromOS = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+            document.documentElement.setAttribute('data-theme', themeFromOS);
+            setAutoMode(true);
+            setThemeState(themeFromOS);
+        }
+    }, []);
+    return /*#__PURE__*/ _react.default.createElement(Context.Provider, {
+        value: {
+            autoMode,
+            setTheme,
+            theme
+        }
+    }, children);
+};
+const useTheme = ()=>(0, _react.useContext)(Context);
+const _default = Context;
+
+//# sourceMappingURL=data:application/json;base64,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

package/packages/payload/dist/admin/components/utilities/UploadEdits/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { UploadEdits } from '../../../../uploads/types';
+export type UploadEditsContext = {
+    resetUploadEdits: () => void;
+    updateUploadEdits: (edits: UploadEdits) => void;
+    uploadEdits: UploadEdits;
+};
+export declare const UploadEditsProvider: ({ children }: {
+    children: any;
+}) => React.JSX.Element;
+export declare const useUploadEdits: () => UploadEditsContext;
+//# sourceMappingURL=index.d.ts.map

package/packages/payload/dist/admin/components/utilities/UploadEdits/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/admin/components/utilities/UploadEdits/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAE5D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,iBAAiB,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAA;IAC/C,WAAW,EAAE,WAAW,CAAA;CACzB,CAAA;AAQD,eAAO,MAAM,mBAAmB;;uBAmB/B,CAAA;AAED,eAAO,MAAM,cAAc,QAAO,kBAA+C,CAAA"}

package/packages/payload/dist/admin/components/utilities/UploadEdits/index.js

@@ -0,0 +1,51 @@
+"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, {
+    UploadEditsProvider: function() {
+        return UploadEditsProvider;
+    },
+    useUploadEdits: function() {
+        return useUploadEdits;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const Context = /*#__PURE__*/ _react.default.createContext({
+    resetUploadEdits: undefined,
+    updateUploadEdits: undefined,
+    uploadEdits: undefined
+});
+const UploadEditsProvider = ({ children })=>{
+    const [uploadEdits, setUploadEdits] = _react.default.useState(undefined);
+    const resetUploadEdits = ()=>{
+        setUploadEdits({});
+    };
+    const updateUploadEdits = (edits)=>{
+        setUploadEdits((prevEdits)=>({
+                ...prevEdits || {},
+                ...edits || {}
+            }));
+    };
+    return /*#__PURE__*/ _react.default.createElement(Context.Provider, {
+        value: {
+            resetUploadEdits,
+            updateUploadEdits,
+            uploadEdits
+        }
+    }, children);
+};
+const useUploadEdits = ()=>_react.default.useContext(Context);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hZG1pbi9jb21wb25lbnRzL3V0aWxpdGllcy9VcGxvYWRFZGl0cy9pbmRleC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0J1xuXG5pbXBvcnQgdHlwZSB7IFVwbG9hZEVkaXRzIH0gZnJvbSAnLi4vLi4vLi4vLi4vdXBsb2Fkcy90eXBlcydcblxuZXhwb3J0IHR5cGUgVXBsb2FkRWRpdHNDb250ZXh0ID0ge1xuICByZXNldFVwbG9hZEVkaXRzOiAoKSA9PiB2b2lkXG4gIHVwZGF0ZVVwbG9hZEVkaXRzOiAoZWRpdHM6IFVwbG9hZEVkaXRzKSA9PiB2b2lkXG4gIHVwbG9hZEVkaXRzOiBVcGxvYWRFZGl0c1xufVxuXG5jb25zdCBDb250ZXh0ID0gUmVhY3QuY3JlYXRlQ29udGV4dDxVcGxvYWRFZGl0c0NvbnRleHQ+KHtcbiAgcmVzZXRVcGxvYWRFZGl0czogdW5kZWZpbmVkLFxuICB1cGRhdGVVcGxvYWRFZGl0czogdW5kZWZpbmVkLFxuICB1cGxvYWRFZGl0czogdW5kZWZpbmVkLFxufSlcblxuZXhwb3J0IGNvbnN0IFVwbG9hZEVkaXRzUHJvdmlkZXIgPSAoeyBjaGlsZHJlbiB9KSA9PiB7XG4gIGNvbnN0IFt1cGxvYWRFZGl0cywgc2V0VXBsb2FkRWRpdHNdID0gUmVhY3QudXNlU3RhdGU8VXBsb2FkRWRpdHM+KHVuZGVmaW5lZClcblxuICBjb25zdCByZXNldFVwbG9hZEVkaXRzID0gKCkgPT4ge1xuICAgIHNldFVwbG9hZEVkaXRzKHt9KVxuICB9XG5cbiAgY29uc3QgdXBkYXRlVXBsb2FkRWRpdHMgPSAoZWRpdHM6IFVwbG9hZEVkaXRzKSA9PiB7XG4gICAgc2V0VXBsb2FkRWRpdHMoKHByZXZFZGl0cykgPT4gKHtcbiAgICAgIC4uLihwcmV2RWRpdHMgfHwge30pLFxuICAgICAgLi4uKGVkaXRzIHx8IHt9KSxcbiAgICB9KSlcbiAgfVxuXG4gIHJldHVybiAoXG4gICAgPENvbnRleHQuUHJvdmlkZXIgdmFsdWU9e3sgcmVzZXRVcGxvYWRFZGl0cywgdXBkYXRlVXBsb2FkRWRpdHMsIHVwbG9hZEVkaXRzIH19PlxuICAgICAge2NoaWxkcmVufVxuICAgIDwvQ29udGV4dC5Qcm92aWRlcj5cbiAgKVxufVxuXG5leHBvcnQgY29uc3QgdXNlVXBsb2FkRWRpdHMgPSAoKTogVXBsb2FkRWRpdHNDb250ZXh0ID0+IFJlYWN0LnVzZUNvbnRleHQoQ29udGV4dClcbiJdLCJuYW1lcyI6WyJVcGxvYWRFZGl0c1Byb3ZpZGVyIiwidXNlVXBsb2FkRWRpdHMiLCJDb250ZXh0IiwiUmVhY3QiLCJjcmVhdGVDb250ZXh0IiwicmVzZXRVcGxvYWRFZGl0cyIsInVuZGVmaW5lZCIsInVwZGF0ZVVwbG9hZEVkaXRzIiwidXBsb2FkRWRpdHMiLCJjaGlsZHJlbiIsInNldFVwbG9hZEVkaXRzIiwidXNlU3RhdGUiLCJlZGl0cyIsInByZXZFZGl0cyIsIlByb3ZpZGVyIiwidmFsdWUiLCJ1c2VDb250ZXh0Il0sInJhbmdlTWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsiLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7SUFnQmFBLG1CQUFtQjtlQUFuQkE7O0lBcUJBQyxjQUFjO2VBQWRBOzs7OERBckNLOzs7Ozs7QUFVbEIsTUFBTUMsd0JBQVVDLGNBQUssQ0FBQ0MsYUFBYSxDQUFxQjtJQUN0REMsa0JBQWtCQztJQUNsQkMsbUJBQW1CRDtJQUNuQkUsYUFBYUY7QUFDZjtBQUVPLE1BQU1OLHNCQUFzQixDQUFDLEVBQUVTLFFBQVEsRUFBRTtJQUM5QyxNQUFNLENBQUNELGFBQWFFLGVBQWUsR0FBR1AsY0FBSyxDQUFDUSxRQUFRLENBQWNMO0lBRWxFLE1BQU1ELG1CQUFtQjtRQUN2QkssZUFBZSxDQUFDO0lBQ2xCO0lBRUEsTUFBTUgsb0JBQW9CLENBQUNLO1FBQ3pCRixlQUFlLENBQUNHLFlBQWUsQ0FBQTtnQkFDN0IsR0FBSUEsYUFBYSxDQUFDLENBQUM7Z0JBQ25CLEdBQUlELFNBQVMsQ0FBQyxDQUFDO1lBQ2pCLENBQUE7SUFDRjtJQUVBLHFCQUNFLDZCQUFDVixRQUFRWSxRQUFRO1FBQUNDLE9BQU87WUFBRVY7WUFBa0JFO1lBQW1CQztRQUFZO09BQ3pFQztBQUdQO0FBRU8sTUFBTVIsaUJBQWlCLElBQTBCRSxjQUFLLENBQUNhLFVBQVUsQ0FBQ2QifQ==

package/packages/payload/dist/admin/components/utilities/WithMergedProps/index.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+/**
+ * Creates a higher-order component (HOC) that merges predefined properties (`toMergeIntoProps`)
+ * with any properties passed to the resulting component.
+ *
+ * Use this when you want to pre-specify some props for a component, while also allowing users to
+ * pass in their own props. The HOC ensures the passed props and predefined props are combined before
+ * rendering the original component.
+ *
+ * @example
+ * const PredefinedComponent = getMergedPropsComponent({
+ *   Component: OriginalComponent,
+ *   toMergeIntoProps: { someExtraValue: 5 }
+ * });
+ * // Using <PredefinedComponent customProp="value" /> will result in
+ * // <OriginalComponent customProp="value" someExtraValue={5} />
+ *
+ * @returns A higher-order component with combined properties.
+ */
+export declare function withMergedProps<ToMergeIntoProps, CompleteReturnProps>({ Component, toMergeIntoProps, }: {
+    Component: React.FC<CompleteReturnProps>;
+    toMergeIntoProps: ToMergeIntoProps;
+}): React.FC<CompleteReturnProps>;
+//# sourceMappingURL=index.d.ts.map

package/packages/payload/dist/admin/components/utilities/WithMergedProps/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/admin/components/utilities/WithMergedProps/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,gBAAgB,EAAE,mBAAmB,EAAE,EACrE,SAAS,EACT,gBAAgB,GACjB,EAAE;IACD,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAAC,CAAA;IACxC,gBAAgB,EAAE,gBAAgB,CAAA;CACnC,GAAG,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAAC,CAQhC"}

package/packages/payload/dist/admin/components/utilities/WithMergedProps/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "withMergedProps", {
+    enumerable: true,
+    get: function() {
+        return withMergedProps;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _deepMerge = require("../../../../utilities/deepMerge");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function withMergedProps({ Component, toMergeIntoProps }) {
+    // A wrapper around the args.Component to inject the args.toMergeArgs as props, which are merged with the passed props
+    const MergedPropsComponent = (passedProps)=>{
+        const mergedProps = (0, _deepMerge.deepMerge)(toMergeIntoProps, passedProps);
+        return /*#__PURE__*/ _react.default.createElement(Component, mergedProps);
+    };
+    return MergedPropsComponent;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/packages/payload/dist/admin/components/views/API/index.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import type { EditViewProps } from '../types';
+import './index.scss';
+export declare const API: React.FC<EditViewProps>;
+//# sourceMappingURL=index.d.ts.map

package/packages/payload/dist/admin/components/views/API/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/admin/components/views/API/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAc7C,OAAO,cAAc,CAAA;AA4JrB,eAAO,MAAM,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CAwKvC,CAAA"}

package/packages/payload/dist/admin/components/views/API/index.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "API", {
+    enumerable: true,
+    get: function() {
+        return API;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _ = require("../..");
+const _api = require("../../../api");
+const _CopyToClipboard = /*#__PURE__*/ _interop_require_default(require("../../elements/CopyToClipboard"));
+const _Gutter = require("../../elements/Gutter");
+const _Input = require("../../forms/field-types/Checkbox/Input");
+const _Input1 = /*#__PURE__*/ _interop_require_default(require("../../forms/field-types/Select/Input"));
+const _MinimizeMaximize = require("../../icons/MinimizeMaximize");
+const _ActionsProvider = require("../../utilities/ActionsProvider");
+const _Config = require("../../utilities/Config");
+const _DocumentInfo = require("../../utilities/DocumentInfo");
+const _Locale = require("../../utilities/Locale");
+const _SetStepNav = require("../collections/Edit/SetStepNav");
+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 chars = {
+    leftCurlyBracket: '\u007B',
+    leftSquareBracket: '\u005B',
+    rightCurlyBracket: '\u007D',
+    rightSquareBracket: '\u005D'
+};
+const baseClass = 'query-inspector';
+const Bracket = ({ type, comma = false, position })=>{
+    const rightBracket = type === 'object' ? chars.rightCurlyBracket : chars.rightSquareBracket;
+    const leftBracket = type === 'object' ? chars.leftCurlyBracket : chars.leftSquareBracket;
+    const bracketToRender = position === 'end' ? rightBracket : leftBracket;
+    return /*#__PURE__*/ _react.createElement("span", {
+        className: `${baseClass}__bracket ${baseClass}__bracket--position-${position}`
+    }, bracketToRender, position === 'end' && comma ? ',' : null);
+};
+const RecursivelyRenderObjectData = ({ isEmpty = false, object, objectKey, parentType = 'object', trailingComma = false })=>{
+    const objectKeys = Object.keys(object);
+    const objectLength = objectKeys.length;
+    const [isOpen, setIsOpen] = _react.useState(true);
+    const isNestedAndEmpty = isEmpty && (parentType === 'object' || parentType === 'array');
+    return /*#__PURE__*/ _react.createElement("li", {
+        className: isNestedAndEmpty ? `${baseClass}__row-line--nested` : ''
+    }, /*#__PURE__*/ _react.createElement("button", {
+        "aria-label": "toggle",
+        className: `${baseClass}__list-toggle ${isEmpty ? `${baseClass}__list-toggle--empty` : ''}`,
+        onClick: ()=>setIsOpen(!isOpen),
+        type: "button"
+    }, isEmpty ? null : /*#__PURE__*/ _react.createElement(_.Chevron, {
+        className: `${baseClass}__toggle-row-icon ${baseClass}__toggle-row-icon--${isOpen ? 'open' : 'closed'}`
+    }), /*#__PURE__*/ _react.createElement("span", null, objectKey && `"${objectKey}": `, /*#__PURE__*/ _react.createElement(Bracket, {
+        position: "start",
+        type: parentType
+    }), isEmpty ? /*#__PURE__*/ _react.createElement(Bracket, {
+        comma: trailingComma,
+        position: "end",
+        type: parentType
+    }) : null)), /*#__PURE__*/ _react.createElement("ul", {
+        className: `${baseClass}__json-children`
+    }, isOpen && objectKeys.map((key, keyIndex)=>{
+        let value = object[key];
+        let type = 'string';
+        const isLastKey = keyIndex === objectLength - 1;
+        if (value === null) {
+            type = 'null';
+        } else if (value instanceof Date) {
+            type = 'date';
+            value = value.toISOString();
+        } else if (Array.isArray(value)) {
+            type = 'array';
+        } else if (typeof value === 'object') {
+            type = 'object';
+        } else if (typeof value === 'number') {
+            type = 'number';
+        } else if (typeof value === 'boolean') {
+            type = 'boolean';
+        } else {
+            type = 'string';
+        }
+        if (type === 'object' || type === 'array') {
+            return /*#__PURE__*/ _react.createElement(RecursivelyRenderObjectData, {
+                isEmpty: value.length === 0 || Object.keys(value).length === 0,
+                key: `${key}-${keyIndex}`,
+                object: value,
+                objectKey: parentType === 'object' ? key : undefined,
+                parentType: type,
+                trailingComma: !isLastKey
+            });
+        }
+        if (type === 'date' || type === 'string' || type === 'null' || type === 'number' || type === 'boolean') {
+            const parentHasKey = Boolean(parentType === 'object' && key);
+            const rowClasses = [
+                `${baseClass}__row-line`,
+                `${baseClass}__value-type--${type}`,
+                `${baseClass}__row-line--${objectKey ? 'nested' : 'top'}`
+            ].filter(Boolean).join(' ');
+            return /*#__PURE__*/ _react.createElement("li", {
+                className: rowClasses,
+                key: `${key}-${keyIndex}`
+            }, parentHasKey ? /*#__PURE__*/ _react.createElement("span", null, `"${key}": `) : null, /*#__PURE__*/ _react.createElement("span", {
+                className: `${baseClass}__value`
+            }, JSON.stringify(value)), isLastKey ? '' : ',');
+        }
+    })), !isEmpty && /*#__PURE__*/ _react.createElement("span", null, /*#__PURE__*/ _react.createElement(Bracket, {
+        comma: trailingComma,
+        position: "end",
+        type: parentType
+    })));
+};
+function createURL(url) {
+    if (url.startsWith('/')) {
+        const domain = window.location.origin;
+        return new URL(url, domain);
+    } else {
+        return new URL(url);
+    }
+}
+const API = (props)=>{
+    const { apiURL } = props;
+    const { i18n, t } = (0, _reacti18next.useTranslation)();
+    const { localization, routes: { api }, serverURL } = (0, _Config.useConfig)();
+    const { id, collection, global } = (0, _DocumentInfo.useDocumentInfo)();
+    const { code } = (0, _Locale.useLocale)();
+    const url = createURL(apiURL);
+    const { setViewActions } = (0, _ActionsProvider.useActions)();
+    const draftsEnabled = collection?.versions?.drafts || global?.versions?.drafts;
+    const docEndpoint = global ? `/globals/${global.slug}` : `/${collection.slug}/${id}`;
+    const [data, setData] = _react.useState({});
+    const [draft, setDraft] = _react.useState(url.searchParams.get('draft') === 'true');
+    const [locale, setLocale] = _react.useState(url.searchParams.get('locale') || code);
+    const [depth, setDepth] = _react.useState(url.searchParams.get('depth') || '1');
+    const [authenticated, setAuthenticated] = _react.useState(true);
+    const [fullscreen, setFullscreen] = _react.useState(false);
+    const fetchURL = `${serverURL}${api}${docEndpoint}?locale=${locale}&draft=${draft}&depth=${depth}`;
+    _react.useEffect(()=>{
+        const fetchData = async ()=>{
+            const request = await _api.requests.get(fetchURL, {
+                credentials: authenticated ? 'include' : 'omit',
+                headers: {
+                    'Accept-Language': i18n.language
+                }
+            });
+            const json = await request.json();
+            setData(json);
+        };
+        fetchData();
+    }, [
+        i18n.language,
+        fetchURL,
+        authenticated
+    ]);
+    _react.useEffect(()=>{
+        const editConfig = (collection || global)?.admin?.components?.views?.Edit;
+        const apiActions = editConfig && 'API' in editConfig && 'actions' in editConfig.API ? editConfig.API.actions : [];
+        setViewActions(apiActions);
+        return ()=>{
+            setViewActions([]);
+        };
+    }, [
+        collection,
+        global,
+        setViewActions
+    ]);
+    const localeOptions = localization && localization.locales.map((locale)=>({
+            label: locale.label,
+            value: locale.code
+        }));
+    const classes = [
+        baseClass,
+        fullscreen && `${baseClass}--fullscreen`
+    ].filter(Boolean).join(' ');
+    let isEditing;
+    if ('collection' in props) {
+        isEditing = props?.isEditing;
+    }
+    return /*#__PURE__*/ _react.createElement(_Gutter.Gutter, {
+        className: classes,
+        right: false
+    }, /*#__PURE__*/ _react.createElement(_SetStepNav.SetStepNav, {
+        collection: collection,
+        global: global,
+        id: id,
+        isEditing: isEditing,
+        view: "API"
+    }), /*#__PURE__*/ _react.createElement("div", {
+        className: `${baseClass}__configuration`
+    }, /*#__PURE__*/ _react.createElement("div", {
+        className: `${baseClass}__api-url`
+    }, /*#__PURE__*/ _react.createElement("span", {
+        className: `${baseClass}__label`
+    }, "API URL ", /*#__PURE__*/ _react.createElement(_CopyToClipboard.default, {
+        value: fetchURL
+    })), /*#__PURE__*/ _react.createElement("a", {
+        href: fetchURL,
+        rel: "noopener noreferrer",
+        target: "_blank"
+    }, fetchURL)), /*#__PURE__*/ _react.createElement("div", {
+        className: `${baseClass}__form-fields`
+    }, /*#__PURE__*/ _react.createElement("div", {
+        className: `${baseClass}__filter-query-checkboxes`
+    }, draftsEnabled && /*#__PURE__*/ _react.createElement(_Input.CheckboxInput, {
+        checked: draft,
+        id: "draft-checkbox",
+        label: t('version:draft'),
+        onToggle: ()=>setDraft(!draft)
+    }), /*#__PURE__*/ _react.createElement(_Input.CheckboxInput, {
+        checked: authenticated,
+        id: "auth-checkbox",
+        label: t('authentication:authenticated'),
+        onToggle: ()=>setAuthenticated(!authenticated)
+    })), localeOptions && /*#__PURE__*/ _react.createElement(_Input1.default, {
+        defaultValue: {
+            label: locale,
+            value: locale
+        },
+        label: t('general:locale'),
+        name: "locale",
+        onChange: (e)=>setLocale(e.value),
+        options: localeOptions,
+        path: "locale"
+    }), /*#__PURE__*/ _react.createElement(_Input1.default, {
+        defaultValue: {
+            label: depth,
+            value: depth
+        },
+        label: t('general:depth'),
+        name: "depth",
+        onChange: (e)=>setDepth(e.value),
+        options: [
+            {
+                label: '0',
+                value: '0'
+            },
+            {
+                label: '1',
+                value: '1'
+            },
+            {
+                label: '2',
+                value: '2'
+            },
+            {
+                label: '3',
+                value: '3'
+            },
+            {
+                label: '4',
+                value: '4'
+            }
+        ],
+        path: "depth"
+    }))), /*#__PURE__*/ _react.createElement("div", {
+        className: `${baseClass}__results-wrapper`
+    }, /*#__PURE__*/ _react.createElement("div", {
+        className: `${baseClass}__toggle-fullscreen-button-container`
+    }, /*#__PURE__*/ _react.createElement("button", {
+        "aria-label": "toggle fullscreen",
+        className: `${baseClass}__toggle-fullscreen-button`,
+        onClick: ()=>setFullscreen(!fullscreen),
+        type: "button"
+    }, /*#__PURE__*/ _react.createElement(_MinimizeMaximize.MinimizeMaximize, {
+        isMinimized: !fullscreen
+    }))), /*#__PURE__*/ _react.createElement("div", {
+        className: `${baseClass}__results`
+    }, /*#__PURE__*/ _react.createElement(RecursivelyRenderObjectData, {
+        object: data
+    }))));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/admin/components/views/API/index.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useTranslation } from 'react-i18next'\n\nimport type { EditViewProps } from '../types'\n\nimport { Chevron } from '../..'\nimport { requests } from '../../../api'\nimport CopyToClipboard from '../../elements/CopyToClipboard'\nimport { Gutter } from '../../elements/Gutter'\nimport { CheckboxInput } from '../../forms/field-types/Checkbox/Input'\nimport SelectInput from '../../forms/field-types/Select/Input'\nimport { MinimizeMaximize } from '../../icons/MinimizeMaximize'\nimport { useActions } from '../../utilities/ActionsProvider'\nimport { useConfig } from '../../utilities/Config'\nimport { useDocumentInfo } from '../../utilities/DocumentInfo'\nimport { useLocale } from '../../utilities/Locale'\nimport { SetStepNav } from '../collections/Edit/SetStepNav'\nimport './index.scss'\n\nconst chars = {\n  leftCurlyBracket: '\\u007B',\n  leftSquareBracket: '\\u005B',\n  rightCurlyBracket: '\\u007D',\n  rightSquareBracket: '\\u005D',\n}\n\nconst baseClass = 'query-inspector'\n\nconst Bracket = ({\n  type,\n  comma = false,\n  position,\n}: {\n  comma?: boolean\n  position: 'end' | 'start'\n  type: 'array' | 'object'\n}) => {\n  const rightBracket = type === 'object' ? chars.rightCurlyBracket : chars.rightSquareBracket\n  const leftBracket = type === 'object' ? chars.leftCurlyBracket : chars.leftSquareBracket\n  const bracketToRender = position === 'end' ? rightBracket : leftBracket\n  return (\n    <span className={`${baseClass}__bracket ${baseClass}__bracket--position-${position}`}>\n      {bracketToRender}\n      {position === 'end' && comma ? ',' : null}\n    </span>\n  )\n}\n\ntype Args = {\n  isEmpty?: boolean\n  object: Record<string, any> | any[]\n  objectKey?: string\n  parentType?: 'array' | 'object'\n  trailingComma?: boolean\n}\n\nconst RecursivelyRenderObjectData = ({\n  isEmpty = false,\n  object,\n  objectKey,\n  parentType = 'object',\n  trailingComma = false,\n}: Args) => {\n  const objectKeys = Object.keys(object)\n  const objectLength = objectKeys.length\n  const [isOpen, setIsOpen] = React.useState<boolean>(true)\n  const isNestedAndEmpty = isEmpty && (parentType === 'object' || parentType === 'array')\n  return (\n    <li className={isNestedAndEmpty ? `${baseClass}__row-line--nested` : ''}>\n      <button\n        aria-label=\"toggle\"\n        className={`${baseClass}__list-toggle ${isEmpty ? `${baseClass}__list-toggle--empty` : ''}`}\n        onClick={() => setIsOpen(!isOpen)}\n        type=\"button\"\n      >\n        {isEmpty ? null : (\n          <Chevron\n            className={`${baseClass}__toggle-row-icon ${baseClass}__toggle-row-icon--${\n              isOpen ? 'open' : 'closed'\n            }`}\n          />\n        )}\n        <span>\n          {objectKey && `\"${objectKey}\": `}\n          <Bracket position=\"start\" type={parentType} />\n          {isEmpty ? <Bracket comma={trailingComma} position=\"end\" type={parentType} /> : null}\n        </span>\n      </button>\n\n      <ul className={`${baseClass}__json-children`}>\n        {isOpen &&\n          objectKeys.map((key, keyIndex) => {\n            let value = object[key]\n            let type = 'string'\n            const isLastKey = keyIndex === objectLength - 1\n\n            if (value === null) {\n              type = 'null'\n            } else if (value instanceof Date) {\n              type = 'date'\n              value = value.toISOString()\n            } else if (Array.isArray(value)) {\n              type = 'array'\n            } else if (typeof value === 'object') {\n              type = 'object'\n            } else if (typeof value === 'number') {\n              type = 'number'\n            } else if (typeof value === 'boolean') {\n              type = 'boolean'\n            } else {\n              type = 'string'\n            }\n\n            if (type === 'object' || type === 'array') {\n              return (\n                <RecursivelyRenderObjectData\n                  isEmpty={value.length === 0 || Object.keys(value).length === 0}\n                  key={`${key}-${keyIndex}`}\n                  object={value}\n                  objectKey={parentType === 'object' ? key : undefined}\n                  parentType={type}\n                  trailingComma={!isLastKey}\n                />\n              )\n            }\n\n            if (\n              type === 'date' ||\n              type === 'string' ||\n              type === 'null' ||\n              type === 'number' ||\n              type === 'boolean'\n            ) {\n              const parentHasKey = Boolean(parentType === 'object' && key)\n\n              const rowClasses = [\n                `${baseClass}__row-line`,\n                `${baseClass}__value-type--${type}`,\n                `${baseClass}__row-line--${objectKey ? 'nested' : 'top'}`,\n              ]\n                .filter(Boolean)\n                .join(' ')\n\n              return (\n                <li className={rowClasses} key={`${key}-${keyIndex}`}>\n                  {parentHasKey ? <span>{`\"${key}\": `}</span> : null}\n\n                  <span className={`${baseClass}__value`}>{JSON.stringify(value)}</span>\n                  {isLastKey ? '' : ','}\n                </li>\n              )\n            }\n          })}\n      </ul>\n\n      {!isEmpty && (\n        <span>\n          <Bracket comma={trailingComma} position=\"end\" type={parentType} />\n        </span>\n      )}\n    </li>\n  )\n}\n\nfunction createURL(url: string) {\n  if (url.startsWith('/')) {\n    const domain = window.location.origin\n    return new URL(url, domain)\n  } else {\n    return new URL(url)\n  }\n}\n\nexport const API: React.FC<EditViewProps> = (props) => {\n  const { apiURL } = props\n  const { i18n, t } = useTranslation()\n  const {\n    localization,\n    routes: { api },\n    serverURL,\n  } = useConfig()\n  const { id, collection, global } = useDocumentInfo()\n  const { code } = useLocale()\n  const url = createURL(apiURL)\n\n  const { setViewActions } = useActions()\n\n  const draftsEnabled = collection?.versions?.drafts || global?.versions?.drafts\n  const docEndpoint = global ? `/globals/${global.slug}` : `/${collection.slug}/${id}`\n\n  const [data, setData] = React.useState<any>({})\n  const [draft, setDraft] = React.useState<boolean>(url.searchParams.get('draft') === 'true')\n  const [locale, setLocale] = React.useState<string>(url.searchParams.get('locale') || code)\n  const [depth, setDepth] = React.useState<string>(url.searchParams.get('depth') || '1')\n  const [authenticated, setAuthenticated] = React.useState<boolean>(true)\n  const [fullscreen, setFullscreen] = React.useState<boolean>(false)\n\n  const fetchURL = `${serverURL}${api}${docEndpoint}?locale=${locale}&draft=${draft}&depth=${depth}`\n\n  React.useEffect(() => {\n    const fetchData = async () => {\n      const request = await requests.get(fetchURL, {\n        credentials: authenticated ? 'include' : 'omit',\n        headers: {\n          'Accept-Language': i18n.language,\n        },\n      })\n\n      const json = await request.json()\n      setData(json)\n    }\n\n    fetchData()\n  }, [i18n.language, fetchURL, authenticated])\n\n  React.useEffect(() => {\n    const editConfig = (collection || global)?.admin?.components?.views?.Edit\n    const apiActions =\n      editConfig && 'API' in editConfig && 'actions' in editConfig.API ? editConfig.API.actions : []\n\n    setViewActions(apiActions)\n\n    return () => {\n      setViewActions([])\n    }\n  }, [collection, global, setViewActions])\n\n  const localeOptions =\n    localization &&\n    localization.locales.map((locale) => ({ label: locale.label, value: locale.code }))\n\n  const classes = [baseClass, fullscreen && `${baseClass}--fullscreen`].filter(Boolean).join(' ')\n\n  let isEditing: boolean\n\n  if ('collection' in props) {\n    isEditing = props?.isEditing\n  }\n\n  return (\n    <Gutter className={classes} right={false}>\n      <SetStepNav\n        collection={collection}\n        global={global}\n        id={id}\n        isEditing={isEditing}\n        view=\"API\"\n      />\n      <div className={`${baseClass}__configuration`}>\n        <div className={`${baseClass}__api-url`}>\n          <span className={`${baseClass}__label`}>\n            API URL <CopyToClipboard value={fetchURL} />\n          </span>\n          <a href={fetchURL} rel=\"noopener noreferrer\" target=\"_blank\">\n            {fetchURL}\n          </a>\n        </div>\n\n        <div className={`${baseClass}__form-fields`}>\n          <div className={`${baseClass}__filter-query-checkboxes`}>\n            {draftsEnabled && (\n              <CheckboxInput\n                checked={draft}\n                id=\"draft-checkbox\"\n                label={t('version:draft')}\n                onToggle={() => setDraft(!draft)}\n              />\n            )}\n            <CheckboxInput\n              checked={authenticated}\n              id=\"auth-checkbox\"\n              label={t('authentication:authenticated')}\n              onToggle={() => setAuthenticated(!authenticated)}\n            />\n          </div>\n\n          {localeOptions && (\n            <SelectInput\n              defaultValue={{\n                label: locale,\n                value: locale,\n              }}\n              label={t('general:locale')}\n              name=\"locale\"\n              onChange={(e) => setLocale(e.value as string)}\n              options={localeOptions}\n              path=\"locale\"\n            />\n          )}\n          <SelectInput\n            defaultValue={{\n              label: depth,\n              value: depth,\n            }}\n            label={t('general:depth')}\n            name=\"depth\"\n            onChange={(e) => setDepth(e.value as string)}\n            options={[\n              {\n                label: '0',\n                value: '0',\n              },\n              {\n                label: '1',\n                value: '1',\n              },\n              {\n                label: '2',\n                value: '2',\n              },\n              {\n                label: '3',\n                value: '3',\n              },\n              {\n                label: '4',\n                value: '4',\n              },\n            ]}\n            path=\"depth\"\n          />\n        </div>\n      </div>\n\n      <div className={`${baseClass}__results-wrapper`}>\n        <div className={`${baseClass}__toggle-fullscreen-button-container`}>\n          <button\n            aria-label=\"toggle fullscreen\"\n            className={`${baseClass}__toggle-fullscreen-button`}\n            onClick={() => setFullscreen(!fullscreen)}\n            type=\"button\"\n          >\n            <MinimizeMaximize isMinimized={!fullscreen} />\n          </button>\n        </div>\n        <div className={`${baseClass}__results`}>\n          <RecursivelyRenderObjectData object={data} />\n        </div>\n      </div>\n    </Gutter>\n  )\n}\n"],"names":["API","chars","leftCurlyBracket","leftSquareBracket","rightCurlyBracket","rightSquareBracket","baseClass","Bracket","type","comma","position","rightBracket","leftBracket","bracketToRender","span","className","RecursivelyRenderObjectData","isEmpty","object","objectKey","parentType","trailingComma","objectKeys","Object","keys","objectLength","length","isOpen","setIsOpen","React","useState","isNestedAndEmpty","li","button","aria-label","onClick","Chevron","ul","map","key","keyIndex","value","isLastKey","Date","toISOString","Array","isArray","undefined","parentHasKey","Boolean","rowClasses","filter","join","JSON","stringify","createURL","url","startsWith","domain","window","location","origin","URL","props","apiURL","i18n","t","useTranslation","localization","routes","api","serverURL","useConfig","id","collection","global","useDocumentInfo","code","useLocale","setViewActions","useActions","draftsEnabled","versions","drafts","docEndpoint","slug","data","setData","draft","setDraft","searchParams","get","locale","setLocale","depth","setDepth","authenticated","setAuthenticated","fullscreen","setFullscreen","fetchURL","useEffect","fetchData","request","requests","credentials","headers","language","json","editConfig","admin","components","views","Edit","apiActions","actions","localeOptions","locales","label","classes","isEditing","Gutter","right","SetStepNav","view","div","CopyToClipboard","a","href","rel","target","CheckboxInput","checked","onToggle","SelectInput","defaultValue","name","onChange","e","options","path","MinimizeMaximize","isMinimized"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}