payload 3.80.0-internal-debug.7019cc9 → 3.80.0-internal.0311fce

package/dist/hierarchy/createFolderField.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/createFolderField.ts"],"sourcesContent":["import type { RelationshipField, SingleRelationshipField } from '../fields/config/types.js'\n\nimport { getHierarchyFieldName } from './constants.js'\n\n/**\n * Options for creating a folder relationship field.\n * All SingleRelationshipField properties are available except name, type, relationTo, and hasMany\n * which are managed by the folder system.\n */\nexport type CreateFolderFieldOptions = {\n  /**\n   * The slug of the hierarchy collection this field references (e.g., 'folders')\n   */\n  relationTo: string\n} & Pick<Partial<SingleRelationshipField>, 'admin' | 'label' | 'required'>\n\n/**\n * Creates a relationship field for folder-style hierarchies (single-select).\n *\n * This field:\n * - Has hasMany:false (single folder selection)\n * - Uses NullField to render nothing in the form (no DOM output)\n * - Injects a header button for folder selection via miller columns UI\n *\n * Use this in your collection's fields array to add a folder relationship.\n * The field name is automatically generated based on the hierarchy slug.\n *\n * @example\n * import { createFolderField } from 'payload'\n *\n * const Posts: CollectionConfig = {\n *   slug: 'posts',\n *   fields: [\n *     { name: 'title', type: 'text' },\n *     createFolderField({\n *       relationTo: 'folders',\n *       label: 'Folder',\n *     }),\n *   ],\n * }\n */\nexport function createFolderField(options: CreateFolderFieldOptions): RelationshipField {\n  const { admin: adminOverrides, label, relationTo, ...restOptions } = options\n  const { components: componentOverrides, ...restAdminOverrides } = adminOverrides || {}\n\n  return {\n    name: getHierarchyFieldName(relationTo),\n    type: 'relationship',\n    admin: {\n      position: 'sidebar',\n      ...restAdminOverrides,\n      components: {\n        // NullField renders nothing - the header button handles the UI\n        Field: '@payloadcms/ui#NullField',\n        ...componentOverrides,\n      },\n    },\n    custom: {\n      hierarchy: {\n        injectHeaderButton: true,\n      },\n    },\n    hasMany: false,\n    index: true,\n    label: label ?? 'Folder',\n    relationTo,\n    ...restOptions,\n  } as RelationshipField\n}\n"],"names":["getHierarchyFieldName","createFolderField","options","admin","adminOverrides","label","relationTo","restOptions","components","componentOverrides","restAdminOverrides","name","type","position","Field","custom","hierarchy","injectHeaderButton","hasMany","index"],"mappings":"AAEA,SAASA,qBAAqB,QAAQ,iBAAgB;AActD;;;;;;;;;;;;;;;;;;;;;;;;CAwBC,GACD,OAAO,SAASC,kBAAkBC,OAAiC;IACjE,MAAM,EAAEC,OAAOC,cAAc,EAAEC,KAAK,EAAEC,UAAU,EAAE,GAAGC,aAAa,GAAGL;IACrE,MAAM,EAAEM,YAAYC,kBAAkB,EAAE,GAAGC,oBAAoB,GAAGN,kBAAkB,CAAC;IAErF,OAAO;QACLO,MAAMX,sBAAsBM;QAC5BM,MAAM;QACNT,OAAO;YACLU,UAAU;YACV,GAAGH,kBAAkB;YACrBF,YAAY;gBACV,+DAA+D;gBAC/DM,OAAO;gBACP,GAAGL,kBAAkB;YACvB;QACF;QACAM,QAAQ;YACNC,WAAW;gBACTC,oBAAoB;YACtB;QACF;QACAC,SAAS;QACTC,OAAO;QACPd,OAAOA,SAAS;QAChBC;QACA,GAAGC,WAAW;IAChB;AACF"}

package/dist/hierarchy/createFoldersCollection.d.ts

@@ -0,0 +1,57 @@
+import type { CollectionConfig } from '../collections/config/types.js';
+import type { HierarchyConfig } from './types.js';
+/**
+ * Hierarchy options for folder collections - all fields optional since defaults are applied.
+ * Cannot override `allowHasMany` - folders always use single-select.
+ */
+type FolderHierarchyOptions = {
+    parentFieldName?: string;
+} & Partial<Omit<HierarchyConfig, 'allowHasMany' | 'parentFieldName'>>;
+/**
+ * Options for creating a folder collection.
+ * Same as CollectionConfig but with `useAsTitle` required.
+ */
+export type CreateFoldersCollectionOptions = {
+    /**
+     * Hierarchy configuration (defaults applied for folder behavior)
+     * Cannot override `allowHasMany` - folders always use single-select
+     */
+    hierarchy?: FolderHierarchyOptions;
+    /**
+     * Field name to use as the display title in the folder tree.
+     * Required to ensure folders display meaningful names.
+     */
+    useAsTitle: string;
+} & Omit<CollectionConfig, 'admin' | 'hierarchy'> & Partial<Pick<CollectionConfig, 'admin'>>;
+/**
+ * Creates a collection config for a folder-style hierarchy.
+ *
+ * This helper provides:
+ * - `hierarchy.allowHasMany: false` (enforced, folders are single-select)
+ * - Default folder icon component
+ * - Required `useAsTitle` to ensure folders display meaningful names
+ * - `admin.group: false` by default to hide from collections list
+ *   (folder collections are accessed via their dedicated sidebar tab)
+ *
+ * @example
+ * import { createFoldersCollection, createFolderField } from 'payload'
+ *
+ * const Folders = createFoldersCollection({
+ *   slug: 'folders',
+ *   useAsTitle: 'name',
+ *   fields: [
+ *     { name: 'name', type: 'text', required: true },
+ *   ],
+ * })
+ *
+ * // Then in related collections:
+ * const Posts: CollectionConfig = {
+ *   slug: 'posts',
+ *   fields: [
+ *     createFolderField({ relationTo: 'folders' }),
+ *   ],
+ * }
+ */
+export declare function createFoldersCollection(options: CreateFoldersCollectionOptions): CollectionConfig;
+export {};
+//# sourceMappingURL=createFoldersCollection.d.ts.map

package/dist/hierarchy/createFoldersCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFoldersCollection.d.ts","sourceRoot":"","sources":["../../src/hierarchy/createFoldersCollection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIjD;;;GAGG;AACH,KAAK,sBAAsB,GAAG;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,iBAAiB,CAAC,CAAC,CAAA;AAEtE;;;GAGG;AACH,MAAM,MAAM,8BAA8B,GAAG;IAC3C;;;OAGG;IACH,SAAS,CAAC,EAAE,sBAAsB,CAAA;IAClC;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAA;CACnB,GAAG,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,WAAW,CAAC,GAC/C,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC,CAAA;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,8BAA8B,GAAG,gBAAgB,CAiCjG"}

package/dist/hierarchy/createFoldersCollection.js

@@ -0,0 +1,63 @@
+import { getHierarchyFieldName } from './constants.js';
+/**
+ * Creates a collection config for a folder-style hierarchy.
+ *
+ * This helper provides:
+ * - `hierarchy.allowHasMany: false` (enforced, folders are single-select)
+ * - Default folder icon component
+ * - Required `useAsTitle` to ensure folders display meaningful names
+ * - `admin.group: false` by default to hide from collections list
+ *   (folder collections are accessed via their dedicated sidebar tab)
+ *
+ * @example
+ * import { createFoldersCollection, createFolderField } from 'payload'
+ *
+ * const Folders = createFoldersCollection({
+ *   slug: 'folders',
+ *   useAsTitle: 'name',
+ *   fields: [
+ *     { name: 'name', type: 'text', required: true },
+ *   ],
+ * })
+ *
+ * // Then in related collections:
+ * const Posts: CollectionConfig = {
+ *   slug: 'posts',
+ *   fields: [
+ *     createFolderField({ relationTo: 'folders' }),
+ *   ],
+ * }
+ */ export function createFoldersCollection(options) {
+    const { admin: adminOverrides, hierarchy: hierarchyOverrides, useAsTitle, ...rest } = options;
+    const slug = rest.slug;
+    // Default parent field to match the hierarchy field name pattern
+    // This enables the joinField to work with both subfolders and related documents
+    const parentFieldName = hierarchyOverrides?.parentFieldName ?? getHierarchyFieldName(slug);
+    return {
+        labels: {
+            plural: 'Folders',
+            singular: 'Folder'
+        },
+        ...rest,
+        admin: {
+            group: false,
+            ...adminOverrides,
+            useAsTitle
+        },
+        hierarchy: {
+            ...hierarchyOverrides,
+            admin: {
+                ...hierarchyOverrides?.admin,
+                components: {
+                    Icon: '@payloadcms/ui#FolderIcon',
+                    ...hierarchyOverrides?.admin?.components
+                },
+                useHeaderButton: hierarchyOverrides?.admin?.useHeaderButton ?? true
+            },
+            allowHasMany: false,
+            parentFieldName
+        }
+    };
+}
+
+//# sourceMappingURL=createFoldersCollection.js.map

package/dist/hierarchy/createFoldersCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/createFoldersCollection.ts"],"sourcesContent":["import type { CollectionConfig } from '../collections/config/types.js'\nimport type { HierarchyConfig } from './types.js'\n\nimport { getHierarchyFieldName } from './constants.js'\n\n/**\n * Hierarchy options for folder collections - all fields optional since defaults are applied.\n * Cannot override `allowHasMany` - folders always use single-select.\n */\ntype FolderHierarchyOptions = {\n  parentFieldName?: string\n} & Partial<Omit<HierarchyConfig, 'allowHasMany' | 'parentFieldName'>>\n\n/**\n * Options for creating a folder collection.\n * Same as CollectionConfig but with `useAsTitle` required.\n */\nexport type CreateFoldersCollectionOptions = {\n  /**\n   * Hierarchy configuration (defaults applied for folder behavior)\n   * Cannot override `allowHasMany` - folders always use single-select\n   */\n  hierarchy?: FolderHierarchyOptions\n  /**\n   * Field name to use as the display title in the folder tree.\n   * Required to ensure folders display meaningful names.\n   */\n  useAsTitle: string\n} & Omit<CollectionConfig, 'admin' | 'hierarchy'> &\n  Partial<Pick<CollectionConfig, 'admin'>>\n\n/**\n * Creates a collection config for a folder-style hierarchy.\n *\n * This helper provides:\n * - `hierarchy.allowHasMany: false` (enforced, folders are single-select)\n * - Default folder icon component\n * - Required `useAsTitle` to ensure folders display meaningful names\n * - `admin.group: false` by default to hide from collections list\n *   (folder collections are accessed via their dedicated sidebar tab)\n *\n * @example\n * import { createFoldersCollection, createFolderField } from 'payload'\n *\n * const Folders = createFoldersCollection({\n *   slug: 'folders',\n *   useAsTitle: 'name',\n *   fields: [\n *     { name: 'name', type: 'text', required: true },\n *   ],\n * })\n *\n * // Then in related collections:\n * const Posts: CollectionConfig = {\n *   slug: 'posts',\n *   fields: [\n *     createFolderField({ relationTo: 'folders' }),\n *   ],\n * }\n */\nexport function createFoldersCollection(options: CreateFoldersCollectionOptions): CollectionConfig {\n  const { admin: adminOverrides, hierarchy: hierarchyOverrides, useAsTitle, ...rest } = options\n  const slug = rest.slug\n\n  // Default parent field to match the hierarchy field name pattern\n  // This enables the joinField to work with both subfolders and related documents\n  const parentFieldName = hierarchyOverrides?.parentFieldName ?? getHierarchyFieldName(slug)\n\n  return {\n    labels: {\n      plural: 'Folders',\n      singular: 'Folder',\n    },\n    ...rest,\n    admin: {\n      group: false,\n      ...adminOverrides,\n      useAsTitle,\n    },\n    hierarchy: {\n      ...hierarchyOverrides,\n      admin: {\n        ...hierarchyOverrides?.admin,\n        components: {\n          Icon: '@payloadcms/ui#FolderIcon',\n          ...hierarchyOverrides?.admin?.components,\n        },\n        useHeaderButton: hierarchyOverrides?.admin?.useHeaderButton ?? true,\n      },\n      allowHasMany: false,\n      parentFieldName,\n    },\n  }\n}\n"],"names":["getHierarchyFieldName","createFoldersCollection","options","admin","adminOverrides","hierarchy","hierarchyOverrides","useAsTitle","rest","slug","parentFieldName","labels","plural","singular","group","components","Icon","useHeaderButton","allowHasMany"],"mappings":"AAGA,SAASA,qBAAqB,QAAQ,iBAAgB;AA4BtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC,GACD,OAAO,SAASC,wBAAwBC,OAAuC;IAC7E,MAAM,EAAEC,OAAOC,cAAc,EAAEC,WAAWC,kBAAkB,EAAEC,UAAU,EAAE,GAAGC,MAAM,GAAGN;IACtF,MAAMO,OAAOD,KAAKC,IAAI;IAEtB,iEAAiE;IACjE,gFAAgF;IAChF,MAAMC,kBAAkBJ,oBAAoBI,mBAAmBV,sBAAsBS;IAErF,OAAO;QACLE,QAAQ;YACNC,QAAQ;YACRC,UAAU;QACZ;QACA,GAAGL,IAAI;QACPL,OAAO;YACLW,OAAO;YACP,GAAGV,cAAc;YACjBG;QACF;QACAF,WAAW;YACT,GAAGC,kBAAkB;YACrBH,OAAO;gBACL,GAAGG,oBAAoBH,KAAK;gBAC5BY,YAAY;oBACVC,MAAM;oBACN,GAAGV,oBAAoBH,OAAOY,UAAU;gBAC1C;gBACAE,iBAAiBX,oBAAoBH,OAAOc,mBAAmB;YACjE;YACAC,cAAc;YACdR;QACF;IACF;AACF"}

package/dist/hierarchy/createTagField.d.ts

@@ -0,0 +1,44 @@
+import type { RelationshipField } from '../fields/config/types.js';
+/**
+ * Options for creating a tag relationship field.
+ * All RelationshipFieldMany properties are available except name, type, and relationTo
+ * which are managed by the tag system.
+ */
+export type CreateTagFieldOptions = {
+    /**
+     * Whether to allow multiple tags (defaults to true)
+     * @default true
+     */
+    hasMany?: boolean;
+    /**
+     * The slug of the hierarchy collection this field references (e.g., 'tags')
+     */
+    relationTo: string;
+} & Pick<Partial<RelationshipField>, 'admin' | 'label' | 'required'>;
+/**
+ * Creates a relationship field for tag-style hierarchies (multi-select by default).
+ *
+ * This field:
+ * - Has hasMany:true by default (multiple tag selection)
+ * - Is positioned in the sidebar by default
+ * - Does NOT inject a header button (tags use standard relationship UI)
+ *
+ * Use this in your collection's fields array to add a tag relationship.
+ * The field name is automatically generated based on the hierarchy slug.
+ *
+ * @example
+ * import { createTagField } from 'payload'
+ *
+ * const Posts: CollectionConfig = {
+ *   slug: 'posts',
+ *   fields: [
+ *     { name: 'title', type: 'text' },
+ *     createTagField({
+ *       relationTo: 'tags',
+ *       label: 'Tags',
+ *     }),
+ *   ],
+ * }
+ */
+export declare function createTagField(options: CreateTagFieldOptions): RelationshipField;
+//# sourceMappingURL=createTagField.d.ts.map

package/dist/hierarchy/createTagField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTagField.d.ts","sourceRoot":"","sources":["../../src/hierarchy/createTagField.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAIlE;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAA;CACnB,GAAG,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,UAAU,CAAC,CAAA;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,iBAAiB,CAqBhF"}

package/dist/hierarchy/createTagField.js

@@ -0,0 +1,48 @@
+import { getHierarchyFieldName } from './constants.js';
+/**
+ * Creates a relationship field for tag-style hierarchies (multi-select by default).
+ *
+ * This field:
+ * - Has hasMany:true by default (multiple tag selection)
+ * - Is positioned in the sidebar by default
+ * - Does NOT inject a header button (tags use standard relationship UI)
+ *
+ * Use this in your collection's fields array to add a tag relationship.
+ * The field name is automatically generated based on the hierarchy slug.
+ *
+ * @example
+ * import { createTagField } from 'payload'
+ *
+ * const Posts: CollectionConfig = {
+ *   slug: 'posts',
+ *   fields: [
+ *     { name: 'title', type: 'text' },
+ *     createTagField({
+ *       relationTo: 'tags',
+ *       label: 'Tags',
+ *     }),
+ *   ],
+ * }
+ */ export function createTagField(options) {
+    const { admin: adminOverrides, hasMany = true, label, relationTo, ...restOptions } = options;
+    const { components: componentOverrides, ...restAdminOverrides } = adminOverrides || {};
+    return {
+        name: getHierarchyFieldName(relationTo),
+        type: 'relationship',
+        admin: {
+            position: 'sidebar',
+            ...restAdminOverrides,
+            components: {
+                Field: '@payloadcms/ui/rsc#HierarchyField',
+                ...componentOverrides
+            }
+        },
+        hasMany,
+        index: true,
+        label: label ?? 'Tags',
+        relationTo,
+        ...restOptions
+    };
+}
+
+//# sourceMappingURL=createTagField.js.map

package/dist/hierarchy/createTagField.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/createTagField.ts"],"sourcesContent":["import type { RelationshipField } from '../fields/config/types.js'\n\nimport { getHierarchyFieldName } from './constants.js'\n\n/**\n * Options for creating a tag relationship field.\n * All RelationshipFieldMany properties are available except name, type, and relationTo\n * which are managed by the tag system.\n */\nexport type CreateTagFieldOptions = {\n  /**\n   * Whether to allow multiple tags (defaults to true)\n   * @default true\n   */\n  hasMany?: boolean\n  /**\n   * The slug of the hierarchy collection this field references (e.g., 'tags')\n   */\n  relationTo: string\n} & Pick<Partial<RelationshipField>, 'admin' | 'label' | 'required'>\n\n/**\n * Creates a relationship field for tag-style hierarchies (multi-select by default).\n *\n * This field:\n * - Has hasMany:true by default (multiple tag selection)\n * - Is positioned in the sidebar by default\n * - Does NOT inject a header button (tags use standard relationship UI)\n *\n * Use this in your collection's fields array to add a tag relationship.\n * The field name is automatically generated based on the hierarchy slug.\n *\n * @example\n * import { createTagField } from 'payload'\n *\n * const Posts: CollectionConfig = {\n *   slug: 'posts',\n *   fields: [\n *     { name: 'title', type: 'text' },\n *     createTagField({\n *       relationTo: 'tags',\n *       label: 'Tags',\n *     }),\n *   ],\n * }\n */\nexport function createTagField(options: CreateTagFieldOptions): RelationshipField {\n  const { admin: adminOverrides, hasMany = true, label, relationTo, ...restOptions } = options\n  const { components: componentOverrides, ...restAdminOverrides } = adminOverrides || {}\n\n  return {\n    name: getHierarchyFieldName(relationTo),\n    type: 'relationship',\n    admin: {\n      position: 'sidebar',\n      ...restAdminOverrides,\n      components: {\n        Field: '@payloadcms/ui/rsc#HierarchyField',\n        ...componentOverrides,\n      },\n    },\n    hasMany,\n    index: true,\n    label: label ?? 'Tags',\n    relationTo,\n    ...restOptions,\n  } as RelationshipField\n}\n"],"names":["getHierarchyFieldName","createTagField","options","admin","adminOverrides","hasMany","label","relationTo","restOptions","components","componentOverrides","restAdminOverrides","name","type","position","Field","index"],"mappings":"AAEA,SAASA,qBAAqB,QAAQ,iBAAgB;AAmBtD;;;;;;;;;;;;;;;;;;;;;;;;CAwBC,GACD,OAAO,SAASC,eAAeC,OAA8B;IAC3D,MAAM,EAAEC,OAAOC,cAAc,EAAEC,UAAU,IAAI,EAAEC,KAAK,EAAEC,UAAU,EAAE,GAAGC,aAAa,GAAGN;IACrF,MAAM,EAAEO,YAAYC,kBAAkB,EAAE,GAAGC,oBAAoB,GAAGP,kBAAkB,CAAC;IAErF,OAAO;QACLQ,MAAMZ,sBAAsBO;QAC5BM,MAAM;QACNV,OAAO;YACLW,UAAU;YACV,GAAGH,kBAAkB;YACrBF,YAAY;gBACVM,OAAO;gBACP,GAAGL,kBAAkB;YACvB;QACF;QACAL;QACAW,OAAO;QACPV,OAAOA,SAAS;QAChBC;QACA,GAAGC,WAAW;IAChB;AACF"}

package/dist/hierarchy/createTagsCollection.d.ts

@@ -0,0 +1,54 @@
+import type { CollectionConfig } from '../collections/config/types.js';
+import type { HierarchyConfig } from './types.js';
+/**
+ * Hierarchy options for tag collections - all fields optional since defaults are applied.
+ */
+type TagHierarchyOptions = {
+    parentFieldName?: string;
+} & Partial<Omit<HierarchyConfig, 'parentFieldName'>>;
+/**
+ * Options for creating a tag collection.
+ * Same as CollectionConfig but with `useAsTitle` required.
+ */
+export type CreateTagsCollectionOptions = {
+    /**
+     * Hierarchy configuration (defaults applied for tag behavior)
+     * `allowHasMany` defaults to true but can be overridden
+     */
+    hierarchy?: TagHierarchyOptions;
+    /**
+     * Field name to use as the display title in the tag tree.
+     * Required to ensure tags display meaningful names.
+     */
+    useAsTitle: string;
+} & Omit<CollectionConfig, 'admin' | 'hierarchy'> & Partial<Pick<CollectionConfig, 'admin'>>;
+/**
+ * Creates a collection config for a tag-style hierarchy.
+ *
+ * This helper provides:
+ * - `hierarchy.allowHasMany: true` by default (can be overridden)
+ * - Default tag icon component
+ * - Required `useAsTitle` to ensure tags display meaningful names
+ *
+ * @example
+ * import { createTagsCollection, createTagField } from 'payload'
+ *
+ * const Tags = createTagsCollection({
+ *   slug: 'tags',
+ *   useAsTitle: 'name',
+ *   fields: [
+ *     { name: 'name', type: 'text', required: true },
+ *   ],
+ * })
+ *
+ * // Then in related collections:
+ * const Posts: CollectionConfig = {
+ *   slug: 'posts',
+ *   fields: [
+ *     createTagField({ relationTo: 'tags' }),
+ *   ],
+ * }
+ */
+export declare function createTagsCollection(options: CreateTagsCollectionOptions): CollectionConfig;
+export {};
+//# sourceMappingURL=createTagsCollection.d.ts.map

package/dist/hierarchy/createTagsCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTagsCollection.d.ts","sourceRoot":"","sources":["../../src/hierarchy/createTagsCollection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIjD;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC,CAAA;AAErD;;;GAGG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC;;;OAGG;IACH,SAAS,CAAC,EAAE,mBAAmB,CAAA;IAC/B;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAA;CACnB,GAAG,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,WAAW,CAAC,GAC/C,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC,CAAA;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,gBAAgB,CA2B3F"}

package/dist/hierarchy/createTagsCollection.js

@@ -0,0 +1,56 @@
+import { getHierarchyFieldName } from './constants.js';
+/**
+ * Creates a collection config for a tag-style hierarchy.
+ *
+ * This helper provides:
+ * - `hierarchy.allowHasMany: true` by default (can be overridden)
+ * - Default tag icon component
+ * - Required `useAsTitle` to ensure tags display meaningful names
+ *
+ * @example
+ * import { createTagsCollection, createTagField } from 'payload'
+ *
+ * const Tags = createTagsCollection({
+ *   slug: 'tags',
+ *   useAsTitle: 'name',
+ *   fields: [
+ *     { name: 'name', type: 'text', required: true },
+ *   ],
+ * })
+ *
+ * // Then in related collections:
+ * const Posts: CollectionConfig = {
+ *   slug: 'posts',
+ *   fields: [
+ *     createTagField({ relationTo: 'tags' }),
+ *   ],
+ * }
+ */ export function createTagsCollection(options) {
+    const { admin: adminOverrides, hierarchy: hierarchyOverrides, useAsTitle, ...rest } = options;
+    return {
+        labels: {
+            plural: 'Tags',
+            singular: 'Tag'
+        },
+        ...rest,
+        admin: {
+            group: false,
+            ...adminOverrides,
+            useAsTitle
+        },
+        hierarchy: {
+            allowHasMany: true,
+            ...hierarchyOverrides,
+            admin: {
+                ...hierarchyOverrides?.admin,
+                components: {
+                    Icon: '@payloadcms/ui#TagIcon',
+                    ...hierarchyOverrides?.admin?.components
+                }
+            },
+            parentFieldName: hierarchyOverrides?.parentFieldName ?? getHierarchyFieldName(rest.slug)
+        }
+    };
+}
+
+//# sourceMappingURL=createTagsCollection.js.map

package/dist/hierarchy/createTagsCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/createTagsCollection.ts"],"sourcesContent":["import type { CollectionConfig } from '../collections/config/types.js'\nimport type { HierarchyConfig } from './types.js'\n\nimport { getHierarchyFieldName } from './constants.js'\n\n/**\n * Hierarchy options for tag collections - all fields optional since defaults are applied.\n */\ntype TagHierarchyOptions = {\n  parentFieldName?: string\n} & Partial<Omit<HierarchyConfig, 'parentFieldName'>>\n\n/**\n * Options for creating a tag collection.\n * Same as CollectionConfig but with `useAsTitle` required.\n */\nexport type CreateTagsCollectionOptions = {\n  /**\n   * Hierarchy configuration (defaults applied for tag behavior)\n   * `allowHasMany` defaults to true but can be overridden\n   */\n  hierarchy?: TagHierarchyOptions\n  /**\n   * Field name to use as the display title in the tag tree.\n   * Required to ensure tags display meaningful names.\n   */\n  useAsTitle: string\n} & Omit<CollectionConfig, 'admin' | 'hierarchy'> &\n  Partial<Pick<CollectionConfig, 'admin'>>\n\n/**\n * Creates a collection config for a tag-style hierarchy.\n *\n * This helper provides:\n * - `hierarchy.allowHasMany: true` by default (can be overridden)\n * - Default tag icon component\n * - Required `useAsTitle` to ensure tags display meaningful names\n *\n * @example\n * import { createTagsCollection, createTagField } from 'payload'\n *\n * const Tags = createTagsCollection({\n *   slug: 'tags',\n *   useAsTitle: 'name',\n *   fields: [\n *     { name: 'name', type: 'text', required: true },\n *   ],\n * })\n *\n * // Then in related collections:\n * const Posts: CollectionConfig = {\n *   slug: 'posts',\n *   fields: [\n *     createTagField({ relationTo: 'tags' }),\n *   ],\n * }\n */\nexport function createTagsCollection(options: CreateTagsCollectionOptions): CollectionConfig {\n  const { admin: adminOverrides, hierarchy: hierarchyOverrides, useAsTitle, ...rest } = options\n\n  return {\n    labels: {\n      plural: 'Tags',\n      singular: 'Tag',\n    },\n    ...rest,\n    admin: {\n      group: false,\n      ...adminOverrides,\n      useAsTitle,\n    },\n    hierarchy: {\n      allowHasMany: true,\n      ...hierarchyOverrides,\n      admin: {\n        ...hierarchyOverrides?.admin,\n        components: {\n          Icon: '@payloadcms/ui#TagIcon',\n          ...hierarchyOverrides?.admin?.components,\n        },\n      },\n      parentFieldName: hierarchyOverrides?.parentFieldName ?? getHierarchyFieldName(rest.slug),\n    },\n  }\n}\n"],"names":["getHierarchyFieldName","createTagsCollection","options","admin","adminOverrides","hierarchy","hierarchyOverrides","useAsTitle","rest","labels","plural","singular","group","allowHasMany","components","Icon","parentFieldName","slug"],"mappings":"AAGA,SAASA,qBAAqB,QAAQ,iBAAgB;AA2BtD;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BC,GACD,OAAO,SAASC,qBAAqBC,OAAoC;IACvE,MAAM,EAAEC,OAAOC,cAAc,EAAEC,WAAWC,kBAAkB,EAAEC,UAAU,EAAE,GAAGC,MAAM,GAAGN;IAEtF,OAAO;QACLO,QAAQ;YACNC,QAAQ;YACRC,UAAU;QACZ;QACA,GAAGH,IAAI;QACPL,OAAO;YACLS,OAAO;YACP,GAAGR,cAAc;YACjBG;QACF;QACAF,WAAW;YACTQ,cAAc;YACd,GAAGP,kBAAkB;YACrBH,OAAO;gBACL,GAAGG,oBAAoBH,KAAK;gBAC5BW,YAAY;oBACVC,MAAM;oBACN,GAAGT,oBAAoBH,OAAOW,UAAU;gBAC1C;YACF;YACAE,iBAAiBV,oBAAoBU,mBAAmBhB,sBAAsBQ,KAAKS,IAAI;QACzF;IACF;AACF"}

package/dist/hierarchy/endpoints/findRelated.d.ts

@@ -0,0 +1,7 @@
+import type { PayloadHandler } from '../../config/types.js';
+/**
+ * Endpoint to find all documents related to a hierarchy item
+ * GET /api/{collection}/{id}/related
+ */
+export declare const findRelatedHandler: PayloadHandler;
+//# sourceMappingURL=findRelated.d.ts.map

package/dist/hierarchy/endpoints/findRelated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findRelated.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/endpoints/findRelated.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAO3D;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAwBhC,CAAA"}

package/dist/hierarchy/endpoints/findRelated.js

@@ -0,0 +1,36 @@
+import { status as httpStatus } from 'http-status';
+import { getRequestCollectionWithID } from '../../utilities/getRequestEntity.js';
+import { headersWithCors } from '../../utilities/headersWithCors.js';
+import { parseParams } from '../../utilities/parseParams/index.js';
+import { findRelatedDocuments } from '../operations/findRelatedDocuments.js';
+/**
+ * Endpoint to find all documents related to a hierarchy item
+ * GET /api/{collection}/{id}/related
+ */ export const findRelatedHandler = async (req)=>{
+    if (!req.user) {
+        return Response.json({
+            message: 'Unauthorized'
+        }, {
+            status: httpStatus.UNAUTHORIZED
+        });
+    }
+    const { id, collection } = getRequestCollectionWithID(req);
+    const { depth, limit, page } = parseParams(req.query);
+    const result = await findRelatedDocuments({
+        id,
+        collection: collection.config,
+        depth: depth || 0,
+        limit: limit || 50,
+        page: page || 1,
+        req
+    });
+    return Response.json(result, {
+        headers: headersWithCors({
+            headers: new Headers(),
+            req
+        }),
+        status: httpStatus.OK
+    });
+};
+
+//# sourceMappingURL=findRelated.js.map

package/dist/hierarchy/endpoints/findRelated.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hierarchy/endpoints/findRelated.ts"],"sourcesContent":["import { status as httpStatus } from 'http-status'\n\nimport type { PayloadHandler } from '../../config/types.js'\n\nimport { getRequestCollectionWithID } from '../../utilities/getRequestEntity.js'\nimport { headersWithCors } from '../../utilities/headersWithCors.js'\nimport { parseParams } from '../../utilities/parseParams/index.js'\nimport { findRelatedDocuments } from '../operations/findRelatedDocuments.js'\n\n/**\n * Endpoint to find all documents related to a hierarchy item\n * GET /api/{collection}/{id}/related\n */\nexport const findRelatedHandler: PayloadHandler = async (req) => {\n  if (!req.user) {\n    return Response.json({ message: 'Unauthorized' }, { status: httpStatus.UNAUTHORIZED })\n  }\n\n  const { id, collection } = getRequestCollectionWithID(req)\n  const { depth, limit, page } = parseParams(req.query)\n\n  const result = await findRelatedDocuments({\n    id,\n    collection: collection.config,\n    depth: depth || 0,\n    limit: limit || 50,\n    page: page || 1,\n    req,\n  })\n\n  return Response.json(result, {\n    headers: headersWithCors({\n      headers: new Headers(),\n      req,\n    }),\n    status: httpStatus.OK,\n  })\n}\n"],"names":["status","httpStatus","getRequestCollectionWithID","headersWithCors","parseParams","findRelatedDocuments","findRelatedHandler","req","user","Response","json","message","UNAUTHORIZED","id","collection","depth","limit","page","query","result","config","headers","Headers","OK"],"mappings":"AAAA,SAASA,UAAUC,UAAU,QAAQ,cAAa;AAIlD,SAASC,0BAA0B,QAAQ,sCAAqC;AAChF,SAASC,eAAe,QAAQ,qCAAoC;AACpE,SAASC,WAAW,QAAQ,uCAAsC;AAClE,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E;;;CAGC,GACD,OAAO,MAAMC,qBAAqC,OAAOC;IACvD,IAAI,CAACA,IAAIC,IAAI,EAAE;QACb,OAAOC,SAASC,IAAI,CAAC;YAAEC,SAAS;QAAe,GAAG;YAAEX,QAAQC,WAAWW,YAAY;QAAC;IACtF;IAEA,MAAM,EAAEC,EAAE,EAAEC,UAAU,EAAE,GAAGZ,2BAA2BK;IACtD,MAAM,EAAEQ,KAAK,EAAEC,KAAK,EAAEC,IAAI,EAAE,GAAGb,YAAYG,IAAIW,KAAK;IAEpD,MAAMC,SAAS,MAAMd,qBAAqB;QACxCQ;QACAC,YAAYA,WAAWM,MAAM;QAC7BL,OAAOA,SAAS;QAChBC,OAAOA,SAAS;QAChBC,MAAMA,QAAQ;QACdV;IACF;IAEA,OAAOE,SAASC,IAAI,CAACS,QAAQ;QAC3BE,SAASlB,gBAAgB;YACvBkB,SAAS,IAAIC;YACbf;QACF;QACAP,QAAQC,WAAWsB,EAAE;IACvB;AACF,EAAC"}

package/dist/hierarchy/getInitialTreeData.d.ts

@@ -0,0 +1,24 @@
+import type { TypeWithID } from '../collections/config/types.js';
+import type { PayloadRequest } from '../types/index.js';
+export type GetInitialTreeDataArgs = {
+    collectionSlug: string;
+    expandedNodeIds?: (number | string)[];
+    /** Filter tree to only show folders that allow these collection types (or are unrestricted) */
+    filterByCollections?: string[];
+    limit?: number;
+    req: PayloadRequest;
+    /** The currently selected node ID. When provided, ensures siblings are loaded to include this node. */
+    selectedNodeId?: null | number | string;
+    /** The parent ID of the selected node. Required when selectedNodeId is provided. */
+    selectedNodeParentId?: null | number | string;
+};
+export type InitialTreeData = {
+    docs: TypeWithID[];
+    loadedParents: Record<string, {
+        hasMore: boolean;
+        loadedCount?: number;
+        totalDocs: number;
+    }>;
+};
+export declare const getInitialTreeData: ({ collectionSlug, expandedNodeIds, filterByCollections, limit, req, selectedNodeId, selectedNodeParentId, }: GetInitialTreeDataArgs) => Promise<InitialTreeData>;
+//# sourceMappingURL=getInitialTreeData.d.ts.map

package/dist/hierarchy/getInitialTreeData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getInitialTreeData.d.ts","sourceRoot":"","sources":["../../src/hierarchy/getInitialTreeData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,KAAK,EAAE,cAAc,EAAS,MAAM,mBAAmB,CAAA;AAI9D,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IACrC,+FAA+F;IAC/F,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,cAAc,CAAA;IACnB,uGAAuG;IACvG,cAAc,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAA;IACvC,oFAAoF;IACpF,oBAAoB,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAA;CAC9C,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,UAAU,EAAE,CAAA;IAElB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC7F,CAAA;AAED,eAAO,MAAM,kBAAkB,gHAQ5B,sBAAsB,KAAG,OAAO,CAAC,eAAe,CAsIlD,CAAA"}

package/dist/hierarchy/getInitialTreeData.js

@@ -0,0 +1,120 @@
+import { DEFAULT_HIERARCHY_TREE_LIMIT } from '../hierarchy/constants.js';
+export const getInitialTreeData = async ({ collectionSlug, expandedNodeIds = [], filterByCollections, limit, req, selectedNodeId, selectedNodeParentId })=>{
+    const collectionConfig = req.payload.collections[collectionSlug]?.config;
+    if (!collectionConfig || !collectionConfig.hierarchy) {
+        throw new Error(`Collection ${collectionSlug} is not a hierarchy`);
+    }
+    const hierarchyConfig = collectionConfig.hierarchy;
+    const parentFieldName = hierarchyConfig.parentFieldName;
+    const useAsTitle = collectionConfig.admin?.useAsTitle ?? 'id';
+    // Get typeFieldName for filtering
+    const typeFieldName = hierarchyConfig.collectionSpecific && typeof hierarchyConfig.collectionSpecific === 'object' ? hierarchyConfig.collectionSpecific.fieldName : undefined;
+    // Build filter condition if filterByCollections is provided
+    // Exclude the hierarchy collection itself (folders always show folders)
+    const filteredTypes = filterByCollections?.filter((t)=>t !== collectionSlug);
+    // Get all possible type values from relatedCollections for detecting empty arrays
+    const allPossibleTypes = hierarchyConfig.relatedCollections ? Object.keys(hierarchyConfig.relatedCollections) : [];
+    const filterCondition = filteredTypes?.length && typeFieldName ? {
+        or: [
+            {
+                [typeFieldName]: {
+                    in: filteredTypes
+                }
+            },
+            {
+                [typeFieldName]: {
+                    exists: false
+                }
+            },
+            // Include unrestricted folders with empty allowedTypes array
+            // Using not_in with all possible values matches empty arrays in both MongoDB and Postgres
+            ...allPossibleTypes.length > 0 ? [
+                {
+                    [typeFieldName]: {
+                        not_in: allPossibleTypes
+                    }
+                }
+            ] : []
+        ]
+    } : null;
+    // Use limit from config if not provided, fallback to config's treeLimit
+    const effectiveLimit = limit ?? hierarchyConfig.admin?.treeLimit ?? DEFAULT_HIERARCHY_TREE_LIMIT;
+    const allDocs = [];
+    const loadedParents = {};
+    // Normalize selectedNodeParentId: treat null/undefined as 'null' (root level)
+    const normalizedSelectedParentId = selectedNodeParentId === null || selectedNodeParentId === undefined ? 'null' : String(selectedNodeParentId);
+    // Helper to check if selectedNodeId is among siblings at a given parent level
+    const needsSelectedNodeIncluded = (parentKey)=>{
+        return !!selectedNodeId && normalizedSelectedParentId === parentKey;
+    };
+    // Helper to fetch children with optional selectedNodeId inclusion
+    const fetchChildrenForParent = async (parentKey, parentCondition)=>{
+        const mustIncludeSelected = needsSelectedNodeIncluded(parentKey);
+        let accumulatedDocs = [];
+        let currentPage = 1;
+        let hasMore = true;
+        let totalDocs = 0;
+        let foundSelected = false;
+        // Combine parent condition with filter condition
+        const whereClause = filterCondition ? {
+            and: [
+                parentCondition,
+                filterCondition
+            ]
+        } : parentCondition;
+        while(hasMore){
+            const result = await req.payload.find({
+                collection: collectionSlug,
+                depth: 0,
+                limit: effectiveLimit,
+                overrideAccess: false,
+                page: currentPage,
+                req,
+                sort: useAsTitle,
+                user: req.user,
+                where: whereClause
+            });
+            accumulatedDocs = [
+                ...accumulatedDocs,
+                ...result.docs
+            ];
+            totalDocs = result.totalDocs;
+            hasMore = result.hasNextPage;
+            // Check if selectedNodeId is in this page's results
+            if (mustIncludeSelected && !foundSelected) {
+                foundSelected = result.docs.some((doc)=>String(doc.id) === String(selectedNodeId));
+            }
+            // Stop if we've found the selected node OR we only need first page
+            if (!mustIncludeSelected || foundSelected || !hasMore) {
+                break;
+            }
+            currentPage++;
+        }
+        allDocs.push(...accumulatedDocs);
+        loadedParents[parentKey] = {
+            hasMore,
+            loadedCount: accumulatedDocs.length,
+            totalDocs
+        };
+    };
+    // Query 1: Fetch root nodes
+    await fetchChildrenForParent('null', {
+        [parentFieldName]: {
+            exists: false
+        }
+    });
+    // Query 2: For each expanded node, fetch its children
+    for (const parentId of expandedNodeIds){
+        await fetchChildrenForParent(String(parentId), {
+            [parentFieldName]: {
+                equals: parentId
+            }
+        });
+    }
+    return {
+        docs: allDocs,
+        loadedParents
+    };
+};
+
+//# sourceMappingURL=getInitialTreeData.js.map

package/dist/hierarchy/getInitialTreeData.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/getInitialTreeData.ts"],"sourcesContent":["import type { TypeWithID } from '../collections/config/types.js'\nimport type { PayloadRequest, Where } from '../types/index.js'\n\nimport { DEFAULT_HIERARCHY_TREE_LIMIT } from '../hierarchy/constants.js'\n\nexport type GetInitialTreeDataArgs = {\n  collectionSlug: string\n  expandedNodeIds?: (number | string)[]\n  /** Filter tree to only show folders that allow these collection types (or are unrestricted) */\n  filterByCollections?: string[]\n  limit?: number\n  req: PayloadRequest\n  /** The currently selected node ID. When provided, ensures siblings are loaded to include this node. */\n  selectedNodeId?: null | number | string\n  /** The parent ID of the selected node. Required when selectedNodeId is provided. */\n  selectedNodeParentId?: null | number | string\n}\n\nexport type InitialTreeData = {\n  docs: TypeWithID[]\n  // Metadata about what was loaded - keyed by parent ID ('null' for root)\n  loadedParents: Record<string, { hasMore: boolean; loadedCount?: number; totalDocs: number }>\n}\n\nexport const getInitialTreeData = async ({\n  collectionSlug,\n  expandedNodeIds = [],\n  filterByCollections,\n  limit,\n  req,\n  selectedNodeId,\n  selectedNodeParentId,\n}: GetInitialTreeDataArgs): Promise<InitialTreeData> => {\n  const collectionConfig = req.payload.collections[collectionSlug]?.config\n\n  if (!collectionConfig || !collectionConfig.hierarchy) {\n    throw new Error(`Collection ${collectionSlug} is not a hierarchy`)\n  }\n\n  const hierarchyConfig = collectionConfig.hierarchy\n  const parentFieldName = hierarchyConfig.parentFieldName\n  const useAsTitle = collectionConfig.admin?.useAsTitle ?? 'id'\n\n  // Get typeFieldName for filtering\n  const typeFieldName =\n    hierarchyConfig.collectionSpecific && typeof hierarchyConfig.collectionSpecific === 'object'\n      ? hierarchyConfig.collectionSpecific.fieldName\n      : undefined\n\n  // Build filter condition if filterByCollections is provided\n  // Exclude the hierarchy collection itself (folders always show folders)\n  const filteredTypes = filterByCollections?.filter((t) => t !== collectionSlug)\n\n  // Get all possible type values from relatedCollections for detecting empty arrays\n  const allPossibleTypes = hierarchyConfig.relatedCollections\n    ? Object.keys(hierarchyConfig.relatedCollections)\n    : []\n\n  const filterCondition =\n    filteredTypes?.length && typeFieldName\n      ? {\n          or: [\n            { [typeFieldName]: { in: filteredTypes } },\n            { [typeFieldName]: { exists: false } }, // Include unrestricted folders (field doesn't exist)\n            // Include unrestricted folders with empty allowedTypes array\n            // Using not_in with all possible values matches empty arrays in both MongoDB and Postgres\n            ...(allPossibleTypes.length > 0\n              ? [{ [typeFieldName]: { not_in: allPossibleTypes } }]\n              : []),\n          ],\n        }\n      : null\n\n  // Use limit from config if not provided, fallback to config's treeLimit\n  const effectiveLimit = limit ?? hierarchyConfig.admin?.treeLimit ?? DEFAULT_HIERARCHY_TREE_LIMIT\n\n  const allDocs: TypeWithID[] = []\n  const loadedParents: Record<\n    string,\n    { hasMore: boolean; loadedCount: number; totalDocs: number }\n  > = {}\n\n  // Normalize selectedNodeParentId: treat null/undefined as 'null' (root level)\n  const normalizedSelectedParentId =\n    selectedNodeParentId === null || selectedNodeParentId === undefined\n      ? 'null'\n      : String(selectedNodeParentId)\n\n  // Helper to check if selectedNodeId is among siblings at a given parent level\n  const needsSelectedNodeIncluded = (parentKey: string): boolean => {\n    return !!selectedNodeId && normalizedSelectedParentId === parentKey\n  }\n\n  // Helper to fetch children with optional selectedNodeId inclusion\n  const fetchChildrenForParent = async (\n    parentKey: string,\n    parentCondition: Where,\n  ): Promise<void> => {\n    const mustIncludeSelected = needsSelectedNodeIncluded(parentKey)\n    let accumulatedDocs: TypeWithID[] = []\n    let currentPage = 1\n    let hasMore = true\n    let totalDocs = 0\n    let foundSelected = false\n\n    // Combine parent condition with filter condition\n    const whereClause = filterCondition\n      ? { and: [parentCondition, filterCondition] }\n      : parentCondition\n\n    while (hasMore) {\n      const result = await req.payload.find({\n        collection: collectionSlug,\n        depth: 0,\n        limit: effectiveLimit,\n        overrideAccess: false,\n        page: currentPage,\n        req,\n        sort: useAsTitle,\n        user: req.user,\n        where: whereClause,\n      })\n\n      accumulatedDocs = [...accumulatedDocs, ...result.docs]\n      totalDocs = result.totalDocs\n      hasMore = result.hasNextPage\n\n      // Check if selectedNodeId is in this page's results\n      if (mustIncludeSelected && !foundSelected) {\n        foundSelected = result.docs.some(\n          (doc: TypeWithID) => String(doc.id) === String(selectedNodeId),\n        )\n      }\n\n      // Stop if we've found the selected node OR we only need first page\n      if (!mustIncludeSelected || foundSelected || !hasMore) {\n        break\n      }\n\n      currentPage++\n    }\n\n    allDocs.push(...accumulatedDocs)\n    loadedParents[parentKey] = {\n      hasMore,\n      loadedCount: accumulatedDocs.length,\n      totalDocs,\n    }\n  }\n\n  // Query 1: Fetch root nodes\n  await fetchChildrenForParent('null', {\n    [parentFieldName]: { exists: false },\n  })\n\n  // Query 2: For each expanded node, fetch its children\n  for (const parentId of expandedNodeIds) {\n    await fetchChildrenForParent(String(parentId), {\n      [parentFieldName]: { equals: parentId },\n    })\n  }\n\n  return {\n    docs: allDocs,\n    loadedParents,\n  }\n}\n"],"names":["DEFAULT_HIERARCHY_TREE_LIMIT","getInitialTreeData","collectionSlug","expandedNodeIds","filterByCollections","limit","req","selectedNodeId","selectedNodeParentId","collectionConfig","payload","collections","config","hierarchy","Error","hierarchyConfig","parentFieldName","useAsTitle","admin","typeFieldName","collectionSpecific","fieldName","undefined","filteredTypes","filter","t","allPossibleTypes","relatedCollections","Object","keys","filterCondition","length","or","in","exists","not_in","effectiveLimit","treeLimit","allDocs","loadedParents","normalizedSelectedParentId","String","needsSelectedNodeIncluded","parentKey","fetchChildrenForParent","parentCondition","mustIncludeSelected","accumulatedDocs","currentPage","hasMore","totalDocs","foundSelected","whereClause","and","result","find","collection","depth","overrideAccess","page","sort","user","where","docs","hasNextPage","some","doc","id","push","loadedCount","parentId","equals"],"mappings":"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"}

package/dist/hierarchy/hooks/collectionAfterDelete.d.ts

@@ -0,0 +1,14 @@
+/**
+ * afterDelete Hook Responsibilities:
+ * - Clear folder references from related documents when folder is deleted
+ */
+import type { CollectionAfterDeleteHook } from '../../index.js';
+type Args = {
+    /**
+     * Map of collection slugs to their field names
+     */
+    relatedCollections: Record<string, string>;
+};
+export declare const hierarchyCollectionAfterDelete: ({ relatedCollections }: Args) => CollectionAfterDeleteHook;
+export {};
+//# sourceMappingURL=collectionAfterDelete.d.ts.map

package/dist/hierarchy/hooks/collectionAfterDelete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectionAfterDelete.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/hooks/collectionAfterDelete.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAA;AAE/D,KAAK,IAAI,GAAG;IACV;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3C,CAAA;AAED,eAAO,MAAM,8BAA8B,2BAChB,IAAI,KAAG,yBAgB/B,CAAA"}