@strapi/content-manager 5.33.3 → 5.34.0

package/dist/server/src/controllers/relations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/relations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,eAAe,CAAC;;uCA+Ib,GAAG,OAAO,KAAK,EAAE;IA4H1D;;;;OAIG;uBACsB,GAAG;sBAwIJ,GAAG;;AA1Q7B,wBAkXE"}
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/relations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,eAAe,CAAC;;uCAiJb,GAAG,OAAO,KAAK,EAAE;IA4H1D;;;;OAIG;uBACsB,GAAG;sBAwIJ,GAAG;;AA1Q7B,wBAkXE"}

package/dist/server/src/controllers/utils/document-status.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Index items by documentId for lookup
+ *
+ * @param items - Array of items with documentId property
+ * @returns Map of documentId -> items array
+ */
+export declare const indexByDocumentId: <T extends {
+    documentId?: string | null | undefined;
+}>(items: T[]) => Map<string, T[]>;
+//# sourceMappingURL=document-status.d.ts.map

package/dist/server/src/controllers/utils/document-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-status.d.ts","sourceRoot":"","sources":["../../../../../server/src/controllers/utils/document-status.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;UACrB,CAAC,EAAE,KACT,IAAI,MAAM,EAAE,CAAC,EAAE,CAmBjB,CAAC"}

package/dist/server/src/index.d.ts

@@ -282,6 +282,7 @@ declare const _default: () => {
                 } & {
                     [key: string]: any;
                 }) | undefined, field: string) => any;
+                requiresEntity: (action: string) => boolean;
                 sanitizeOutput: (data: {
                     id: import("@strapi/types/dist/data").ID;
                 } & {

package/dist/server/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,wBAUE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,wBAUE"}

package/dist/server/src/services/components.d.ts

@@ -22,6 +22,12 @@ declare const _default: ({ strapi }: {
         options?: object | undefined;
         category: string;
     }>;
+    /**
+     * Batch load component configurations.
+     *
+     * Collects all component UIDs upfront, then loads configurations in a single
+     * batch query instead of sequential queries per component.
+     */
     findComponentsConfigurations(model: Struct.ComponentSchema): Promise<Record<string, Configuration & {
         category: string;
         isComponent: boolean;

package/dist/server/src/services/components.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../../server/src/services/components.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;qCAmB/B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;uBAO9B,IAAI,SAAS;iCAQG,OAAO,eAAe;;;;;;;;mCAW5C,OAAO,eAAe,oBACf,mBAAmB;;;;;;;;wCAOG,OAAO,eAAe;kBAGhC,MAAM;qBAAe,OAAO;;;;AArC9D,wBA4EG"}
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../../../server/src/services/components.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;qCAmB/B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;uBAO9B,IAAI,SAAS;iCAQG,OAAO,eAAe;;;;;;;;mCAW5C,OAAO,eAAe,oBACf,mBAAmB;;;;;;;;IAOvC;;;;;OAKG;wCACuC,OAAO,eAAe;kBAmD9B,MAAM;qBAAe,OAAO;;;;AA3FhE,wBAoIG"}

package/dist/server/src/services/index.d.ts

@@ -174,6 +174,7 @@ declare const _default: {
             } & {
                 [key: string]: any;
             }) | undefined, field: string) => any;
+            requiresEntity: (action: string) => boolean;
             sanitizeOutput: (data: {
                 id: import("@strapi/types/dist/data").ID;
             } & {

package/dist/server/src/services/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/services/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA,wBAeE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/services/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA,wBAeE"}

package/dist/server/src/services/permission-checker.d.ts

@@ -21,6 +21,7 @@ declare const _default: ({ strapi }: {
         } & {
             [key: string]: any;
         }) | undefined, field: string) => any;
+        requiresEntity: (action: string) => boolean;
         sanitizeOutput: (data: {
             id: import("@strapi/types/dist/data").ID;
         } & {

package/dist/server/src/services/permission-checker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"permission-checker.d.ts","sourceRoot":"","sources":["../../../../server/src/services/permission-checker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,eAAe,CAAC;AAaxD,KAAK,KAAK,GAAG;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;qCAoH0B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAnD,wBAEG"}
+{"version":3,"file":"permission-checker.d.ts","sourceRoot":"","sources":["../../../../server/src/services/permission-checker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,eAAe,CAAC;AAaxD,KAAK,KAAK,GAAG;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;qCA6I0B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAnD,wBAEG"}

package/dist/server/src/services/utils/store.d.ts

@@ -4,8 +4,12 @@ declare const _default: {
     getModelConfiguration: (key: any) => Promise<{
         settings: {};
         metadatas: {};
-        layouts: {};
+        layouts: {
+            list: never[];
+            edit: never[];
+        };
     }>;
+    getModelConfigurations: (keys: string[]) => Promise<Record<string, any>>;
     setModelConfiguration: (key: string, value: any) => Promise<void>;
     deleteKey: (key: any) => Promise<any>;
     keys: {

package/dist/server/src/services/utils/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/utils/store.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AA4DA,wBAOE"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/utils/store.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AA8GA,wBAQE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/content-manager",
-  "version": "5.33.3",
+  "version": "5.34.0",
   "description": "A powerful UI to easily manage your data.",
   "repository": {
     "type": "git",
@@ -67,10 +67,10 @@
     "@radix-ui/react-toolbar": "1.0.4",
     "@reduxjs/toolkit": "1.9.7",
     "@sindresorhus/slugify": "1.1.0",
-    "@strapi/design-system": "2.0.1",
-    "@strapi/icons": "2.0.1",
-    "@strapi/types": "5.33.3",
-    "@strapi/utils": "5.33.3",
+    "@strapi/design-system": "2.1.2",
+    "@strapi/icons": "2.1.2",
+    "@strapi/types": "5.34.0",
+    "@strapi/utils": "5.34.0",
     "codemirror5": "npm:codemirror@^5.65.11",
     "date-fns": "2.30.0",
     "fractional-indexing": "3.2.0",
@@ -104,8 +104,8 @@
     "yup": "0.32.9"
   },
   "devDependencies": {
-    "@strapi/admin": "5.33.3",
-    "@strapi/database": "5.33.3",
+    "@strapi/admin": "5.34.0",
+    "@strapi/database": "5.34.0",
     "@testing-library/react": "16.3.0",
     "@types/jest": "29.5.2",
     "@types/lodash": "^4.14.191",

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/plugins/withImages.js

@@ -1,17 +0,0 @@
-'use strict';
-
-/**
- * Images are void elements. They handle the rendering of their children instead of Slate.
- * See the Slate documentation for more information:
- * - https://docs.slatejs.org/api/nodes/element#void-vs-not-void
- * - https://docs.slatejs.org/api/nodes/element#rendering-void-elements
- */ const withImages = (editor)=>{
-    const { isVoid } = editor;
-    editor.isVoid = (element)=>{
-        return element.type === 'image' ? true : isVoid(element);
-    };
-    return editor;
-};
-
-exports.withImages = withImages;
-//# sourceMappingURL=withImages.js.map

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/plugins/withImages.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"withImages.js","sources":["../../../../../../../../admin/src/pages/EditView/components/FormInputs/BlocksInput/plugins/withImages.ts"],"sourcesContent":["import { type Editor } from 'slate';\n\n/**\n * Images are void elements. They handle the rendering of their children instead of Slate.\n * See the Slate documentation for more information:\n * - https://docs.slatejs.org/api/nodes/element#void-vs-not-void\n * - https://docs.slatejs.org/api/nodes/element#rendering-void-elements\n */\nconst withImages = (editor: Editor) => {\n  const { isVoid } = editor;\n\n  editor.isVoid = (element) => {\n    return element.type === 'image' ? true : isVoid(element);\n  };\n\n  return editor;\n};\n\nexport { withImages };\n"],"names":["withImages","editor","isVoid","element","type"],"mappings":";;AAEA;;;;;IAMA,MAAMA,aAAa,CAACC,MAAAA,GAAAA;IAClB,MAAM,EAAEC,MAAM,EAAE,GAAGD,MAAAA;IAEnBA,MAAOC,CAAAA,MAAM,GAAG,CAACC,OAAAA,GAAAA;AACf,QAAA,OAAOA,OAAQC,CAAAA,IAAI,KAAK,OAAA,GAAU,OAAOF,MAAOC,CAAAA,OAAAA,CAAAA;AAClD,KAAA;IAEA,OAAOF,MAAAA;AACT;;;;"}

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/plugins/withImages.mjs

@@ -1,15 +0,0 @@
-/**
- * Images are void elements. They handle the rendering of their children instead of Slate.
- * See the Slate documentation for more information:
- * - https://docs.slatejs.org/api/nodes/element#void-vs-not-void
- * - https://docs.slatejs.org/api/nodes/element#rendering-void-elements
- */ const withImages = (editor)=>{
-    const { isVoid } = editor;
-    editor.isVoid = (element)=>{
-        return element.type === 'image' ? true : isVoid(element);
-    };
-    return editor;
-};
-
-export { withImages };
-//# sourceMappingURL=withImages.mjs.map

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/plugins/withImages.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"withImages.mjs","sources":["../../../../../../../../admin/src/pages/EditView/components/FormInputs/BlocksInput/plugins/withImages.ts"],"sourcesContent":["import { type Editor } from 'slate';\n\n/**\n * Images are void elements. They handle the rendering of their children instead of Slate.\n * See the Slate documentation for more information:\n * - https://docs.slatejs.org/api/nodes/element#void-vs-not-void\n * - https://docs.slatejs.org/api/nodes/element#rendering-void-elements\n */\nconst withImages = (editor: Editor) => {\n  const { isVoid } = editor;\n\n  editor.isVoid = (element) => {\n    return element.type === 'image' ? true : isVoid(element);\n  };\n\n  return editor;\n};\n\nexport { withImages };\n"],"names":["withImages","editor","isVoid","element","type"],"mappings":"AAEA;;;;;IAMA,MAAMA,aAAa,CAACC,MAAAA,GAAAA;IAClB,MAAM,EAAEC,MAAM,EAAE,GAAGD,MAAAA;IAEnBA,MAAOC,CAAAA,MAAM,GAAG,CAACC,OAAAA,GAAAA;AACf,QAAA,OAAOA,OAAQC,CAAAA,IAAI,KAAK,OAAA,GAAU,OAAOF,MAAOC,CAAAA,OAAAA,CAAAA;AAClD,KAAA;IAEA,OAAOF,MAAAA;AACT;;;;"}

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/plugins/withLinks.js

@@ -1,75 +0,0 @@
-'use strict';
-
-var slate = require('slate');
-var links = require('../utils/links.js');
-
-const withLinks = (editor)=>{
-    const { isInline, apply, insertText, insertData } = editor;
-    // Links are inline elements, so we need to override the isInline method for slate
-    editor.isInline = (element)=>{
-        return element.type === 'link' ? true : isInline(element);
-    };
-    // We keep a track of the last inserted link path
-    // So we can show the popover on the link component if that link is the last one inserted
-    editor.lastInsertedLinkPath = null;
-    // We intercept the apply method, so everytime we insert a new link, we save its path
-    editor.apply = (operation)=>{
-        if (operation.type === 'insert_node') {
-            if (!slate.Editor.isEditor(operation.node) && operation.node.type === 'link' && editor.shouldSaveLinkPath) {
-                editor.lastInsertedLinkPath = operation.path;
-            }
-        } else if (operation.type === 'move_node') {
-            // We need to update the last inserted link path when link is moved
-            // If link is the first word in the paragraph we dont need to update the path
-            if (slate.Path.hasPrevious(operation.path) && editor.lastInsertedLinkPath && editor.shouldSaveLinkPath) {
-                editor.lastInsertedLinkPath = slate.Path.transform(editor.lastInsertedLinkPath, operation);
-            }
-        }
-        apply(operation);
-    };
-    editor.insertText = (text)=>{
-        // When selection is at the end of a link and user types a space, we want to break the link
-        if (editor.selection && slate.Range.isCollapsed(editor.selection) && text === ' ') {
-            const linksInSelection = Array.from(slate.Editor.nodes(editor, {
-                at: editor.selection,
-                match: (node)=>!slate.Editor.isEditor(node) && node.type === 'link'
-            }));
-            const selectionIsInLink = editor.selection && linksInSelection.length > 0;
-            const selectionIsAtEndOfLink = selectionIsInLink && slate.Point.equals(editor.selection.anchor, slate.Editor.end(editor, linksInSelection[0][1]));
-            if (selectionIsAtEndOfLink) {
-                slate.Transforms.insertNodes(editor, {
-                    text: ' ',
-                    type: 'text'
-                }, {
-                    at: slate.Path.next(linksInSelection[0][1]),
-                    select: true
-                });
-                return;
-            }
-        }
-        insertText(text);
-    };
-    // Add data as a clickable link if its a valid URL
-    editor.insertData = (data)=>{
-        const pastedText = data.getData('text/plain');
-        if (pastedText) {
-            try {
-                // eslint-disable-next-line no-new
-                new URL(pastedText);
-                // Do not show link popup on copy-paste a link, so do not save its path
-                editor.shouldSaveLinkPath = false;
-                links.insertLink(editor, {
-                    url: pastedText
-                });
-                return;
-            } catch (error) {
-            // continue normal data insertion
-            }
-        }
-        insertData(data);
-    };
-    return editor;
-};
-
-exports.withLinks = withLinks;
-//# sourceMappingURL=withLinks.js.map

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/plugins/withLinks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"withLinks.js","sources":["../../../../../../../../admin/src/pages/EditView/components/FormInputs/BlocksInput/plugins/withLinks.ts"],"sourcesContent":["import { type BaseEditor, Path, Transforms, Range, Point, Editor } from 'slate';\n\nimport { insertLink } from '../utils/links';\n\ninterface LinkEditor extends BaseEditor {\n  lastInsertedLinkPath: Path | null;\n  shouldSaveLinkPath: boolean;\n}\n\nconst withLinks = (editor: Editor) => {\n  const { isInline, apply, insertText, insertData } = editor;\n\n  // Links are inline elements, so we need to override the isInline method for slate\n  editor.isInline = (element) => {\n    return element.type === 'link' ? true : isInline(element);\n  };\n\n  // We keep a track of the last inserted link path\n  // So we can show the popover on the link component if that link is the last one inserted\n  editor.lastInsertedLinkPath = null;\n\n  // We intercept the apply method, so everytime we insert a new link, we save its path\n  editor.apply = (operation) => {\n    if (operation.type === 'insert_node') {\n      if (\n        !Editor.isEditor(operation.node) &&\n        operation.node.type === 'link' &&\n        editor.shouldSaveLinkPath\n      ) {\n        editor.lastInsertedLinkPath = operation.path;\n      }\n    } else if (operation.type === 'move_node') {\n      // We need to update the last inserted link path when link is moved\n      // If link is the first word in the paragraph we dont need to update the path\n      if (\n        Path.hasPrevious(operation.path) &&\n        editor.lastInsertedLinkPath &&\n        editor.shouldSaveLinkPath\n      ) {\n        editor.lastInsertedLinkPath = Path.transform(editor.lastInsertedLinkPath, operation);\n      }\n    }\n\n    apply(operation);\n  };\n\n  editor.insertText = (text) => {\n    // When selection is at the end of a link and user types a space, we want to break the link\n    if (editor.selection && Range.isCollapsed(editor.selection) && text === ' ') {\n      const linksInSelection = Array.from(\n        Editor.nodes(editor, {\n          at: editor.selection,\n          match: (node) => !Editor.isEditor(node) && node.type === 'link',\n        })\n      );\n\n      const selectionIsInLink = editor.selection && linksInSelection.length > 0;\n      const selectionIsAtEndOfLink =\n        selectionIsInLink &&\n        Point.equals(editor.selection.anchor, Editor.end(editor, linksInSelection[0][1]));\n\n      if (selectionIsAtEndOfLink) {\n        Transforms.insertNodes(\n          editor,\n          { text: ' ', type: 'text' },\n          { at: Path.next(linksInSelection[0][1]), select: true }\n        );\n\n        return;\n      }\n    }\n\n    insertText(text);\n  };\n\n  // Add data as a clickable link if its a valid URL\n  editor.insertData = (data) => {\n    const pastedText = data.getData('text/plain');\n\n    if (pastedText) {\n      try {\n        // eslint-disable-next-line no-new\n        new URL(pastedText);\n        // Do not show link popup on copy-paste a link, so do not save its path\n        editor.shouldSaveLinkPath = false;\n        insertLink(editor, { url: pastedText });\n        return;\n      } catch (error) {\n        // continue normal data insertion\n      }\n    }\n\n    insertData(data);\n  };\n\n  return editor;\n};\n\nexport { withLinks, type LinkEditor };\n"],"names":["withLinks","editor","isInline","apply","insertText","insertData","element","type","lastInsertedLinkPath","operation","Editor","isEditor","node","shouldSaveLinkPath","path","Path","hasPrevious","transform","text","selection","Range","isCollapsed","linksInSelection","Array","from","nodes","at","match","selectionIsInLink","length","selectionIsAtEndOfLink","Point","equals","anchor","end","Transforms","insertNodes","next","select","data","pastedText","getData","URL","insertLink","url","error"],"mappings":"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"}

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/plugins/withLinks.mjs

@@ -1,73 +0,0 @@
-import { Editor, Path, Range, Point, Transforms } from 'slate';
-import { insertLink } from '../utils/links.mjs';
-
-const withLinks = (editor)=>{
-    const { isInline, apply, insertText, insertData } = editor;
-    // Links are inline elements, so we need to override the isInline method for slate
-    editor.isInline = (element)=>{
-        return element.type === 'link' ? true : isInline(element);
-    };
-    // We keep a track of the last inserted link path
-    // So we can show the popover on the link component if that link is the last one inserted
-    editor.lastInsertedLinkPath = null;
-    // We intercept the apply method, so everytime we insert a new link, we save its path
-    editor.apply = (operation)=>{
-        if (operation.type === 'insert_node') {
-            if (!Editor.isEditor(operation.node) && operation.node.type === 'link' && editor.shouldSaveLinkPath) {
-                editor.lastInsertedLinkPath = operation.path;
-            }
-        } else if (operation.type === 'move_node') {
-            // We need to update the last inserted link path when link is moved
-            // If link is the first word in the paragraph we dont need to update the path
-            if (Path.hasPrevious(operation.path) && editor.lastInsertedLinkPath && editor.shouldSaveLinkPath) {
-                editor.lastInsertedLinkPath = Path.transform(editor.lastInsertedLinkPath, operation);
-            }
-        }
-        apply(operation);
-    };
-    editor.insertText = (text)=>{
-        // When selection is at the end of a link and user types a space, we want to break the link
-        if (editor.selection && Range.isCollapsed(editor.selection) && text === ' ') {
-            const linksInSelection = Array.from(Editor.nodes(editor, {
-                at: editor.selection,
-                match: (node)=>!Editor.isEditor(node) && node.type === 'link'
-            }));
-            const selectionIsInLink = editor.selection && linksInSelection.length > 0;
-            const selectionIsAtEndOfLink = selectionIsInLink && Point.equals(editor.selection.anchor, Editor.end(editor, linksInSelection[0][1]));
-            if (selectionIsAtEndOfLink) {
-                Transforms.insertNodes(editor, {
-                    text: ' ',
-                    type: 'text'
-                }, {
-                    at: Path.next(linksInSelection[0][1]),
-                    select: true
-                });
-                return;
-            }
-        }
-        insertText(text);
-    };
-    // Add data as a clickable link if its a valid URL
-    editor.insertData = (data)=>{
-        const pastedText = data.getData('text/plain');
-        if (pastedText) {
-            try {
-                // eslint-disable-next-line no-new
-                new URL(pastedText);
-                // Do not show link popup on copy-paste a link, so do not save its path
-                editor.shouldSaveLinkPath = false;
-                insertLink(editor, {
-                    url: pastedText
-                });
-                return;
-            } catch (error) {
-            // continue normal data insertion
-            }
-        }
-        insertData(data);
-    };
-    return editor;
-};
-
-export { withLinks };
-//# sourceMappingURL=withLinks.mjs.map

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/plugins/withLinks.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"withLinks.mjs","sources":["../../../../../../../../admin/src/pages/EditView/components/FormInputs/BlocksInput/plugins/withLinks.ts"],"sourcesContent":["import { type BaseEditor, Path, Transforms, Range, Point, Editor } from 'slate';\n\nimport { insertLink } from '../utils/links';\n\ninterface LinkEditor extends BaseEditor {\n  lastInsertedLinkPath: Path | null;\n  shouldSaveLinkPath: boolean;\n}\n\nconst withLinks = (editor: Editor) => {\n  const { isInline, apply, insertText, insertData } = editor;\n\n  // Links are inline elements, so we need to override the isInline method for slate\n  editor.isInline = (element) => {\n    return element.type === 'link' ? true : isInline(element);\n  };\n\n  // We keep a track of the last inserted link path\n  // So we can show the popover on the link component if that link is the last one inserted\n  editor.lastInsertedLinkPath = null;\n\n  // We intercept the apply method, so everytime we insert a new link, we save its path\n  editor.apply = (operation) => {\n    if (operation.type === 'insert_node') {\n      if (\n        !Editor.isEditor(operation.node) &&\n        operation.node.type === 'link' &&\n        editor.shouldSaveLinkPath\n      ) {\n        editor.lastInsertedLinkPath = operation.path;\n      }\n    } else if (operation.type === 'move_node') {\n      // We need to update the last inserted link path when link is moved\n      // If link is the first word in the paragraph we dont need to update the path\n      if (\n        Path.hasPrevious(operation.path) &&\n        editor.lastInsertedLinkPath &&\n        editor.shouldSaveLinkPath\n      ) {\n        editor.lastInsertedLinkPath = Path.transform(editor.lastInsertedLinkPath, operation);\n      }\n    }\n\n    apply(operation);\n  };\n\n  editor.insertText = (text) => {\n    // When selection is at the end of a link and user types a space, we want to break the link\n    if (editor.selection && Range.isCollapsed(editor.selection) && text === ' ') {\n      const linksInSelection = Array.from(\n        Editor.nodes(editor, {\n          at: editor.selection,\n          match: (node) => !Editor.isEditor(node) && node.type === 'link',\n        })\n      );\n\n      const selectionIsInLink = editor.selection && linksInSelection.length > 0;\n      const selectionIsAtEndOfLink =\n        selectionIsInLink &&\n        Point.equals(editor.selection.anchor, Editor.end(editor, linksInSelection[0][1]));\n\n      if (selectionIsAtEndOfLink) {\n        Transforms.insertNodes(\n          editor,\n          { text: ' ', type: 'text' },\n          { at: Path.next(linksInSelection[0][1]), select: true }\n        );\n\n        return;\n      }\n    }\n\n    insertText(text);\n  };\n\n  // Add data as a clickable link if its a valid URL\n  editor.insertData = (data) => {\n    const pastedText = data.getData('text/plain');\n\n    if (pastedText) {\n      try {\n        // eslint-disable-next-line no-new\n        new URL(pastedText);\n        // Do not show link popup on copy-paste a link, so do not save its path\n        editor.shouldSaveLinkPath = false;\n        insertLink(editor, { url: pastedText });\n        return;\n      } catch (error) {\n        // continue normal data insertion\n      }\n    }\n\n    insertData(data);\n  };\n\n  return editor;\n};\n\nexport { withLinks, type LinkEditor };\n"],"names":["withLinks","editor","isInline","apply","insertText","insertData","element","type","lastInsertedLinkPath","operation","Editor","isEditor","node","shouldSaveLinkPath","path","Path","hasPrevious","transform","text","selection","Range","isCollapsed","linksInSelection","Array","from","nodes","at","match","selectionIsInLink","length","selectionIsAtEndOfLink","Point","equals","anchor","end","Transforms","insertNodes","next","select","data","pastedText","getData","URL","insertLink","url","error"],"mappings":"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"}

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/utils/links.js

@@ -1,88 +0,0 @@
-'use strict';
-
-var slate = require('slate');
-
-const removeLink = (editor)=>{
-    slate.Transforms.unwrapNodes(editor, {
-        match: (node)=>!slate.Editor.isEditor(node) && slate.Element.isElement(node) && node.type === 'link'
-    });
-};
-const insertLink = (editor, { url })=>{
-    if (editor.selection) {
-        // We want to remove all link on the selection
-        const linkNodes = Array.from(slate.Editor.nodes(editor, {
-            at: editor.selection,
-            match: (node)=>!slate.Editor.isEditor(node) && node.type === 'link'
-        }));
-        linkNodes.forEach(([, path])=>{
-            slate.Transforms.unwrapNodes(editor, {
-                at: path
-            });
-        });
-        if (slate.Range.isCollapsed(editor.selection)) {
-            const link = {
-                type: 'link',
-                url: url ?? '',
-                children: [
-                    {
-                        type: 'text',
-                        text: url
-                    }
-                ],
-                rel: '',
-                target: ''
-            };
-            slate.Transforms.insertNodes(editor, link);
-        } else {
-            slate.Transforms.wrapNodes(editor, {
-                type: 'link',
-                url: url ?? ''
-            }, {
-                split: true
-            });
-        }
-    }
-};
-const editLink = (editor, link)=>{
-    const { url, text, rel, target } = link;
-    if (!editor.selection) {
-        return;
-    }
-    const linkEntry = slate.Editor.above(editor, {
-        match: (node)=>!slate.Editor.isEditor(node) && node.type === 'link'
-    });
-    if (linkEntry) {
-        const [, linkPath] = linkEntry;
-        slate.Transforms.setNodes(editor, {
-            url,
-            rel,
-            target
-        }, {
-            at: linkPath
-        });
-        // If link text is different, we remove the old text and insert the new one
-        if (text !== '' && text !== slate.Editor.string(editor, linkPath)) {
-            const linkNodeChildrens = Array.from(slate.Node.children(editor, linkPath, {
-                reverse: true
-            }));
-            linkNodeChildrens.forEach(([, childPath])=>{
-                slate.Transforms.removeNodes(editor, {
-                    at: childPath
-                });
-            });
-            slate.Transforms.insertNodes(editor, [
-                {
-                    type: 'text',
-                    text
-                }
-            ], {
-                at: linkPath.concat(0)
-            });
-        }
-    }
-};
-
-exports.editLink = editLink;
-exports.insertLink = insertLink;
-exports.removeLink = removeLink;
-//# sourceMappingURL=links.js.map

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/utils/links.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"links.js","sources":["../../../../../../../../admin/src/pages/EditView/components/FormInputs/BlocksInput/utils/links.ts"],"sourcesContent":["import { Transforms, Editor, Element as SlateElement, Node, Range } from 'slate';\n\nimport { type Block } from './types';\n\nconst removeLink = (editor: Editor) => {\n  Transforms.unwrapNodes(editor, {\n    match: (node) => !Editor.isEditor(node) && SlateElement.isElement(node) && node.type === 'link',\n  });\n};\n\nconst insertLink = (editor: Editor, { url }: { url: string }) => {\n  if (editor.selection) {\n    // We want to remove all link on the selection\n    const linkNodes = Array.from(\n      Editor.nodes(editor, {\n        at: editor.selection,\n        match: (node) => !Editor.isEditor(node) && node.type === 'link',\n      })\n    );\n\n    linkNodes.forEach(([, path]) => {\n      Transforms.unwrapNodes(editor, { at: path });\n    });\n\n    if (Range.isCollapsed(editor.selection)) {\n      const link: Block<'link'> = {\n        type: 'link',\n        url: url ?? '',\n        children: [{ type: 'text', text: url }],\n        rel: '',\n        target: '',\n      };\n\n      Transforms.insertNodes(editor, link);\n    } else {\n      Transforms.wrapNodes(editor, { type: 'link', url: url ?? '' } as Block<'link'>, {\n        split: true,\n      });\n    }\n  }\n};\n\nconst editLink = (\n  editor: Editor,\n  link: { url: string; text: string; rel: string; target: string }\n) => {\n  const { url, text, rel, target } = link;\n\n  if (!editor.selection) {\n    return;\n  }\n\n  const linkEntry = Editor.above(editor, {\n    match: (node) => !Editor.isEditor(node) && node.type === 'link',\n  });\n\n  if (linkEntry) {\n    const [, linkPath] = linkEntry;\n    Transforms.setNodes(editor, { url, rel, target }, { at: linkPath });\n\n    // If link text is different, we remove the old text and insert the new one\n    if (text !== '' && text !== Editor.string(editor, linkPath)) {\n      const linkNodeChildrens = Array.from(Node.children(editor, linkPath, { reverse: true }));\n\n      linkNodeChildrens.forEach(([, childPath]) => {\n        Transforms.removeNodes(editor, { at: childPath });\n      });\n\n      Transforms.insertNodes(editor, [{ type: 'text', text }], { at: linkPath.concat(0) });\n    }\n  }\n};\n\nexport { insertLink, editLink, removeLink };\n"],"names":["removeLink","editor","Transforms","unwrapNodes","match","node","Editor","isEditor","SlateElement","isElement","type","insertLink","url","selection","linkNodes","Array","from","nodes","at","forEach","path","Range","isCollapsed","link","children","text","rel","target","insertNodes","wrapNodes","split","editLink","linkEntry","above","linkPath","setNodes","string","linkNodeChildrens","Node","reverse","childPath","removeNodes","concat"],"mappings":"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"}

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/utils/links.mjs

@@ -1,84 +0,0 @@
-import { Editor, Transforms, Range, Element, Node } from 'slate';
-
-const removeLink = (editor)=>{
-    Transforms.unwrapNodes(editor, {
-        match: (node)=>!Editor.isEditor(node) && Element.isElement(node) && node.type === 'link'
-    });
-};
-const insertLink = (editor, { url })=>{
-    if (editor.selection) {
-        // We want to remove all link on the selection
-        const linkNodes = Array.from(Editor.nodes(editor, {
-            at: editor.selection,
-            match: (node)=>!Editor.isEditor(node) && node.type === 'link'
-        }));
-        linkNodes.forEach(([, path])=>{
-            Transforms.unwrapNodes(editor, {
-                at: path
-            });
-        });
-        if (Range.isCollapsed(editor.selection)) {
-            const link = {
-                type: 'link',
-                url: url ?? '',
-                children: [
-                    {
-                        type: 'text',
-                        text: url
-                    }
-                ],
-                rel: '',
-                target: ''
-            };
-            Transforms.insertNodes(editor, link);
-        } else {
-            Transforms.wrapNodes(editor, {
-                type: 'link',
-                url: url ?? ''
-            }, {
-                split: true
-            });
-        }
-    }
-};
-const editLink = (editor, link)=>{
-    const { url, text, rel, target } = link;
-    if (!editor.selection) {
-        return;
-    }
-    const linkEntry = Editor.above(editor, {
-        match: (node)=>!Editor.isEditor(node) && node.type === 'link'
-    });
-    if (linkEntry) {
-        const [, linkPath] = linkEntry;
-        Transforms.setNodes(editor, {
-            url,
-            rel,
-            target
-        }, {
-            at: linkPath
-        });
-        // If link text is different, we remove the old text and insert the new one
-        if (text !== '' && text !== Editor.string(editor, linkPath)) {
-            const linkNodeChildrens = Array.from(Node.children(editor, linkPath, {
-                reverse: true
-            }));
-            linkNodeChildrens.forEach(([, childPath])=>{
-                Transforms.removeNodes(editor, {
-                    at: childPath
-                });
-            });
-            Transforms.insertNodes(editor, [
-                {
-                    type: 'text',
-                    text
-                }
-            ], {
-                at: linkPath.concat(0)
-            });
-        }
-    }
-};
-
-export { editLink, insertLink, removeLink };
-//# sourceMappingURL=links.mjs.map

package/dist/admin/pages/EditView/components/FormInputs/BlocksInput/utils/links.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"links.mjs","sources":["../../../../../../../../admin/src/pages/EditView/components/FormInputs/BlocksInput/utils/links.ts"],"sourcesContent":["import { Transforms, Editor, Element as SlateElement, Node, Range } from 'slate';\n\nimport { type Block } from './types';\n\nconst removeLink = (editor: Editor) => {\n  Transforms.unwrapNodes(editor, {\n    match: (node) => !Editor.isEditor(node) && SlateElement.isElement(node) && node.type === 'link',\n  });\n};\n\nconst insertLink = (editor: Editor, { url }: { url: string }) => {\n  if (editor.selection) {\n    // We want to remove all link on the selection\n    const linkNodes = Array.from(\n      Editor.nodes(editor, {\n        at: editor.selection,\n        match: (node) => !Editor.isEditor(node) && node.type === 'link',\n      })\n    );\n\n    linkNodes.forEach(([, path]) => {\n      Transforms.unwrapNodes(editor, { at: path });\n    });\n\n    if (Range.isCollapsed(editor.selection)) {\n      const link: Block<'link'> = {\n        type: 'link',\n        url: url ?? '',\n        children: [{ type: 'text', text: url }],\n        rel: '',\n        target: '',\n      };\n\n      Transforms.insertNodes(editor, link);\n    } else {\n      Transforms.wrapNodes(editor, { type: 'link', url: url ?? '' } as Block<'link'>, {\n        split: true,\n      });\n    }\n  }\n};\n\nconst editLink = (\n  editor: Editor,\n  link: { url: string; text: string; rel: string; target: string }\n) => {\n  const { url, text, rel, target } = link;\n\n  if (!editor.selection) {\n    return;\n  }\n\n  const linkEntry = Editor.above(editor, {\n    match: (node) => !Editor.isEditor(node) && node.type === 'link',\n  });\n\n  if (linkEntry) {\n    const [, linkPath] = linkEntry;\n    Transforms.setNodes(editor, { url, rel, target }, { at: linkPath });\n\n    // If link text is different, we remove the old text and insert the new one\n    if (text !== '' && text !== Editor.string(editor, linkPath)) {\n      const linkNodeChildrens = Array.from(Node.children(editor, linkPath, { reverse: true }));\n\n      linkNodeChildrens.forEach(([, childPath]) => {\n        Transforms.removeNodes(editor, { at: childPath });\n      });\n\n      Transforms.insertNodes(editor, [{ type: 'text', text }], { at: linkPath.concat(0) });\n    }\n  }\n};\n\nexport { insertLink, editLink, removeLink };\n"],"names":["removeLink","editor","Transforms","unwrapNodes","match","node","Editor","isEditor","SlateElement","isElement","type","insertLink","url","selection","linkNodes","Array","from","nodes","at","forEach","path","Range","isCollapsed","link","children","text","rel","target","insertNodes","wrapNodes","split","editLink","linkEntry","above","linkPath","setNodes","string","linkNodeChildrens","Node","reverse","childPath","removeNodes","concat"],"mappings":"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"}

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/plugins/withImages.d.ts

@@ -1,11 +0,0 @@
-import { type Editor } from 'slate';
-/**
- * Images are void elements. They handle the rendering of their children instead of Slate.
- * See the Slate documentation for more information:
- * - https://docs.slatejs.org/api/nodes/element#void-vs-not-void
- * - https://docs.slatejs.org/api/nodes/element#rendering-void-elements
- */
-declare const withImages: (editor: Editor) => Omit<import("slate").BaseEditor & import("slate-react").ReactEditor & import("slate-history").HistoryEditor & import("./withLinks").LinkEditor, "children"> & {
-    children: import("@strapi/types/dist/schema/attribute").BlocksValue;
-};
-export { withImages };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/plugins/withLinks.d.ts

@@ -1,9 +0,0 @@
-import { type BaseEditor, Path, Editor } from 'slate';
-interface LinkEditor extends BaseEditor {
-    lastInsertedLinkPath: Path | null;
-    shouldSaveLinkPath: boolean;
-}
-declare const withLinks: (editor: Editor) => Omit<BaseEditor & import("slate-react").ReactEditor & import("slate-history").HistoryEditor & LinkEditor, "children"> & {
-    children: import("@strapi/types/dist/schema/attribute").BlocksValue;
-};
-export { withLinks, type LinkEditor };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/utils/links.d.ts

@@ -1,12 +0,0 @@
-import { Editor } from 'slate';
-declare const removeLink: (editor: Editor) => void;
-declare const insertLink: (editor: Editor, { url }: {
-    url: string;
-}) => void;
-declare const editLink: (editor: Editor, link: {
-    url: string;
-    text: string;
-    rel: string;
-    target: string;
-}) => void;
-export { insertLink, editLink, removeLink };