payload 2.0.0-beta.1 → 2.0.0-beta.4

package/dist/admin/components/views/LivePreview/index.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LivePreviewView", {
+    enumerable: true,
+    get: function() {
+        return LivePreviewView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _getTranslation = require("../../../../utilities/getTranslation");
+const _DocumentControls = require("../../elements/DocumentControls");
+const _Gutter = require("../../elements/Gutter");
+const _RenderFields = /*#__PURE__*/ _interop_require_default(require("../../forms/RenderFields"));
+const _filterFields = require("../../forms/RenderFields/filterFields");
+const _fieldtypes = require("../../forms/field-types");
+const _LeaveWithoutSaving = /*#__PURE__*/ _interop_require_default(require("../../modals/LeaveWithoutSaving"));
+const _Meta = /*#__PURE__*/ _interop_require_default(require("../../utilities/Meta"));
+const _PreviewWindow = require("./PreviewWindow");
+require("./index.scss");
+const _usePopupWindow = require("./usePopupWindow");
+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 = {};
+    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 = 'live-preview';
+const LivePreviewView = (props)=>{
+    const { i18n, t } = (0, _reacti18next.useTranslation)('general');
+    let url;
+    if ('collection' in props) {
+        url = props?.collection.admin.livePreview.url;
+    }
+    if ('global' in props) {
+        url = props?.global.admin.livePreview.url;
+    }
+    const popupState = (0, _usePopupWindow.usePopupWindow)({
+        eventType: 'livePreview',
+        href: url
+    });
+    const { apiURL, data, permissions } = props;
+    let collection;
+    let global;
+    let disableActions;
+    let disableLeaveWithoutSaving;
+    let hasSavePermission;
+    let isEditing;
+    let id;
+    if ('collection' in props) {
+        collection = props?.collection;
+        disableActions = props?.disableActions;
+        disableLeaveWithoutSaving = props?.disableLeaveWithoutSaving;
+        hasSavePermission = props?.hasSavePermission;
+        isEditing = props?.isEditing;
+        id = props?.id;
+    }
+    if ('global' in props) {
+        global = props?.global;
+    }
+    const { fields } = collection;
+    const sidebarFields = (0, _filterFields.filterFields)({
+        fieldSchema: fields,
+        fieldTypes: _fieldtypes.fieldTypes,
+        filter: (field)=>field?.admin?.position === 'sidebar',
+        permissions: permissions.fields,
+        readOnly: !hasSavePermission
+    });
+    return /*#__PURE__*/ _react.default.createElement(_react.Fragment, null, /*#__PURE__*/ _react.default.createElement(_DocumentControls.DocumentControls, {
+        apiURL: apiURL,
+        collection: collection,
+        data: data,
+        disableActions: disableActions,
+        global: global,
+        hasSavePermission: hasSavePermission,
+        id: id,
+        isEditing: isEditing,
+        permissions: permissions
+    }), /*#__PURE__*/ _react.default.createElement("div", {
+        className: [
+            baseClass,
+            popupState?.isPopupOpen && `${baseClass}--detached`
+        ].filter(Boolean).join(' ')
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__main`
+    }, /*#__PURE__*/ _react.default.createElement(_Meta.default, {
+        description: t('editing'),
+        keywords: `${(0, _getTranslation.getTranslation)(collection.labels.singular, i18n)}, Payload, CMS`,
+        title: `${isEditing ? t('editing') : t('creating')} - ${(0, _getTranslation.getTranslation)(collection.labels.singular, i18n)}`
+    }), !(collection.versions?.drafts && collection.versions?.drafts?.autosave) && !disableLeaveWithoutSaving && /*#__PURE__*/ _react.default.createElement(_LeaveWithoutSaving.default, null), /*#__PURE__*/ _react.default.createElement(_Gutter.Gutter, {
+        className: `${baseClass}__edit`
+    }, /*#__PURE__*/ _react.default.createElement(_RenderFields.default, {
+        fieldSchema: fields,
+        fieldTypes: _fieldtypes.fieldTypes,
+        filter: (field)=>!field?.admin?.position || field?.admin?.position !== 'sidebar',
+        permissions: permissions.fields,
+        readOnly: !hasSavePermission
+    }), sidebarFields && sidebarFields.length > 0 && /*#__PURE__*/ _react.default.createElement(_RenderFields.default, {
+        fieldTypes: _fieldtypes.fieldTypes,
+        fields: sidebarFields
+    }))), /*#__PURE__*/ _react.default.createElement(_PreviewWindow.PreviewWindow, {
+        ...props,
+        popupState: popupState,
+        url: url
+    })));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/admin/components/views/LivePreview/index.tsx"],"sourcesContent":["import React, { Fragment } from 'react'\nimport { useTranslation } from 'react-i18next'\n\nimport type { SanitizedCollectionConfig, SanitizedGlobalConfig } from '../../../../exports/types'\nimport type { EditViewProps } from '../types'\n\nimport { getTranslation } from '../../../../utilities/getTranslation'\nimport { DocumentControls } from '../../elements/DocumentControls'\nimport { Gutter } from '../../elements/Gutter'\nimport RenderFields from '../../forms/RenderFields'\nimport { filterFields } from '../../forms/RenderFields/filterFields'\nimport { fieldTypes } from '../../forms/field-types'\nimport LeaveWithoutSaving from '../../modals/LeaveWithoutSaving'\nimport Meta from '../../utilities/Meta'\nimport { PreviewWindow } from './PreviewWindow'\nimport './index.scss'\nimport { usePopupWindow } from './usePopupWindow'\n\nconst baseClass = 'live-preview'\n\nexport const LivePreviewView: React.FC<EditViewProps> = (props) => {\n  const { i18n, t } = useTranslation('general')\n\n  let url\n\n  if ('collection' in props) {\n    url = props?.collection.admin.livePreview.url\n  }\n\n  if ('global' in props) {\n    url = props?.global.admin.livePreview.url\n  }\n\n  const popupState = usePopupWindow({\n    eventType: 'livePreview',\n    href: url,\n  })\n\n  const { apiURL, data, permissions } = props\n\n  let collection: SanitizedCollectionConfig\n  let global: SanitizedGlobalConfig\n  let disableActions: boolean\n  let disableLeaveWithoutSaving: boolean\n  let hasSavePermission: boolean\n  let isEditing: boolean\n  let id: string\n\n  if ('collection' in props) {\n    collection = props?.collection\n    disableActions = props?.disableActions\n    disableLeaveWithoutSaving = props?.disableLeaveWithoutSaving\n    hasSavePermission = props?.hasSavePermission\n    isEditing = props?.isEditing\n    id = props?.id\n  }\n\n  if ('global' in props) {\n    global = props?.global\n  }\n\n  const { fields } = collection\n\n  const sidebarFields = filterFields({\n    fieldSchema: fields,\n    fieldTypes,\n    filter: (field) => field?.admin?.position === 'sidebar',\n    permissions: permissions.fields,\n    readOnly: !hasSavePermission,\n  })\n\n  return (\n    <Fragment>\n      <DocumentControls\n        apiURL={apiURL}\n        collection={collection}\n        data={data}\n        disableActions={disableActions}\n        global={global}\n        hasSavePermission={hasSavePermission}\n        id={id}\n        isEditing={isEditing}\n        permissions={permissions}\n      />\n      <div\n        className={[baseClass, popupState?.isPopupOpen && `${baseClass}--detached`]\n          .filter(Boolean)\n          .join(' ')}\n      >\n        <div className={`${baseClass}__main`}>\n          <Meta\n            description={t('editing')}\n            keywords={`${getTranslation(collection.labels.singular, i18n)}, Payload, CMS`}\n            title={`${isEditing ? t('editing') : t('creating')} - ${getTranslation(\n              collection.labels.singular,\n              i18n,\n            )}`}\n          />\n          {!(collection.versions?.drafts && collection.versions?.drafts?.autosave) &&\n            !disableLeaveWithoutSaving && <LeaveWithoutSaving />}\n          <Gutter className={`${baseClass}__edit`}>\n            <RenderFields\n              fieldSchema={fields}\n              fieldTypes={fieldTypes}\n              filter={(field) => !field?.admin?.position || field?.admin?.position !== 'sidebar'}\n              permissions={permissions.fields}\n              readOnly={!hasSavePermission}\n            />\n            {sidebarFields && sidebarFields.length > 0 && (\n              <RenderFields fieldTypes={fieldTypes} fields={sidebarFields} />\n            )}\n          </Gutter>\n        </div>\n        <PreviewWindow {...props} popupState={popupState} url={url} />\n      </div>\n    </Fragment>\n  )\n}\n"],"names":["LivePreviewView","baseClass","props","i18n","t","useTranslation","url","collection","admin","livePreview","global","popupState","usePopupWindow","eventType","href","apiURL","data","permissions","disableActions","disableLeaveWithoutSaving","hasSavePermission","isEditing","id","fields","sidebarFields","filterFields","fieldSchema","fieldTypes","filter","field","position","readOnly","Fragment","DocumentControls","div","className","isPopupOpen","Boolean","join","Meta","description","keywords","getTranslation","labels","singular","title","versions","drafts","autosave","LeaveWithoutSaving","Gutter","RenderFields","length","PreviewWindow"],"mappings":"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"}

package/dist/admin/components/views/LivePreview/index.scss

@@ -0,0 +1,75 @@
+@import '../../../scss/styles.scss';
+
+.live-preview {
+  width: 100%;
+  display: flex;
+
+  [dir='rtl'] & {
+    flex-direction: row-reverse;
+  }
+
+  &--popup-open {
+    .live-preview {
+      &__edit {
+        padding-right: var(--gutter-h);
+      }
+    }
+  }
+
+  &__main {
+    flex-grow: 1;
+    flex-shrink: 1;
+    display: flex;
+    flex-direction: column;
+    min-height: 100%;
+    position: relative;
+
+    &::after {
+      content: ' ';
+      position: absolute;
+      top: 0;
+      right: 0;
+      width: calc(var(--base) * 2);
+      height: 100%;
+      background: linear-gradient(to left, rgba(0, 0, 0, 0.25) 0%, rgba(0, 0, 0, 0) 100%);
+      pointer-events: none;
+      z-index: -1;
+    }
+  }
+
+  &__edit {
+    padding-top: calc(var(--base) * 1.5);
+    padding-bottom: base(4);
+    flex-grow: 1;
+    padding-right: calc(var(--base) * 2);
+
+    [dir='rtl'] & {
+      padding-right: 0;
+      padding-left: calc(var(--base) * 2);
+    }
+  }
+
+  @include mid-break {
+    flex-direction: column;
+
+    &__main {
+      min-height: initial;
+    }
+
+    &__form {
+      display: block;
+    }
+
+    &__edit {
+      padding-top: var(--base);
+      padding-bottom: 0;
+      padding-right: var(--gutter-h);
+    }
+  }
+
+  @include small-break {
+    &__edit {
+      padding-top: calc(var(--base) / 2);
+    }
+  }
+}

package/dist/admin/components/views/LivePreview/useLivePreview.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useLivePreview", {
+    enumerable: true,
+    get: function() {
+        return useLivePreview;
+    }
+});
+const _react = require("react");
+const useLivePreview = (props)=>{
+    const { initialPage, serverURL } = props;
+    const [data, setData] = (0, _react.useState)(initialPage);
+    const [isLoading, setIsLoading] = (0, _react.useState)(true);
+    const handleMessage = (0, _react.useCallback)((event)=>{
+        if (event.origin === serverURL && event.data) {
+            const eventData = JSON.parse(event?.data);
+            if (eventData.type === 'livePreview') {
+                setData(eventData?.data);
+                setIsLoading(false);
+            }
+        }
+    }, [
+        serverURL
+    ]);
+    (0, _react.useEffect)(()=>{
+        window.addEventListener('message', handleMessage);
+        window.parent.postMessage('ready', serverURL);
+        return ()=>{
+            window.removeEventListener('message', handleMessage);
+        };
+    }, [
+        serverURL,
+        handleMessage
+    ]);
+    return {
+        data,
+        isLoading
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/admin/components/views/LivePreview/usePopupWindow.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "usePopupWindow", {
+    enumerable: true,
+    get: function() {
+        return usePopupWindow;
+    }
+});
+const _react = require("react");
+const _Config = require("../../utilities/Config");
+const usePopupWindow = (props)=>{
+    const { eventType, href, onMessage } = props;
+    const isReceivingMessage = (0, _react.useRef)(false);
+    const [isOpen, setIsOpen] = (0, _react.useState)(false);
+    const [popupHasLoaded, setPopupHasLoaded] = (0, _react.useState)(false);
+    const { serverURL } = (0, _Config.useConfig)();
+    const popupRef = (0, _react.useRef)(null);
+    // Optionally broadcast messages back out to the parent component
+    (0, _react.useEffect)(()=>{
+        const receiveMessage = async (event)=>{
+            if (event.origin !== window.location.origin || event.origin !== href || event.origin !== serverURL) {
+                // console.warn(`Message received by ${event.origin}; IGNORED.`) // eslint-disable-line no-console
+                return;
+            }
+            if (typeof onMessage === 'function' && event.data?.type === eventType && !isReceivingMessage.current) {
+                isReceivingMessage.current = true;
+                await onMessage(event.data?.searchParams);
+                isReceivingMessage.current = false;
+            }
+        };
+        window.addEventListener('message', receiveMessage, false);
+        return ()=>{
+            window.removeEventListener('message', receiveMessage);
+        };
+    }, [
+        onMessage,
+        eventType,
+        href,
+        serverURL
+    ]);
+    // Customize the size, position, and style of the popup window
+    const openPopupWindow = (0, _react.useCallback)((e)=>{
+        e.preventDefault();
+        const features = {
+            height: 700,
+            left: 'auto',
+            menubar: 'no',
+            popup: 'yes',
+            toolbar: 'no',
+            top: 'auto',
+            width: 800
+        };
+        const popupOptions = Object.entries(features).reduce((str, [key, value])=>{
+            let strCopy = str;
+            if (value === 'auto') {
+                if (key === 'top') {
+                    const v = Math.round(window.innerHeight / 2 - features.height / 2);
+                    strCopy += `top=${v},`;
+                } else if (key === 'left') {
+                    const v = Math.round(window.innerWidth / 2 - features.width / 2);
+                    strCopy += `left=${v},`;
+                }
+                return strCopy;
+            }
+            strCopy += `${key}=${value},`;
+            return strCopy;
+        }, '').slice(0, -1) // remove last ',' (comma)
+        ;
+        const newWindow = window.open(href, '_blank', popupOptions);
+        popupRef.current = newWindow;
+        setIsOpen(true);
+    }, [
+        href
+    ]);
+    // the only cross-origin way of detecting when a popup window has loaded
+    // we catch a message event that the site rendered within the popup window fires
+    // there is no way in js to add an event listener to a popup window across domains
+    (0, _react.useEffect)(()=>{
+        window.addEventListener('message', (event)=>{
+            if (event.origin === href && event.data === 'ready') {
+                setPopupHasLoaded(true);
+            }
+        });
+    }, [
+        href
+    ]);
+    // this is the most stable and widely supported way to check if a popup window is no longer open
+    // we poll its ref every x ms and use the popup window's `closed` property
+    (0, _react.useEffect)(()=>{
+        let timer;
+        if (isOpen) {
+            timer = setInterval(function() {
+                if (popupRef.current.closed) {
+                    clearInterval(timer);
+                    setIsOpen(false);
+                    setPopupHasLoaded(false);
+                }
+            }, 1000);
+        } else {
+            clearInterval(timer);
+        }
+        return ()=>{
+            if (timer) {
+                clearInterval(timer);
+            }
+        };
+    }, [
+        isOpen,
+        popupRef
+    ]);
+    return {
+        isPopupOpen: isOpen,
+        openPopupWindow,
+        popupHasLoaded,
+        popupRef
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/admin/components/views/LivePreview/usePopupWindow.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react'\n\nimport { useConfig } from '../../utilities/Config'\n\nexport interface PopupMessage {\n  searchParams: {\n    [key: string]: string | undefined\n    code: string\n    installation_id: string\n    state: string\n  }\n  type: string\n}\n\nexport const usePopupWindow = (props: {\n  eventType?: string\n  href: string\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  onMessage?: (searchParams: PopupMessage['searchParams']) => Promise<void>\n}): {\n  isPopupOpen: boolean\n  openPopupWindow: (e: React.MouseEvent<HTMLAnchorElement>) => void\n  popupHasLoaded: boolean\n  popupRef?: React.MutableRefObject<Window | null>\n} => {\n  const { eventType, href, onMessage } = props\n  const isReceivingMessage = useRef(false)\n  const [isOpen, setIsOpen] = useState(false)\n  const [popupHasLoaded, setPopupHasLoaded] = useState(false)\n  const { serverURL } = useConfig()\n  const popupRef = useRef<Window | null>(null)\n\n  // Optionally broadcast messages back out to the parent component\n  useEffect(() => {\n    const receiveMessage = async (event: MessageEvent): Promise<void> => {\n      if (\n        event.origin !== window.location.origin ||\n        event.origin !== href ||\n        event.origin !== serverURL\n      ) {\n        // console.warn(`Message received by ${event.origin}; IGNORED.`) // eslint-disable-line no-console\n        return\n      }\n\n      if (\n        typeof onMessage === 'function' &&\n        event.data?.type === eventType &&\n        !isReceivingMessage.current\n      ) {\n        isReceivingMessage.current = true\n        await onMessage(event.data?.searchParams)\n        isReceivingMessage.current = false\n      }\n    }\n\n    window.addEventListener('message', receiveMessage, false)\n\n    return () => {\n      window.removeEventListener('message', receiveMessage)\n    }\n  }, [onMessage, eventType, href, serverURL])\n\n  // Customize the size, position, and style of the popup window\n  const openPopupWindow = useCallback(\n    (e) => {\n      e.preventDefault()\n\n      const features = {\n        height: 700,\n        left: 'auto',\n        menubar: 'no',\n        popup: 'yes',\n        toolbar: 'no',\n        top: 'auto',\n        width: 800,\n      }\n\n      const popupOptions = Object.entries(features)\n        .reduce((str, [key, value]) => {\n          let strCopy = str\n          if (value === 'auto') {\n            if (key === 'top') {\n              const v = Math.round(window.innerHeight / 2 - features.height / 2)\n              strCopy += `top=${v},`\n            } else if (key === 'left') {\n              const v = Math.round(window.innerWidth / 2 - features.width / 2)\n              strCopy += `left=${v},`\n            }\n            return strCopy\n          }\n\n          strCopy += `${key}=${value},`\n          return strCopy\n        }, '')\n        .slice(0, -1) // remove last ',' (comma)\n      const newWindow = window.open(href, '_blank', popupOptions)\n      popupRef.current = newWindow\n      setIsOpen(true)\n    },\n    [href],\n  )\n\n  // the only cross-origin way of detecting when a popup window has loaded\n  // we catch a message event that the site rendered within the popup window fires\n  // there is no way in js to add an event listener to a popup window across domains\n  useEffect(() => {\n    window.addEventListener('message', (event) => {\n      if (event.origin === href && event.data === 'ready') {\n        setPopupHasLoaded(true)\n      }\n    })\n  }, [href])\n\n  // this is the most stable and widely supported way to check if a popup window is no longer open\n  // we poll its ref every x ms and use the popup window's `closed` property\n  useEffect(() => {\n    let timer: NodeJS.Timeout\n\n    if (isOpen) {\n      timer = setInterval(function () {\n        if (popupRef.current.closed) {\n          clearInterval(timer)\n          setIsOpen(false)\n          setPopupHasLoaded(false)\n        }\n      }, 1000)\n    } else {\n      clearInterval(timer)\n    }\n\n    return () => {\n      if (timer) {\n        clearInterval(timer)\n      }\n    }\n  }, [isOpen, popupRef])\n\n  return {\n    isPopupOpen: isOpen,\n    openPopupWindow,\n    popupHasLoaded,\n    popupRef,\n  }\n}\n"],"names":["usePopupWindow","props","eventType","href","onMessage","isReceivingMessage","useRef","isOpen","setIsOpen","useState","popupHasLoaded","setPopupHasLoaded","serverURL","useConfig","popupRef","useEffect","receiveMessage","event","origin","window","location","data","type","current","searchParams","addEventListener","removeEventListener","openPopupWindow","useCallback","e","preventDefault","features","height","left","menubar","popup","toolbar","top","width","popupOptions","Object","entries","reduce","str","key","value","strCopy","v","Math","round","innerHeight","innerWidth","slice","newWindow","open","timer","setInterval","closed","clearInterval","isPopupOpen"],"mappings":"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"}

package/dist/admin/components/views/NotFound/index.scss

@@ -20,7 +20,7 @@
     margin-top: calc(var(--base) * 2);
   }
 
-  @include mid-break {
+  @include large-break {
     &--margin-top-large {
       margin-top: var(--base);
     }

package/dist/admin/components/views/RestAPI/index.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "QueryInspector", {
+    enumerable: true,
+    get: function() {
+        return QueryInspector;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _api = require("../../../api");
+const _Gutter = require("../../elements/Gutter");
+const _Input = /*#__PURE__*/ _interop_require_default(require("../../forms/field-types/Text/Input"));
+const _Config = require("../../utilities/Config");
+const _DocumentInfo = require("../../utilities/DocumentInfo");
+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 = {};
+    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 = 'query-inspector';
+const QueryInspector = ()=>{
+    const { id, collection } = (0, _DocumentInfo.useDocumentInfo)();
+    const { serverURL } = (0, _Config.useConfig)();
+    const { i18n } = (0, _reacti18next.useTranslation)();
+    const [query, setQuery] = _react.useState('');
+    const containerRef = _react.useRef(null);
+    _react.useEffect(()=>{
+        const fetchData = async ()=>{
+            if (id) {
+                const request = await _api.requests.get(`${serverURL}/api/${collection.slug}/${id}${query ? `${query}` : ''}`, {
+                    headers: {
+                        'Accept-Language': i18n.language
+                    }
+                });
+                const json = await request.json();
+                // const formatter = new JsonFormatter(json, Infinity)
+                // const formattedJSON = formatter.render()
+                containerRef.current.innerHTML = '' // Clear previous content
+                ;
+                containerRef.current.appendChild(json);
+            }
+        };
+        fetchData();
+    }, [
+        id,
+        collection,
+        serverURL,
+        i18n.language,
+        query
+    ]);
+    return /*#__PURE__*/ _react.createElement(_Gutter.Gutter, {
+        className: baseClass,
+        right: false
+    }, /*#__PURE__*/ _react.createElement("div", {
+        className: `${baseClass}__configuration`
+    }, /*#__PURE__*/ _react.createElement("h3", {
+        className: `${baseClass}__configuration-title`
+    }, "Query Builder"), /*#__PURE__*/ _react.createElement(_Input.default, {
+        name: "query",
+        onChange: (e)=>setQuery(e.target.value),
+        path: "query",
+        placeholder: "?depth=1",
+        value: query
+    })), /*#__PURE__*/ _react.createElement("div", {
+        className: `${baseClass}__results-container`,
+        ref: containerRef
+    }));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/admin/components/views/RestAPI/index.scss

@@ -0,0 +1,107 @@
+.query-inspector {
+  display: flex;
+  gap: var(--base);
+}
+
+.query-inspector__configuration {
+  margin-top: calc(var(--base) * 2);
+}
+
+.query-inspector__results-container {
+  --inspector-bg: var(--theme-elevation-50);
+  overflow: auto;
+  background-color: var(--inspector-bg);
+  flex-grow: 1;
+  padding-top: calc(var(--base) * 0.5);
+  padding-left: calc(var(--base) * 0.5);
+  padding-bottom: calc(var(--base) * 0.5);
+
+  .json-formatter-constructor-name,
+  .json-formatter-constructor-name + *,
+  > .json-formatter-row > .json-formatter-toggler-link {
+    display: none;
+  }
+
+  > .json-formatter-row {
+    border: none !important;
+  }
+
+  .json-formatter-constructor-name,
+  .json-formatter-key,
+  .json-formatter-bracket {
+    color: var(--theme-text);
+  }
+
+  .json-formatter-row {
+    position: relative;
+  }
+
+  .json-formatter-children {
+    position: relative;
+  }
+
+  .json-formatter-toggler-link {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+  }
+
+  .json-formatter-toggler-link {
+    &:before {
+      content: '';
+      position: absolute;
+      width: 0px;
+      border-left: 1px dashed var(--theme-elevation-400);
+      opacity: 0.5;
+      height: calc(100% - 25px);
+      top: 25px;
+      bottom: 0;
+      left: 0;
+    }
+  }
+
+  .json-formatter-row .json-formatter-toggler {
+    height: 5px;
+    width: 5px;
+    position: relative;
+    opacity: 1;
+
+    &:after {
+      content: '';
+      display: inline-block;
+      position: absolute;
+      border: 4px solid transparent;
+      border-left-color: var(--theme-text);
+      transform: translate3d(-50%, -50%, 0px) !important;
+      left: 0;
+      top: 5px;
+    }
+  }
+
+  .json-formatter-row.json-formatter-open > .json-formatter-toggler-link > .json-formatter-toggler {
+    &:after {
+      border-top-color: var(--theme-text);
+      border-left-color: transparent;
+    }
+  }
+
+  .json-formatter-key {
+  }
+
+  .json-formatter-number {
+    color: #62c3f3;
+  }
+}
+
+html[data-theme='dark'] {
+  .query-inspector__results-container {
+    .json-formatter-toggler {
+    }
+
+    .json-formatter-key {
+    }
+
+    .json-formatter-number {
+    }
+  }
+}