payload 3.80.0-internal.cdd7ef7 → 3.80.0

package/dist/folders/hooks/deleteSubfoldersAfterDelete.js

@@ -0,0 +1,15 @@
+export const deleteSubfoldersBeforeDelete = ({ folderFieldName, folderSlug })=>{
+    return async ({ id, req })=>{
+        await req.payload.delete({
+            collection: folderSlug,
+            req,
+            where: {
+                [folderFieldName]: {
+                    equals: id
+                }
+            }
+        });
+    };
+};
+
+//# sourceMappingURL=deleteSubfoldersAfterDelete.js.map

package/dist/folders/hooks/deleteSubfoldersAfterDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/folders/hooks/deleteSubfoldersAfterDelete.ts"],"sourcesContent":["import type { CollectionBeforeDeleteHook } from '../../index.js'\n\ntype Args = {\n  folderFieldName: string\n  folderSlug: string\n}\nexport const deleteSubfoldersBeforeDelete = ({\n  folderFieldName,\n  folderSlug,\n}: Args): CollectionBeforeDeleteHook => {\n  return async ({ id, req }) => {\n    await req.payload.delete({\n      collection: folderSlug,\n      req,\n      where: {\n        [folderFieldName]: {\n          equals: id,\n        },\n      },\n    })\n  }\n}\n"],"names":["deleteSubfoldersBeforeDelete","folderFieldName","folderSlug","id","req","payload","delete","collection","where","equals"],"mappings":"AAMA,OAAO,MAAMA,+BAA+B,CAAC,EAC3CC,eAAe,EACfC,UAAU,EACL;IACL,OAAO,OAAO,EAAEC,EAAE,EAAEC,GAAG,EAAE;QACvB,MAAMA,IAAIC,OAAO,CAACC,MAAM,CAAC;YACvBC,YAAYL;YACZE;YACAI,OAAO;gBACL,CAACP,gBAAgB,EAAE;oBACjBQ,QAAQN;gBACV;YACF;QACF;IACF;AACF,EAAC"}

package/dist/folders/hooks/dissasociateAfterDelete.d.ts

@@ -0,0 +1,8 @@
+import type { CollectionAfterDeleteHook } from '../../index.js';
+type Args = {
+    collectionSlugs: string[];
+    folderFieldName: string;
+};
+export declare const dissasociateAfterDelete: ({ collectionSlugs, folderFieldName, }: Args) => CollectionAfterDeleteHook;
+export {};
+//# sourceMappingURL=dissasociateAfterDelete.d.ts.map

package/dist/folders/hooks/dissasociateAfterDelete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dissasociateAfterDelete.d.ts","sourceRoot":"","sources":["../../../src/folders/hooks/dissasociateAfterDelete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAA;AAE/D,KAAK,IAAI,GAAG;IACV,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AACD,eAAO,MAAM,uBAAuB,0CAGjC,IAAI,KAAG,yBAiBT,CAAA"}

package/dist/folders/hooks/dissasociateAfterDelete.js

@@ -0,0 +1,20 @@
+export const dissasociateAfterDelete = ({ collectionSlugs, folderFieldName })=>{
+    return async ({ id, req })=>{
+        for (const collectionSlug of collectionSlugs){
+            await req.payload.update({
+                collection: collectionSlug,
+                data: {
+                    [folderFieldName]: null
+                },
+                req,
+                where: {
+                    [folderFieldName]: {
+                        equals: id
+                    }
+                }
+            });
+        }
+    };
+};
+
+//# sourceMappingURL=dissasociateAfterDelete.js.map

package/dist/folders/hooks/dissasociateAfterDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/folders/hooks/dissasociateAfterDelete.ts"],"sourcesContent":["import type { CollectionAfterDeleteHook } from '../../index.js'\n\ntype Args = {\n  collectionSlugs: string[]\n  folderFieldName: string\n}\nexport const dissasociateAfterDelete = ({\n  collectionSlugs,\n  folderFieldName,\n}: Args): CollectionAfterDeleteHook => {\n  return async ({ id, req }) => {\n    for (const collectionSlug of collectionSlugs) {\n      await req.payload.update({\n        collection: collectionSlug,\n        data: {\n          [folderFieldName]: null,\n        },\n        req,\n        where: {\n          [folderFieldName]: {\n            equals: id,\n          },\n        },\n      })\n    }\n  }\n}\n"],"names":["dissasociateAfterDelete","collectionSlugs","folderFieldName","id","req","collectionSlug","payload","update","collection","data","where","equals"],"mappings":"AAMA,OAAO,MAAMA,0BAA0B,CAAC,EACtCC,eAAe,EACfC,eAAe,EACV;IACL,OAAO,OAAO,EAAEC,EAAE,EAAEC,GAAG,EAAE;QACvB,KAAK,MAAMC,kBAAkBJ,gBAAiB;YAC5C,MAAMG,IAAIE,OAAO,CAACC,MAAM,CAAC;gBACvBC,YAAYH;gBACZI,MAAM;oBACJ,CAACP,gBAAgB,EAAE;gBACrB;gBACAE;gBACAM,OAAO;oBACL,CAACR,gBAAgB,EAAE;wBACjBS,QAAQR;oBACV;gBACF;YACF;QACF;IACF;AACF,EAAC"}

package/dist/folders/hooks/ensureSafeCollectionsChange.d.ts

@@ -0,0 +1,5 @@
+import { type CollectionBeforeValidateHook, type CollectionSlug } from '../../index.js';
+export declare const ensureSafeCollectionsChange: ({ foldersSlug }: {
+    foldersSlug: CollectionSlug;
+}) => CollectionBeforeValidateHook;
+//# sourceMappingURL=ensureSafeCollectionsChange.d.ts.map

package/dist/folders/hooks/ensureSafeCollectionsChange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureSafeCollectionsChange.d.ts","sourceRoot":"","sources":["../../../src/folders/hooks/ensureSafeCollectionsChange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,4BAA4B,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAIjG,eAAO,MAAM,2BAA2B,oBACpB;IAAE,WAAW,EAAE,cAAc,CAAA;CAAE,KAAG,4BA0InD,CAAA"}

package/dist/folders/hooks/ensureSafeCollectionsChange.js

@@ -0,0 +1,107 @@
+import { APIError } from '../../index.js';
+import { extractID } from '../../utilities/extractID.js';
+import { getTranslatedLabel } from '../../utilities/getTranslatedLabel.js';
+export const ensureSafeCollectionsChange = ({ foldersSlug })=>async ({ data, originalDoc, req })=>{
+        const currentFolderID = extractID(originalDoc || {});
+        const parentFolderID = extractID(data?.folder || originalDoc?.folder || {});
+        if (Array.isArray(data?.folderType) && data.folderType.length > 0) {
+            const folderType = data.folderType;
+            const currentlyAssignedCollections = Array.isArray(originalDoc?.folderType) && originalDoc.folderType.length > 0 ? originalDoc.folderType : undefined;
+            /**
+       * Check if the assigned collections have changed.
+       * example:
+       * - originalAssignedCollections: ['posts', 'pages']
+       * - folderType: ['posts']
+       *
+       * The user is narrowing the types of documents that can be associated with this folder.
+       * If the user is only expanding the types of documents that can be associated with this folder,
+       * we do not need to do anything.
+       */ const newCollections = currentlyAssignedCollections ? currentlyAssignedCollections.filter((c)=>!folderType.includes(c)) : folderType;
+            if (newCollections && newCollections.length > 0) {
+                let hasDependentDocuments = false;
+                if (typeof currentFolderID === 'string' || typeof currentFolderID === 'number') {
+                    const childDocumentsResult = await req.payload.findByID({
+                        id: currentFolderID,
+                        collection: foldersSlug,
+                        joins: {
+                            documentsAndFolders: {
+                                limit: 100_000_000,
+                                where: {
+                                    or: [
+                                        {
+                                            relationTo: {
+                                                in: newCollections
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        overrideAccess: true,
+                        req
+                    });
+                    hasDependentDocuments = childDocumentsResult.documentsAndFolders.docs.length > 0;
+                }
+                // matches folders that are directly related to the removed collections
+                let hasDependentFolders = false;
+                if (!hasDependentDocuments && (typeof currentFolderID === 'string' || typeof currentFolderID === 'number')) {
+                    const childFoldersResult = await req.payload.find({
+                        collection: foldersSlug,
+                        limit: 1,
+                        req,
+                        where: {
+                            and: [
+                                {
+                                    folderType: {
+                                        in: newCollections
+                                    }
+                                },
+                                {
+                                    folder: {
+                                        equals: currentFolderID
+                                    }
+                                }
+                            ]
+                        }
+                    });
+                    hasDependentFolders = childFoldersResult.totalDocs > 0;
+                }
+                if (hasDependentDocuments || hasDependentFolders) {
+                    const translatedLabels = newCollections.map((collectionSlug)=>{
+                        if (req.payload.collections[collectionSlug]?.config.labels.singular) {
+                            return getTranslatedLabel(req.payload.collections[collectionSlug]?.config.labels.plural, req.i18n);
+                        }
+                        return collectionSlug;
+                    });
+                    throw new APIError(`The folder "${data.name || originalDoc.name}" contains ${hasDependentDocuments ? 'documents' : 'folders'} that still belong to the following collections: ${translatedLabels.join(', ')}`, 400);
+                }
+                return data;
+            }
+        } else if ((data?.folderType === null || Array.isArray(data?.folderType) && data?.folderType.length === 0) && parentFolderID) {
+            // attempting to set the folderType to catch-all, so we need to ensure that the parent allows this
+            let parentFolder;
+            if (typeof parentFolderID === 'string' || typeof parentFolderID === 'number') {
+                try {
+                    parentFolder = await req.payload.findByID({
+                        id: parentFolderID,
+                        collection: foldersSlug,
+                        overrideAccess: true,
+                        req,
+                        select: {
+                            name: true,
+                            folderType: true
+                        },
+                        user: req.user
+                    });
+                } catch (_) {
+                // parent folder does not exist
+                }
+            }
+            if (parentFolder && parentFolder?.folderType && Array.isArray(parentFolder.folderType) && parentFolder.folderType.length > 0) {
+                throw new APIError(`The folder "${data?.name || originalDoc.name}" must have folder-type set since its parent folder ${parentFolder?.name ? `"${parentFolder?.name}" ` : ''}has a folder-type set.`, 400);
+            }
+        }
+        return data;
+    };
+
+//# sourceMappingURL=ensureSafeCollectionsChange.js.map

package/dist/folders/hooks/ensureSafeCollectionsChange.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/folders/hooks/ensureSafeCollectionsChange.ts"],"sourcesContent":["import { APIError, type CollectionBeforeValidateHook, type CollectionSlug } from '../../index.js'\nimport { extractID } from '../../utilities/extractID.js'\nimport { getTranslatedLabel } from '../../utilities/getTranslatedLabel.js'\n\nexport const ensureSafeCollectionsChange =\n  ({ foldersSlug }: { foldersSlug: CollectionSlug }): CollectionBeforeValidateHook =>\n  async ({ data, originalDoc, req }) => {\n    const currentFolderID = extractID(originalDoc || {})\n    const parentFolderID = extractID(data?.folder || originalDoc?.folder || {})\n    if (Array.isArray(data?.folderType) && data.folderType.length > 0) {\n      const folderType = data.folderType as string[]\n      const currentlyAssignedCollections: string[] | undefined =\n        Array.isArray(originalDoc?.folderType) && originalDoc.folderType.length > 0\n          ? originalDoc.folderType\n          : undefined\n      /**\n       * Check if the assigned collections have changed.\n       * example:\n       * - originalAssignedCollections: ['posts', 'pages']\n       * - folderType: ['posts']\n       *\n       * The user is narrowing the types of documents that can be associated with this folder.\n       * If the user is only expanding the types of documents that can be associated with this folder,\n       * we do not need to do anything.\n       */\n      const newCollections = currentlyAssignedCollections\n        ? // user is narrowing the current scope of the folder\n          currentlyAssignedCollections.filter((c) => !folderType.includes(c))\n        : // user is adding a scope to the folder\n          folderType\n\n      if (newCollections && newCollections.length > 0) {\n        let hasDependentDocuments = false\n        if (typeof currentFolderID === 'string' || typeof currentFolderID === 'number') {\n          const childDocumentsResult = await req.payload.findByID({\n            id: currentFolderID,\n            collection: foldersSlug,\n            joins: {\n              documentsAndFolders: {\n                limit: 100_000_000,\n                where: {\n                  or: [\n                    {\n                      relationTo: {\n                        in: newCollections,\n                      },\n                    },\n                  ],\n                },\n              },\n            },\n            overrideAccess: true,\n            req,\n          })\n\n          hasDependentDocuments = childDocumentsResult.documentsAndFolders.docs.length > 0\n        }\n\n        // matches folders that are directly related to the removed collections\n        let hasDependentFolders = false\n        if (\n          !hasDependentDocuments &&\n          (typeof currentFolderID === 'string' || typeof currentFolderID === 'number')\n        ) {\n          const childFoldersResult = await req.payload.find({\n            collection: foldersSlug,\n            limit: 1,\n            req,\n            where: {\n              and: [\n                {\n                  folderType: {\n                    in: newCollections,\n                  },\n                },\n                {\n                  folder: {\n                    equals: currentFolderID,\n                  },\n                },\n              ],\n            },\n          })\n          hasDependentFolders = childFoldersResult.totalDocs > 0\n        }\n\n        if (hasDependentDocuments || hasDependentFolders) {\n          const translatedLabels = newCollections.map((collectionSlug) => {\n            if (req.payload.collections[collectionSlug]?.config.labels.singular) {\n              return getTranslatedLabel(\n                req.payload.collections[collectionSlug]?.config.labels.plural,\n                req.i18n,\n              )\n            }\n            return collectionSlug\n          })\n\n          throw new APIError(\n            `The folder \"${data.name || originalDoc.name}\" contains ${hasDependentDocuments ? 'documents' : 'folders'} that still belong to the following collections: ${translatedLabels.join(', ')}`,\n            400,\n          )\n        }\n        return data\n      }\n    } else if (\n      (data?.folderType === null ||\n        (Array.isArray(data?.folderType) && data?.folderType.length === 0)) &&\n      parentFolderID\n    ) {\n      // attempting to set the folderType to catch-all, so we need to ensure that the parent allows this\n      let parentFolder\n      if (typeof parentFolderID === 'string' || typeof parentFolderID === 'number') {\n        try {\n          parentFolder = await req.payload.findByID({\n            id: parentFolderID,\n            collection: foldersSlug,\n            overrideAccess: true,\n            req,\n            select: {\n              name: true,\n              folderType: true,\n            },\n            user: req.user,\n          })\n        } catch (_) {\n          // parent folder does not exist\n        }\n      }\n\n      if (\n        parentFolder &&\n        parentFolder?.folderType &&\n        Array.isArray(parentFolder.folderType) &&\n        parentFolder.folderType.length > 0\n      ) {\n        throw new APIError(\n          `The folder \"${data?.name || originalDoc.name}\" must have folder-type set since its parent folder ${parentFolder?.name ? `\"${parentFolder?.name}\" ` : ''}has a folder-type set.`,\n          400,\n        )\n      }\n    }\n\n    return data\n  }\n"],"names":["APIError","extractID","getTranslatedLabel","ensureSafeCollectionsChange","foldersSlug","data","originalDoc","req","currentFolderID","parentFolderID","folder","Array","isArray","folderType","length","currentlyAssignedCollections","undefined","newCollections","filter","c","includes","hasDependentDocuments","childDocumentsResult","payload","findByID","id","collection","joins","documentsAndFolders","limit","where","or","relationTo","in","overrideAccess","docs","hasDependentFolders","childFoldersResult","find","and","equals","totalDocs","translatedLabels","map","collectionSlug","collections","config","labels","singular","plural","i18n","name","join","parentFolder","select","user","_"],"mappings":"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"}

package/dist/folders/hooks/reparentChildFolder.d.ts

@@ -0,0 +1,24 @@
+import type { CollectionAfterChangeHook } from '../../index.js';
+/**
+ * If a parent is moved into a child folder, we need to re-parent the child
+ *
+ * @example
+ *
+ * ```ts
+    → F1
+      → F2
+        → F2A
+      → F3
+
+  Moving F1 → F2A becomes:
+
+    → F2A
+      → F1
+        → F2
+        → F3
+  ```
+ */
+export declare const reparentChildFolder: ({ folderFieldName, }: {
+    folderFieldName: string;
+}) => CollectionAfterChangeHook;
+//# sourceMappingURL=reparentChildFolder.d.ts.map

package/dist/folders/hooks/reparentChildFolder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reparentChildFolder.d.ts","sourceRoot":"","sources":["../../../src/folders/hooks/reparentChildFolder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAW,MAAM,gBAAgB,CAAA;AAmDxE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,yBAE7B;IACD,eAAe,EAAE,MAAM,CAAA;CACxB,KAAG,yBAkCH,CAAA"}

package/dist/folders/hooks/reparentChildFolder.js

@@ -0,0 +1,72 @@
+import { extractID } from '../../utilities/extractID.js';
+/**
+ * Determines if a child folder belongs to a parent folder by
+ * recursively checking upwards through the folder hierarchy.
+ */ async function isChildOfFolder({ folderCollectionSlug, folderFieldName, folderID, parentIDToFind, payload }) {
+    const parentFolder = await payload.findByID({
+        id: folderID,
+        collection: folderCollectionSlug
+    });
+    const parentFolderID = parentFolder[folderFieldName] ? extractID(parentFolder[folderFieldName]) : undefined;
+    if (!parentFolderID) {
+        // made it to the root
+        return false;
+    }
+    if (parentFolderID === parentIDToFind) {
+        // found match, would be cyclic
+        return true;
+    }
+    return isChildOfFolder({
+        folderCollectionSlug,
+        folderFieldName,
+        folderID: parentFolderID,
+        parentIDToFind,
+        payload
+    });
+}
+/**
+ * If a parent is moved into a child folder, we need to re-parent the child
+ * 
+ * @example
+ * 
+ * ```ts
+    → F1
+      → F2
+        → F2A
+      → F3
+
+  Moving F1 → F2A becomes:
+
+    → F2A
+      → F1
+        → F2
+        → F3
+  ```
+ */ export const reparentChildFolder = ({ folderFieldName })=>{
+    return async ({ doc, previousDoc, req })=>{
+        if (previousDoc[folderFieldName] !== doc[folderFieldName] && doc[folderFieldName] && req.payload.config.folders) {
+            const newParentFolderID = extractID(doc[folderFieldName]);
+            const isMovingToChild = newParentFolderID ? await isChildOfFolder({
+                folderCollectionSlug: req.payload.config.folders.slug,
+                folderFieldName,
+                folderID: newParentFolderID,
+                parentIDToFind: doc.id,
+                payload: req.payload
+            }) : false;
+            if (isMovingToChild) {
+                // if the folder was moved into a child folder, the child folder needs
+                // to be re-parented with the parent of the folder that was moved
+                await req.payload.update({
+                    id: newParentFolderID,
+                    collection: req.payload.config.folders.slug,
+                    data: {
+                        [folderFieldName]: previousDoc[folderFieldName] ? extractID(previousDoc[folderFieldName]) : null
+                    },
+                    req
+                });
+            }
+        }
+    };
+};
+
+//# sourceMappingURL=reparentChildFolder.js.map

package/dist/folders/hooks/reparentChildFolder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/folders/hooks/reparentChildFolder.ts"],"sourcesContent":["import type { CollectionAfterChangeHook, Payload } from '../../index.js'\n\nimport { extractID } from '../../utilities/extractID.js'\n\ntype Args = {\n  folderCollectionSlug: string\n  folderFieldName: string\n  folderID: number | string\n  parentIDToFind: number | string\n  payload: Payload\n}\n\n/**\n * Determines if a child folder belongs to a parent folder by\n * recursively checking upwards through the folder hierarchy.\n */\nasync function isChildOfFolder({\n  folderCollectionSlug,\n  folderFieldName,\n  folderID,\n  parentIDToFind,\n  payload,\n}: Args): Promise<boolean> {\n  const parentFolder = await payload.findByID({\n    id: folderID,\n    collection: folderCollectionSlug,\n  })\n\n  const parentFolderID = parentFolder[folderFieldName]\n    ? extractID(parentFolder[folderFieldName])\n    : undefined\n\n  if (!parentFolderID) {\n    // made it to the root\n    return false\n  }\n\n  if (parentFolderID === parentIDToFind) {\n    // found match, would be cyclic\n    return true\n  }\n\n  return isChildOfFolder({\n    folderCollectionSlug,\n    folderFieldName,\n    folderID: parentFolderID,\n    parentIDToFind,\n    payload,\n  })\n}\n\n/**\n * If a parent is moved into a child folder, we need to re-parent the child\n * \n * @example\n * \n * ```ts\n    → F1\n      → F2\n        → F2A\n      → F3\n\n  Moving F1 → F2A becomes:\n\n    → F2A\n      → F1\n        → F2\n        → F3\n  ```\n */\nexport const reparentChildFolder = ({\n  folderFieldName,\n}: {\n  folderFieldName: string\n}): CollectionAfterChangeHook => {\n  return async ({ doc, previousDoc, req }) => {\n    if (\n      previousDoc[folderFieldName] !== doc[folderFieldName] &&\n      doc[folderFieldName] &&\n      req.payload.config.folders\n    ) {\n      const newParentFolderID = extractID(doc[folderFieldName])\n      const isMovingToChild = newParentFolderID\n        ? await isChildOfFolder({\n            folderCollectionSlug: req.payload.config.folders.slug,\n            folderFieldName,\n            folderID: newParentFolderID,\n            parentIDToFind: doc.id,\n            payload: req.payload,\n          })\n        : false\n\n      if (isMovingToChild) {\n        // if the folder was moved into a child folder, the child folder needs\n        // to be re-parented with the parent of the folder that was moved\n        await req.payload.update({\n          id: newParentFolderID,\n          collection: req.payload.config.folders.slug,\n          data: {\n            [folderFieldName]: previousDoc[folderFieldName]\n              ? extractID(previousDoc[folderFieldName])\n              : null,\n          },\n          req,\n        })\n      }\n    }\n  }\n}\n"],"names":["extractID","isChildOfFolder","folderCollectionSlug","folderFieldName","folderID","parentIDToFind","payload","parentFolder","findByID","id","collection","parentFolderID","undefined","reparentChildFolder","doc","previousDoc","req","config","folders","newParentFolderID","isMovingToChild","slug","update","data"],"mappings":"AAEA,SAASA,SAAS,QAAQ,+BAA8B;AAUxD;;;CAGC,GACD,eAAeC,gBAAgB,EAC7BC,oBAAoB,EACpBC,eAAe,EACfC,QAAQ,EACRC,cAAc,EACdC,OAAO,EACF;IACL,MAAMC,eAAe,MAAMD,QAAQE,QAAQ,CAAC;QAC1CC,IAAIL;QACJM,YAAYR;IACd;IAEA,MAAMS,iBAAiBJ,YAAY,CAACJ,gBAAgB,GAChDH,UAAUO,YAAY,CAACJ,gBAAgB,IACvCS;IAEJ,IAAI,CAACD,gBAAgB;QACnB,sBAAsB;QACtB,OAAO;IACT;IAEA,IAAIA,mBAAmBN,gBAAgB;QACrC,+BAA+B;QAC/B,OAAO;IACT;IAEA,OAAOJ,gBAAgB;QACrBC;QACAC;QACAC,UAAUO;QACVN;QACAC;IACF;AACF;AAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,MAAMO,sBAAsB,CAAC,EAClCV,eAAe,EAGhB;IACC,OAAO,OAAO,EAAEW,GAAG,EAAEC,WAAW,EAAEC,GAAG,EAAE;QACrC,IACED,WAAW,CAACZ,gBAAgB,KAAKW,GAAG,CAACX,gBAAgB,IACrDW,GAAG,CAACX,gBAAgB,IACpBa,IAAIV,OAAO,CAACW,MAAM,CAACC,OAAO,EAC1B;YACA,MAAMC,oBAAoBnB,UAAUc,GAAG,CAACX,gBAAgB;YACxD,MAAMiB,kBAAkBD,oBACpB,MAAMlB,gBAAgB;gBACpBC,sBAAsBc,IAAIV,OAAO,CAACW,MAAM,CAACC,OAAO,CAACG,IAAI;gBACrDlB;gBACAC,UAAUe;gBACVd,gBAAgBS,IAAIL,EAAE;gBACtBH,SAASU,IAAIV,OAAO;YACtB,KACA;YAEJ,IAAIc,iBAAiB;gBACnB,sEAAsE;gBACtE,iEAAiE;gBACjE,MAAMJ,IAAIV,OAAO,CAACgB,MAAM,CAAC;oBACvBb,IAAIU;oBACJT,YAAYM,IAAIV,OAAO,CAACW,MAAM,CAACC,OAAO,CAACG,IAAI;oBAC3CE,MAAM;wBACJ,CAACpB,gBAAgB,EAAEY,WAAW,CAACZ,gBAAgB,GAC3CH,UAAUe,WAAW,CAACZ,gBAAgB,IACtC;oBACN;oBACAa;gBACF;YACF;QACF;IACF;AACF,EAAC"}

package/dist/folders/types.d.ts

@@ -0,0 +1,118 @@
+import type { CollectionConfig, TypeWithID } from '../collections/config/types.js';
+import type { CollectionSlug, SanitizedCollectionConfig } from '../index.js';
+import type { Document } from '../types/index.js';
+export type FolderInterface = {
+    documentsAndFolders?: {
+        docs: {
+            relationTo: CollectionSlug;
+            value: Document;
+        }[];
+    };
+    folder?: FolderInterface | (number | string | undefined);
+    folderType: CollectionSlug[];
+    name: string;
+} & TypeWithID;
+export type FolderBreadcrumb = {
+    folderType?: CollectionSlug[];
+    id: null | number | string;
+    name: string;
+};
+export type Subfolder = {
+    fileCount: number;
+    hasSubfolders: boolean;
+    id: number | string;
+    name: string;
+    subfolderCount: number;
+};
+export type FolderEnabledColection = {
+    admin: {
+        custom: {
+            folderCollectionSlug: CollectionSlug;
+        };
+    };
+    slug: CollectionSlug;
+} & SanitizedCollectionConfig;
+/**
+ * `${relationTo}-${id}` is used as a key for the item
+ */
+export type FolderDocumentItemKey = `${string}-${number | string}`;
+/**
+ * Needed for document card view for upload enabled collections
+ */
+type DocumentMediaData = {
+    filename?: string;
+    mimeType?: string;
+    url?: string;
+};
+/**
+ * A generic structure for a folder or document item.
+ */
+export type FolderOrDocument = {
+    itemKey: FolderDocumentItemKey;
+    relationTo: CollectionSlug;
+    value: {
+        _folderOrDocumentTitle: string;
+        createdAt?: string;
+        folderID?: number | string;
+        folderType: CollectionSlug[];
+        id: number | string;
+        updatedAt?: string;
+    } & DocumentMediaData;
+};
+export type GetFolderDataResult = {
+    breadcrumbs: FolderBreadcrumb[] | null;
+    documents: FolderOrDocument[];
+    folderAssignedCollections: CollectionSlug[] | undefined;
+    subfolders: FolderOrDocument[];
+};
+export type RootFoldersConfiguration = {
+    /**
+     * If true, the browse by folder view will be enabled
+     *
+     * @default true
+     */
+    browseByFolder?: boolean;
+    /**
+     * An array of functions to be ran when the folder collection is initialized
+     * This allows plugins to modify the collection configuration
+     */
+    collectionOverrides?: (({ collection, }: {
+        collection: Omit<CollectionConfig, 'trash'>;
+    }) => Omit<CollectionConfig, 'trash'> | Promise<Omit<CollectionConfig, 'trash'>>)[];
+    /**
+     * If true, you can scope folders to specific collections.
+     *
+     * @default true
+     */
+    collectionSpecific?: boolean;
+    /**
+     * Ability to view hidden fields and collections related to folders
+     *
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * The Folder field name
+     *
+     * @default "folder"
+     */
+    fieldName?: string;
+    /**
+     * Slug for the folder collection
+     *
+     * @default "payload-folders"
+     */
+    slug?: string;
+};
+export type CollectionFoldersConfiguration = {
+    /**
+     * If true, the collection will be included in the browse by folder view
+     *
+     * @default true
+     */
+    browseByFolder?: boolean;
+};
+type BaseFolderSortKeys = 'createdAt' | 'name' | 'updatedAt';
+export type FolderSortKeys = `-${BaseFolderSortKeys}` | BaseFolderSortKeys;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/folders/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/folders/types.ts"],"names":[],"mappings":"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"}

package/dist/folders/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

package/dist/folders/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/folders/types.ts"],"sourcesContent":["import type { CollectionConfig, TypeWithID } from '../collections/config/types.js'\nimport type { CollectionSlug, SanitizedCollectionConfig } from '../index.js'\nimport type { Document } from '../types/index.js'\n\nexport type FolderInterface = {\n  documentsAndFolders?: {\n    docs: {\n      relationTo: CollectionSlug\n      value: Document\n    }[]\n  }\n  folder?: FolderInterface | (number | string | undefined)\n  folderType: CollectionSlug[]\n  name: string\n} & TypeWithID\n\nexport type FolderBreadcrumb = {\n  folderType?: CollectionSlug[]\n  id: null | number | string\n  name: string\n}\n\nexport type Subfolder = {\n  fileCount: number\n  hasSubfolders: boolean\n  id: number | string\n  name: string\n  subfolderCount: number\n}\n\nexport type FolderEnabledColection = {\n  admin: {\n    custom: {\n      folderCollectionSlug: CollectionSlug\n    }\n  }\n  slug: CollectionSlug\n} & SanitizedCollectionConfig\n\n/**\n * `${relationTo}-${id}` is used as a key for the item\n */\nexport type FolderDocumentItemKey = `${string}-${number | string}`\n\n/**\n * Needed for document card view for upload enabled collections\n */\ntype DocumentMediaData = {\n  filename?: string\n  mimeType?: string\n  url?: string\n}\n/**\n * A generic structure for a folder or document item.\n */\nexport type FolderOrDocument = {\n  itemKey: FolderDocumentItemKey\n  relationTo: CollectionSlug\n  value: {\n    _folderOrDocumentTitle: string\n    createdAt?: string\n    folderID?: number | string\n    folderType: CollectionSlug[]\n    id: number | string\n    updatedAt?: string\n  } & DocumentMediaData\n}\n\nexport type GetFolderDataResult = {\n  breadcrumbs: FolderBreadcrumb[] | null\n  documents: FolderOrDocument[]\n  folderAssignedCollections: CollectionSlug[] | undefined\n  subfolders: FolderOrDocument[]\n}\n\nexport type RootFoldersConfiguration = {\n  /**\n   * If true, the browse by folder view will be enabled\n   *\n   * @default true\n   */\n  browseByFolder?: boolean\n  /**\n   * An array of functions to be ran when the folder collection is initialized\n   * This allows plugins to modify the collection configuration\n   */\n  collectionOverrides?: (({\n    collection,\n  }: {\n    collection: Omit<CollectionConfig, 'trash'>\n  }) => Omit<CollectionConfig, 'trash'> | Promise<Omit<CollectionConfig, 'trash'>>)[]\n  /**\n   * If true, you can scope folders to specific collections.\n   *\n   * @default true\n   */\n  collectionSpecific?: boolean\n  /**\n   * Ability to view hidden fields and collections related to folders\n   *\n   * @default false\n   */\n  debug?: boolean\n  /**\n   * The Folder field name\n   *\n   * @default \"folder\"\n   */\n  fieldName?: string\n  /**\n   * Slug for the folder collection\n   *\n   * @default \"payload-folders\"\n   */\n  slug?: string\n}\n\nexport type CollectionFoldersConfiguration = {\n  /**\n   * If true, the collection will be included in the browse by folder view\n   *\n   * @default true\n   */\n  browseByFolder?: boolean\n}\n\ntype BaseFolderSortKeys = 'createdAt' | 'name' | 'updatedAt'\n\nexport type FolderSortKeys = `-${BaseFolderSortKeys}` | BaseFolderSortKeys\n"],"names":[],"mappings":"AAgIA,WAA0E"}

package/dist/folders/utils/buildFolderWhereConstraints.d.ts

@@ -0,0 +1,13 @@
+import type { SanitizedCollectionConfig } from '../../collections/config/types.js';
+import type { PayloadRequest, Where } from '../../types/index.js';
+type Args = {
+    collectionConfig: SanitizedCollectionConfig;
+    folderID?: number | string;
+    localeCode?: string;
+    req: PayloadRequest;
+    search?: string;
+    sort?: string;
+};
+export declare function buildFolderWhereConstraints({ collectionConfig, folderID, localeCode, req, search, sort, }: Args): Promise<undefined | Where>;
+export {};
+//# sourceMappingURL=buildFolderWhereConstraints.d.ts.map

package/dist/folders/utils/buildFolderWhereConstraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildFolderWhereConstraints.d.ts","sourceRoot":"","sources":["../../../src/folders/utils/buildFolderWhereConstraints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAKjE,KAAK,IAAI,GAAG;IACV,gBAAgB,EAAE,yBAAyB,CAAA;IAC3C,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,GAAG,EAAE,cAAc,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AACD,wBAAsB,2BAA2B,CAAC,EAChD,gBAAgB,EAChB,QAAQ,EACR,UAAU,EACV,GAAG,EACH,MAAW,EACX,IAAI,GACL,EAAE,IAAI,GAAG,OAAO,CAAC,SAAS,GAAG,KAAK,CAAC,CAoDnC"}

package/dist/folders/utils/buildFolderWhereConstraints.js

@@ -0,0 +1,45 @@
+import { combineWhereConstraints } from '../../utilities/combineWhereConstraints.js';
+import { mergeListSearchAndWhere } from '../../utilities/mergeListSearchAndWhere.js';
+export async function buildFolderWhereConstraints({ collectionConfig, folderID, localeCode, req, search = '', sort }) {
+    const constraints = [
+        mergeListSearchAndWhere({
+            collectionConfig,
+            search
+        })
+    ];
+    const baseFilterConstraint = await (collectionConfig.admin?.baseFilter ?? collectionConfig.admin?.baseListFilter)?.({
+        limit: 0,
+        locale: localeCode,
+        page: 1,
+        req,
+        sort: sort || (typeof collectionConfig.defaultSort === 'string' ? collectionConfig.defaultSort : 'id')
+    });
+    if (baseFilterConstraint) {
+        constraints.push(baseFilterConstraint);
+    }
+    if (folderID) {
+        // build folder join where constraints
+        constraints.push({
+            relationTo: {
+                equals: collectionConfig.slug
+            }
+        });
+        // join queries need to omit trashed documents
+        if (collectionConfig.trash) {
+            constraints.push({
+                deletedAt: {
+                    exists: false
+                }
+            });
+        }
+    }
+    const filteredConstraints = constraints.filter(Boolean);
+    if (filteredConstraints.length > 1) {
+        return combineWhereConstraints(filteredConstraints);
+    } else if (filteredConstraints.length === 1) {
+        return filteredConstraints[0];
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=buildFolderWhereConstraints.js.map

package/dist/folders/utils/buildFolderWhereConstraints.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/folders/utils/buildFolderWhereConstraints.ts"],"sourcesContent":["import type { SanitizedCollectionConfig } from '../../collections/config/types.js'\nimport type { PayloadRequest, Where } from '../../types/index.js'\n\nimport { combineWhereConstraints } from '../../utilities/combineWhereConstraints.js'\nimport { mergeListSearchAndWhere } from '../../utilities/mergeListSearchAndWhere.js'\n\ntype Args = {\n  collectionConfig: SanitizedCollectionConfig\n  folderID?: number | string\n  localeCode?: string\n  req: PayloadRequest\n  search?: string\n  sort?: string\n}\nexport async function buildFolderWhereConstraints({\n  collectionConfig,\n  folderID,\n  localeCode,\n  req,\n  search = '',\n  sort,\n}: Args): Promise<undefined | Where> {\n  const constraints: Where[] = [\n    mergeListSearchAndWhere({\n      collectionConfig,\n      search,\n      // where // cannot have where since fields in folders and collection will differ\n    }),\n  ]\n\n  const baseFilterConstraint = await (\n    collectionConfig.admin?.baseFilter ?? collectionConfig.admin?.baseListFilter\n  )?.({\n    limit: 0,\n    locale: localeCode,\n    page: 1,\n    req,\n    sort:\n      sort ||\n      (typeof collectionConfig.defaultSort === 'string' ? collectionConfig.defaultSort : 'id'),\n  })\n\n  if (baseFilterConstraint) {\n    constraints.push(baseFilterConstraint)\n  }\n\n  if (folderID) {\n    // build folder join where constraints\n    constraints.push({\n      relationTo: {\n        equals: collectionConfig.slug,\n      },\n    })\n\n    // join queries need to omit trashed documents\n    if (collectionConfig.trash) {\n      constraints.push({\n        deletedAt: {\n          exists: false,\n        },\n      })\n    }\n  }\n\n  const filteredConstraints = constraints.filter(Boolean)\n\n  if (filteredConstraints.length > 1) {\n    return combineWhereConstraints(filteredConstraints)\n  } else if (filteredConstraints.length === 1) {\n    return filteredConstraints[0]\n  }\n\n  return undefined\n}\n"],"names":["combineWhereConstraints","mergeListSearchAndWhere","buildFolderWhereConstraints","collectionConfig","folderID","localeCode","req","search","sort","constraints","baseFilterConstraint","admin","baseFilter","baseListFilter","limit","locale","page","defaultSort","push","relationTo","equals","slug","trash","deletedAt","exists","filteredConstraints","filter","Boolean","length","undefined"],"mappings":"AAGA,SAASA,uBAAuB,QAAQ,6CAA4C;AACpF,SAASC,uBAAuB,QAAQ,6CAA4C;AAUpF,OAAO,eAAeC,4BAA4B,EAChDC,gBAAgB,EAChBC,QAAQ,EACRC,UAAU,EACVC,GAAG,EACHC,SAAS,EAAE,EACXC,IAAI,EACC;IACL,MAAMC,cAAuB;QAC3BR,wBAAwB;YACtBE;YACAI;QAEF;KACD;IAED,MAAMG,uBAAuB,MAC3BP,CAAAA,iBAAiBQ,KAAK,EAAEC,cAAcT,iBAAiBQ,KAAK,EAAEE,cAAa,IACzE;QACFC,OAAO;QACPC,QAAQV;QACRW,MAAM;QACNV;QACAE,MACEA,QACC,CAAA,OAAOL,iBAAiBc,WAAW,KAAK,WAAWd,iBAAiBc,WAAW,GAAG,IAAG;IAC1F;IAEA,IAAIP,sBAAsB;QACxBD,YAAYS,IAAI,CAACR;IACnB;IAEA,IAAIN,UAAU;QACZ,sCAAsC;QACtCK,YAAYS,IAAI,CAAC;YACfC,YAAY;gBACVC,QAAQjB,iBAAiBkB,IAAI;YAC/B;QACF;QAEA,8CAA8C;QAC9C,IAAIlB,iBAAiBmB,KAAK,EAAE;YAC1Bb,YAAYS,IAAI,CAAC;gBACfK,WAAW;oBACTC,QAAQ;gBACV;YACF;QACF;IACF;IAEA,MAAMC,sBAAsBhB,YAAYiB,MAAM,CAACC;IAE/C,IAAIF,oBAAoBG,MAAM,GAAG,GAAG;QAClC,OAAO5B,wBAAwByB;IACjC,OAAO,IAAIA,oBAAoBG,MAAM,KAAK,GAAG;QAC3C,OAAOH,mBAAmB,CAAC,EAAE;IAC/B;IAEA,OAAOI;AACT"}

package/dist/folders/utils/formatFolderOrDocumentItem.d.ts

@@ -0,0 +1,12 @@
+import type { CollectionSlug, Document } from '../../index.js';
+import type { FolderOrDocument } from '../types.js';
+type Args = {
+    folderFieldName: string;
+    isUpload: boolean;
+    relationTo: CollectionSlug;
+    useAsTitle?: string;
+    value: Document;
+};
+export declare function formatFolderOrDocumentItem({ folderFieldName, isUpload, relationTo, useAsTitle, value, }: Args): FolderOrDocument;
+export {};
+//# sourceMappingURL=formatFolderOrDocumentItem.d.ts.map

package/dist/folders/utils/formatFolderOrDocumentItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatFolderOrDocumentItem.d.ts","sourceRoot":"","sources":["../../../src/folders/utils/formatFolderOrDocumentItem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAKnD,KAAK,IAAI,GAAG;IACV,eAAe,EAAE,MAAM,CAAA;IACvB,QAAQ,EAAE,OAAO,CAAA;IACjB,UAAU,EAAE,cAAc,CAAA;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,QAAQ,CAAA;CAChB,CAAA;AACD,wBAAgB,0BAA0B,CAAC,EACzC,eAAe,EACf,QAAQ,EACR,UAAU,EACV,UAAU,EACV,KAAK,GACN,EAAE,IAAI,GAAG,gBAAgB,CA+BzB"}

package/dist/folders/utils/formatFolderOrDocumentItem.js

@@ -0,0 +1,30 @@
+import { isImage } from '../../uploads/isImage.js';
+import { getBestFitFromSizes } from '../../utilities/getBestFitFromSizes.js';
+export function formatFolderOrDocumentItem({ folderFieldName, isUpload, relationTo, useAsTitle, value }) {
+    const itemValue = {
+        id: value?.id,
+        _folderOrDocumentTitle: String(useAsTitle && value?.[useAsTitle] || value['id']),
+        createdAt: value?.createdAt,
+        folderID: value?.[folderFieldName],
+        folderType: value?.folderType || [],
+        updatedAt: value?.updatedAt
+    };
+    if (isUpload) {
+        itemValue.filename = value.filename;
+        itemValue.mimeType = value.mimeType;
+        itemValue.url = value.thumbnailURL || (isImage(value.mimeType) ? getBestFitFromSizes({
+            sizes: value.sizes,
+            targetSizeMax: 520,
+            targetSizeMin: 300,
+            url: value.url,
+            width: value.width
+        }) : undefined);
+    }
+    return {
+        itemKey: `${relationTo}-${value.id}`,
+        relationTo,
+        value: itemValue
+    };
+}
+
+//# sourceMappingURL=formatFolderOrDocumentItem.js.map

package/dist/folders/utils/formatFolderOrDocumentItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/folders/utils/formatFolderOrDocumentItem.ts"],"sourcesContent":["import type { CollectionSlug, Document } from '../../index.js'\nimport type { FolderOrDocument } from '../types.js'\n\nimport { isImage } from '../../uploads/isImage.js'\nimport { getBestFitFromSizes } from '../../utilities/getBestFitFromSizes.js'\n\ntype Args = {\n  folderFieldName: string\n  isUpload: boolean\n  relationTo: CollectionSlug\n  useAsTitle?: string\n  value: Document\n}\nexport function formatFolderOrDocumentItem({\n  folderFieldName,\n  isUpload,\n  relationTo,\n  useAsTitle,\n  value,\n}: Args): FolderOrDocument {\n  const itemValue: FolderOrDocument['value'] = {\n    id: value?.id,\n    _folderOrDocumentTitle: String((useAsTitle && value?.[useAsTitle]) || value['id']),\n    createdAt: value?.createdAt,\n    folderID: value?.[folderFieldName],\n    folderType: value?.folderType || [],\n    updatedAt: value?.updatedAt,\n  }\n\n  if (isUpload) {\n    itemValue.filename = value.filename\n    itemValue.mimeType = value.mimeType\n    itemValue.url =\n      value.thumbnailURL ||\n      (isImage(value.mimeType)\n        ? getBestFitFromSizes({\n            sizes: value.sizes,\n            targetSizeMax: 520,\n            targetSizeMin: 300,\n            url: value.url,\n            width: value.width,\n          })\n        : undefined)\n  }\n\n  return {\n    itemKey: `${relationTo}-${value.id}`,\n    relationTo,\n    value: itemValue,\n  }\n}\n"],"names":["isImage","getBestFitFromSizes","formatFolderOrDocumentItem","folderFieldName","isUpload","relationTo","useAsTitle","value","itemValue","id","_folderOrDocumentTitle","String","createdAt","folderID","folderType","updatedAt","filename","mimeType","url","thumbnailURL","sizes","targetSizeMax","targetSizeMin","width","undefined","itemKey"],"mappings":"AAGA,SAASA,OAAO,QAAQ,2BAA0B;AAClD,SAASC,mBAAmB,QAAQ,yCAAwC;AAS5E,OAAO,SAASC,2BAA2B,EACzCC,eAAe,EACfC,QAAQ,EACRC,UAAU,EACVC,UAAU,EACVC,KAAK,EACA;IACL,MAAMC,YAAuC;QAC3CC,IAAIF,OAAOE;QACXC,wBAAwBC,OAAO,AAACL,cAAcC,OAAO,CAACD,WAAW,IAAKC,KAAK,CAAC,KAAK;QACjFK,WAAWL,OAAOK;QAClBC,UAAUN,OAAO,CAACJ,gBAAgB;QAClCW,YAAYP,OAAOO,cAAc,EAAE;QACnCC,WAAWR,OAAOQ;IACpB;IAEA,IAAIX,UAAU;QACZI,UAAUQ,QAAQ,GAAGT,MAAMS,QAAQ;QACnCR,UAAUS,QAAQ,GAAGV,MAAMU,QAAQ;QACnCT,UAAUU,GAAG,GACXX,MAAMY,YAAY,IACjBnB,CAAAA,QAAQO,MAAMU,QAAQ,IACnBhB,oBAAoB;YAClBmB,OAAOb,MAAMa,KAAK;YAClBC,eAAe;YACfC,eAAe;YACfJ,KAAKX,MAAMW,GAAG;YACdK,OAAOhB,MAAMgB,KAAK;QACpB,KACAC,SAAQ;IAChB;IAEA,OAAO;QACLC,SAAS,GAAGpB,WAAW,CAAC,EAAEE,MAAME,EAAE,EAAE;QACpCJ;QACAE,OAAOC;IACT;AACF"}

package/dist/folders/utils/getFolderBreadcrumbs.d.ts

@@ -0,0 +1,14 @@
+import type { PayloadRequest } from '../../types/index.js';
+import type { FolderBreadcrumb } from '../types.js';
+type GetFolderBreadcrumbsArgs = {
+    breadcrumbs?: FolderBreadcrumb[];
+    folderID?: number | string;
+    req: PayloadRequest;
+};
+/**
+ * Builds breadcrumbs up from child folder
+ * all the way up to root folder
+ */
+export declare const getFolderBreadcrumbs: ({ breadcrumbs, folderID, req, }: GetFolderBreadcrumbsArgs) => Promise<FolderBreadcrumb[] | null>;
+export {};
+//# sourceMappingURL=getFolderBreadcrumbs.d.ts.map

package/dist/folders/utils/getFolderBreadcrumbs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFolderBreadcrumbs.d.ts","sourceRoot":"","sources":["../../../src/folders/utils/getFolderBreadcrumbs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,KAAK,wBAAwB,GAAG;IAC9B,WAAW,CAAC,EAAE,gBAAgB,EAAE,CAAA;IAChC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1B,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AACD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,oCAI9B,wBAAwB,KAAG,OAAO,CAAC,gBAAgB,EAAE,GAAG,IAAI,CA8C9D,CAAA"}