payload 3.84.1 → 4.0.0-internal.d28e9fb

package/dist/hierarchy/resolveHierarchyCollections.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/resolveHierarchyCollections.ts"],"sourcesContent":["import type { CollectionConfig, SanitizedCollectionConfig } from '../collections/config/types.js'\nimport type { Config } from '../config/types.js'\nimport type {\n  JoinField,\n  Option,\n  RelationshipField,\n  SelectField,\n  Validate,\n} from '../fields/config/types.js'\nimport type { Document } from '../types/index.js'\nimport type {\n  HierarchyJoinFieldConfig,\n  SanitizedHierarchyConfig,\n  SanitizedHierarchyRelatedCollection,\n} from './types.js'\n\nimport { sanitizeJoinField } from '../fields/config/sanitizeJoinField.js'\nimport { fieldAffectsData } from '../fields/config/types.js'\nimport { extractID } from '../utilities/extractID.js'\nimport { flattenAllFields } from '../utilities/flattenAllFields.js'\nimport { getHierarchyFieldName } from './constants.js'\nimport { hierarchyCollectionAfterDelete } from './hooks/collectionAfterDelete.js'\nimport { injectHierarchyButton } from './injectHierarchyButton.js'\n\n/**\n * Resolves hierarchy relationships across collections.\n *\n * This function runs after individual collection sanitization to establish\n * cross-collection hierarchy relationships. It discovers which collections\n * reference each hierarchy and configures the necessary fields, components,\n * and hooks.\n *\n * @remarks\n * Must be called after all collections are sanitized.\n *\n * **What it does:**\n * - Discovers related collections by scanning for hierarchy relationship fields\n * - Injects `HierarchyButton` component when `custom.hierarchy.injectHeaderButton` is set\n * - Adds `collectionSpecific` validation to ensure hierarchy items accept the document type\n * - Injects the `hierarchyType` select field when `collectionSpecific` is enabled\n * - Injects join field when `joinField` is configured\n * - Adds `afterDelete` hook to clear hierarchy references when items are deleted\n * - Populates `relatedCollections` in the sanitized hierarchy config\n */\nexport const resolveHierarchyCollections = (config: Config): void => {\n  const hierarchyCollections =\n    config.collections?.filter((col) => col.hierarchy && typeof col.hierarchy === 'object') || []\n\n  for (const hierarchyCollection of hierarchyCollections) {\n    const hierarchy = hierarchyCollection.hierarchy\n\n    // TypeScript guard - hierarchy is guaranteed to be an object by the filter above\n    if (!hierarchy || typeof hierarchy !== 'object') {\n      continue\n    }\n\n    const hierarchyConfig = hierarchy as SanitizedHierarchyConfig\n    const defaultFieldName = getHierarchyFieldName(hierarchyCollection.slug)\n    const parentFieldName = hierarchyConfig.parentFieldName ?? defaultFieldName\n    const isParentFieldNameOverridden = parentFieldName !== defaultFieldName\n    const collectionSpecific = hierarchyConfig.collectionSpecific\n    const typeFieldName = collectionSpecific ? collectionSpecific.fieldName : undefined\n    const allowHasMany = hierarchyConfig.allowHasMany ?? true\n\n    // Build relatedCollections by scanning all collections for hierarchy fields\n    const sanitizedRelatedCollections: Record<string, SanitizedHierarchyRelatedCollection> = {}\n\n    const selfParentField = hierarchyCollection.fields.find(\n      (field) =>\n        fieldAffectsData(field) &&\n        field.name === parentFieldName &&\n        field.type === 'relationship' &&\n        (field as RelationshipField).relationTo === hierarchyCollection.slug,\n    ) as RelationshipField | undefined\n\n    // Check if the hierarchy collection's own parent field should be replaced with a header button\n    if (selfParentField?.custom?.hierarchy?.injectHeaderButton === true) {\n      injectHierarchyButton({\n        collection: hierarchyCollection,\n        fieldName: parentFieldName,\n        hierarchyCollectionSlug: hierarchyCollection.slug,\n        parentFieldName: hierarchyConfig.parentFieldName,\n      })\n    }\n\n    for (const collection of config.collections || []) {\n      // Skip the hierarchy collection itself (handled above)\n      if (collection.slug === hierarchyCollection.slug) {\n        continue\n      }\n\n      // Find hierarchy field by the default name (what createFolderField uses)\n      const hierarchyField = collection.fields.find(\n        (field) =>\n          fieldAffectsData(field) &&\n          field.name === defaultFieldName &&\n          field.type === 'relationship' &&\n          (field as RelationshipField).relationTo === hierarchyCollection.slug,\n      ) as RelationshipField | undefined\n\n      // If parentFieldName is overridden, rename the field to match\n      if (hierarchyField && isParentFieldNameOverridden) {\n        hierarchyField.name = parentFieldName\n      }\n\n      if (!hierarchyField) {\n        continue\n      }\n\n      const fieldHasMany = hierarchyField.hasMany ?? allowHasMany\n\n      // If collectionSpecific, inject validation to check hierarchy allows this collection type\n      if (collectionSpecific) {\n        injectCollectionSpecificValidation({\n          hierarchyField,\n          hierarchySlug: hierarchyCollection.slug,\n          typeFieldName: typeFieldName!,\n        })\n      }\n\n      // Store discovered collection with hasMany info\n      sanitizedRelatedCollections[collection.slug] = {\n        fieldName: parentFieldName,\n        hasMany: fieldHasMany,\n      }\n\n      // Inject HierarchyButton if field requests it\n      if (hierarchyField.custom?.hierarchy?.injectHeaderButton === true) {\n        injectHierarchyButton({\n          collection,\n          fieldName: parentFieldName,\n          hierarchyCollectionSlug: hierarchyCollection.slug,\n          parentFieldName: hierarchyConfig.parentFieldName,\n        })\n      }\n    }\n\n    // If collectionSpecific, add type field to hierarchy collection\n    if (hierarchyConfig.collectionSpecific) {\n      injectTypeField({\n        config,\n        hierarchyCollection: hierarchyCollection as SanitizedCollectionConfig,\n        parentFieldName: hierarchyConfig.parentFieldName,\n        sanitizedRelatedCollections,\n        typeFieldName: hierarchyConfig.collectionSpecific.fieldName,\n      })\n    }\n\n    // If joinField is configured, add the join field to query children\n    if (hierarchyConfig.joinField) {\n      injectJoinField({\n        config,\n        hierarchyCollection: hierarchyCollection as SanitizedCollectionConfig,\n        joinFieldConfig: hierarchyConfig.joinField,\n        parentFieldName,\n        relatedSlugs: Object.keys(sanitizedRelatedCollections),\n      })\n    }\n\n    // Update hierarchy config with sanitized relatedCollections\n    if (hierarchyConfig) {\n      hierarchyConfig.relatedCollections = sanitizedRelatedCollections\n    }\n\n    // Add afterDelete hook to clear folder references from related documents\n    if (Object.keys(sanitizedRelatedCollections).length > 0) {\n      injectAfterDeleteHook({\n        hierarchyCollection: hierarchyCollection as SanitizedCollectionConfig,\n        sanitizedRelatedCollections,\n      })\n    }\n\n    // Add sidebar tab for this hierarchy collection (unless explicitly disabled)\n    if (hierarchyConfig.admin.injectSidebarTab !== false) {\n      injectSidebarTab({\n        config,\n        hierarchyCollection,\n        hierarchyConfig,\n      })\n\n      // Hide from nav when sidebar tab is injected (unless user explicitly set group)\n      if (hierarchyCollection.admin?.group === undefined) {\n        hierarchyCollection.admin = {\n          ...hierarchyCollection.admin,\n          group: false,\n        }\n      }\n    }\n  }\n}\n\n/**\n * Injects validation for collectionSpecific hierarchy fields.\n * Ensures the selected hierarchy item allows documents of this collection type.\n */\nfunction injectCollectionSpecificValidation({\n  hierarchyField,\n  hierarchySlug,\n  typeFieldName,\n}: {\n  hierarchyField: RelationshipField\n  hierarchySlug: string\n  typeFieldName: string\n}): void {\n  const existingValidate = hierarchyField.validate\n\n  const validate: Validate<unknown> = async (value, options) => {\n    // Run existing validation first if present\n    if (existingValidate) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const existingResult = await existingValidate(value as any, options as any)\n      if (existingResult !== true) {\n        return existingResult\n      }\n    }\n\n    // No hierarchy selected, no validation needed\n    if (!value) {\n      return true\n    }\n\n    const { collectionSlug, overrideAccess, previousValue, req } = options\n    const newID = extractID<Document>(value)\n\n    // Value didn't change, no validation needed\n    if (previousValue && extractID<Document>(previousValue) === newID) {\n      return true\n    }\n\n    // Fetch the hierarchy item to check its type field\n    let parentItem: Document | null = null\n    if (typeof newID === 'string' || typeof newID === 'number') {\n      try {\n        parentItem = await req.payload.findByID({\n          id: newID,\n          collection: hierarchySlug,\n          depth: 0,\n          overrideAccess: overrideAccess ?? false,\n          req,\n          select: { [typeFieldName]: true },\n        })\n      } catch {\n        return `Hierarchy item with ID ${newID} not found`\n      }\n    }\n\n    if (!parentItem) {\n      return `Hierarchy item with ID ${newID} not found`\n    }\n\n    const allowedTypes: string[] = (parentItem[typeFieldName] as string[]) || []\n\n    // If hierarchy has no types, it accepts all collections\n    if (allowedTypes.length === 0) {\n      return true\n    }\n\n    // Check if this collection is allowed\n    if (collectionSlug && allowedTypes.includes(collectionSlug)) {\n      return true\n    }\n\n    return `Hierarchy item \"${newID}\" does not allow documents of type \"${collectionSlug}\"`\n  }\n\n  hierarchyField.validate = validate\n}\n\n/**\n * Injects the hierarchyType select field into a hierarchy collection.\n */\nfunction injectTypeField({\n  config,\n  hierarchyCollection,\n  parentFieldName,\n  sanitizedRelatedCollections,\n  typeFieldName,\n}: {\n  config: Config\n  hierarchyCollection: CollectionConfig | SanitizedCollectionConfig\n  parentFieldName: string\n  sanitizedRelatedCollections: Record<string, SanitizedHierarchyRelatedCollection>\n  typeFieldName: string\n}): void {\n  const collectionOptions: Option[] = Object.keys(sanitizedRelatedCollections).map((slug) => {\n    const relatedCollection = config.collections?.find((c) => c.slug === slug)\n    return {\n      label: relatedCollection?.labels?.plural || slug,\n      value: slug,\n    }\n  })\n\n  const typeField: SelectField = {\n    name: typeFieldName,\n    type: 'select',\n    admin: {\n      components: {\n        Field: {\n          path: '@payloadcms/next/rsc#HierarchyTypeFieldServer',\n          serverProps: {\n            collectionOptions,\n            parentFieldName,\n          },\n        },\n      },\n      position: 'sidebar',\n    },\n    hasMany: true,\n    options: collectionOptions,\n  }\n\n  hierarchyCollection.fields = hierarchyCollection.fields || []\n  hierarchyCollection.fields.push(typeField)\n\n  // Recompute flattenedFields since we added a field after initial sanitization\n  // This is required for the field to be queryable\n  if ('flattenedFields' in hierarchyCollection) {\n    hierarchyCollection.flattenedFields = flattenAllFields({\n      fields: hierarchyCollection.fields,\n    })\n  }\n}\n\n/**\n * Injects a join field to query all children of a hierarchy item.\n */\nfunction injectJoinField({\n  config,\n  hierarchyCollection,\n  joinFieldConfig,\n  parentFieldName,\n  relatedSlugs,\n}: {\n  config: Config\n  hierarchyCollection: SanitizedCollectionConfig\n  joinFieldConfig: HierarchyJoinFieldConfig\n  parentFieldName: string\n  relatedSlugs: string[]\n}): void {\n  const { name, admin: userAdmin, ...userConfig } = joinFieldConfig\n\n  const hasJoinField = hierarchyCollection.fields?.some(\n    (field) => 'name' in field && field.name === name,\n  )\n\n  if (hasJoinField) {\n    return\n  }\n\n  const joinField: JoinField = {\n    // User config (spread first so auto-generated values take precedence for required fields)\n    ...userConfig,\n    // Auto-generated values (these cannot be overridden)\n    name,\n    type: 'join',\n    collection: [hierarchyCollection.slug, ...relatedSlugs],\n    hasMany: true,\n    on: parentFieldName,\n    // Merge admin config\n    admin: {\n      ...userAdmin,\n    },\n  }\n\n  hierarchyCollection.fields = hierarchyCollection.fields || []\n  hierarchyCollection.fields.push(joinField)\n\n  // Sanitize the join field to register it properly\n  sanitizeJoinField({\n    config,\n    field: joinField,\n    joins: hierarchyCollection.joins,\n    parentIsLocalized: false,\n    polymorphicJoins: hierarchyCollection.polymorphicJoins,\n  })\n\n  // Recompute flattenedFields since we added a field after initial sanitization\n  hierarchyCollection.flattenedFields = flattenAllFields({\n    fields: hierarchyCollection.fields,\n  })\n}\n\n/**\n * Injects afterDelete hook to clear hierarchy references from related documents.\n */\nfunction injectAfterDeleteHook({\n  hierarchyCollection,\n  sanitizedRelatedCollections,\n}: {\n  hierarchyCollection: CollectionConfig | SanitizedCollectionConfig\n  sanitizedRelatedCollections: Record<string, SanitizedHierarchyRelatedCollection>\n}): void {\n  // Build map of collection slugs to their field names\n  const relatedCollectionFieldMap: Record<string, string> = {}\n  for (const [slug, relatedConfig] of Object.entries(sanitizedRelatedCollections)) {\n    relatedCollectionFieldMap[slug] = relatedConfig.fieldName\n  }\n\n  hierarchyCollection.hooks = hierarchyCollection.hooks || {}\n  hierarchyCollection.hooks.afterDelete = [\n    ...(hierarchyCollection.hooks.afterDelete || []),\n    hierarchyCollectionAfterDelete({ relatedCollections: relatedCollectionFieldMap }),\n  ]\n}\n\n/**\n * Injects a sidebar tab for a hierarchy collection.\n */\nfunction injectSidebarTab({\n  config,\n  hierarchyCollection,\n  hierarchyConfig,\n}: {\n  config: Config\n  hierarchyCollection: CollectionConfig\n  hierarchyConfig: SanitizedHierarchyConfig\n}): void {\n  const tabSlug = `hierarchy-${hierarchyCollection.slug}`\n  const Icon = hierarchyConfig.admin.components.Icon\n\n  // Initialize admin config structure\n  config.admin = config.admin || {}\n  config.admin.components = config.admin.components || {}\n  config.admin.components.sidebar = config.admin.components.sidebar || {}\n  config.admin.components.sidebar.tabs = config.admin.components.sidebar.tabs || []\n\n  // Check if tab already exists\n  const hasTab = config.admin.components.sidebar.tabs.some((tab) => tab.slug === tabSlug)\n\n  if (!hasTab) {\n    config.admin.components.sidebar.tabs.push({\n      slug: tabSlug,\n      components: {\n        Content: {\n          clientProps: {\n            hierarchyCollectionSlug: hierarchyCollection.slug,\n          },\n          path: '@payloadcms/ui/rsc#HierarchySidebarTabServer',\n        },\n        Icon,\n      },\n      label: hierarchyCollection.labels?.plural || hierarchyCollection.slug,\n    })\n  }\n}\n"],"names":["sanitizeJoinField","fieldAffectsData","extractID","flattenAllFields","getHierarchyFieldName","hierarchyCollectionAfterDelete","injectHierarchyButton","resolveHierarchyCollections","config","hierarchyCollections","collections","filter","col","hierarchy","hierarchyCollection","hierarchyConfig","defaultFieldName","slug","parentFieldName","isParentFieldNameOverridden","collectionSpecific","typeFieldName","fieldName","undefined","allowHasMany","sanitizedRelatedCollections","selfParentField","fields","find","field","name","type","relationTo","custom","injectHeaderButton","collection","hierarchyCollectionSlug","hierarchyField","fieldHasMany","hasMany","injectCollectionSpecificValidation","hierarchySlug","injectTypeField","joinField","injectJoinField","joinFieldConfig","relatedSlugs","Object","keys","relatedCollections","length","injectAfterDeleteHook","admin","injectSidebarTab","group","existingValidate","validate","value","options","existingResult","collectionSlug","overrideAccess","previousValue","req","newID","parentItem","payload","findByID","id","depth","select","allowedTypes","includes","collectionOptions","map","relatedCollection","c","label","labels","plural","typeField","components","Field","path","serverProps","position","push","flattenedFields","userAdmin","userConfig","hasJoinField","some","on","joins","parentIsLocalized","polymorphicJoins","relatedCollectionFieldMap","relatedConfig","entries","hooks","afterDelete","tabSlug","Icon","sidebar","tabs","hasTab","tab","Content","clientProps"],"mappings":"AAgBA,SAASA,iBAAiB,QAAQ,wCAAuC;AACzE,SAASC,gBAAgB,QAAQ,4BAA2B;AAC5D,SAASC,SAAS,QAAQ,4BAA2B;AACrD,SAASC,gBAAgB,QAAQ,mCAAkC;AACnE,SAASC,qBAAqB,QAAQ,iBAAgB;AACtD,SAASC,8BAA8B,QAAQ,mCAAkC;AACjF,SAASC,qBAAqB,QAAQ,6BAA4B;AAElE;;;;;;;;;;;;;;;;;;;CAmBC,GACD,OAAO,MAAMC,8BAA8B,CAACC;IAC1C,MAAMC,uBACJD,OAAOE,WAAW,EAAEC,OAAO,CAACC,MAAQA,IAAIC,SAAS,IAAI,OAAOD,IAAIC,SAAS,KAAK,aAAa,EAAE;IAE/F,KAAK,MAAMC,uBAAuBL,qBAAsB;QACtD,MAAMI,YAAYC,oBAAoBD,SAAS;QAE/C,iFAAiF;QACjF,IAAI,CAACA,aAAa,OAAOA,cAAc,UAAU;YAC/C;QACF;QAEA,MAAME,kBAAkBF;QACxB,MAAMG,mBAAmBZ,sBAAsBU,oBAAoBG,IAAI;QACvE,MAAMC,kBAAkBH,gBAAgBG,eAAe,IAAIF;QAC3D,MAAMG,8BAA8BD,oBAAoBF;QACxD,MAAMI,qBAAqBL,gBAAgBK,kBAAkB;QAC7D,MAAMC,gBAAgBD,qBAAqBA,mBAAmBE,SAAS,GAAGC;QAC1E,MAAMC,eAAeT,gBAAgBS,YAAY,IAAI;QAErD,4EAA4E;QAC5E,MAAMC,8BAAmF,CAAC;QAE1F,MAAMC,kBAAkBZ,oBAAoBa,MAAM,CAACC,IAAI,CACrD,CAACC,QACC5B,iBAAiB4B,UACjBA,MAAMC,IAAI,KAAKZ,mBACfW,MAAME,IAAI,KAAK,kBACf,AAACF,MAA4BG,UAAU,KAAKlB,oBAAoBG,IAAI;QAGxE,+FAA+F;QAC/F,IAAIS,iBAAiBO,QAAQpB,WAAWqB,uBAAuB,MAAM;YACnE5B,sBAAsB;gBACpB6B,YAAYrB;gBACZQ,WAAWJ;gBACXkB,yBAAyBtB,oBAAoBG,IAAI;gBACjDC,iBAAiBH,gBAAgBG,eAAe;YAClD;QACF;QAEA,KAAK,MAAMiB,cAAc3B,OAAOE,WAAW,IAAI,EAAE,CAAE;YACjD,uDAAuD;YACvD,IAAIyB,WAAWlB,IAAI,KAAKH,oBAAoBG,IAAI,EAAE;gBAChD;YACF;YAEA,yEAAyE;YACzE,MAAMoB,iBAAiBF,WAAWR,MAAM,CAACC,IAAI,CAC3C,CAACC,QACC5B,iBAAiB4B,UACjBA,MAAMC,IAAI,KAAKd,oBACfa,MAAME,IAAI,KAAK,kBACf,AAACF,MAA4BG,UAAU,KAAKlB,oBAAoBG,IAAI;YAGxE,8DAA8D;YAC9D,IAAIoB,kBAAkBlB,6BAA6B;gBACjDkB,eAAeP,IAAI,GAAGZ;YACxB;YAEA,IAAI,CAACmB,gBAAgB;gBACnB;YACF;YAEA,MAAMC,eAAeD,eAAeE,OAAO,IAAIf;YAE/C,0FAA0F;YAC1F,IAAIJ,oBAAoB;gBACtBoB,mCAAmC;oBACjCH;oBACAI,eAAe3B,oBAAoBG,IAAI;oBACvCI,eAAeA;gBACjB;YACF;YAEA,gDAAgD;YAChDI,2BAA2B,CAACU,WAAWlB,IAAI,CAAC,GAAG;gBAC7CK,WAAWJ;gBACXqB,SAASD;YACX;YAEA,8CAA8C;YAC9C,IAAID,eAAeJ,MAAM,EAAEpB,WAAWqB,uBAAuB,MAAM;gBACjE5B,sBAAsB;oBACpB6B;oBACAb,WAAWJ;oBACXkB,yBAAyBtB,oBAAoBG,IAAI;oBACjDC,iBAAiBH,gBAAgBG,eAAe;gBAClD;YACF;QACF;QAEA,gEAAgE;QAChE,IAAIH,gBAAgBK,kBAAkB,EAAE;YACtCsB,gBAAgB;gBACdlC;gBACAM,qBAAqBA;gBACrBI,iBAAiBH,gBAAgBG,eAAe;gBAChDO;gBACAJ,eAAeN,gBAAgBK,kBAAkB,CAACE,SAAS;YAC7D;QACF;QAEA,mEAAmE;QACnE,IAAIP,gBAAgB4B,SAAS,EAAE;YAC7BC,gBAAgB;gBACdpC;gBACAM,qBAAqBA;gBACrB+B,iBAAiB9B,gBAAgB4B,SAAS;gBAC1CzB;gBACA4B,cAAcC,OAAOC,IAAI,CAACvB;YAC5B;QACF;QAEA,4DAA4D;QAC5D,IAAIV,iBAAiB;YACnBA,gBAAgBkC,kBAAkB,GAAGxB;QACvC;QAEA,yEAAyE;QACzE,IAAIsB,OAAOC,IAAI,CAACvB,6BAA6ByB,MAAM,GAAG,GAAG;YACvDC,sBAAsB;gBACpBrC,qBAAqBA;gBACrBW;YACF;QACF;QAEA,6EAA6E;QAC7E,IAAIV,gBAAgBqC,KAAK,CAACC,gBAAgB,KAAK,OAAO;YACpDA,iBAAiB;gBACf7C;gBACAM;gBACAC;YACF;YAEA,gFAAgF;YAChF,IAAID,oBAAoBsC,KAAK,EAAEE,UAAU/B,WAAW;gBAClDT,oBAAoBsC,KAAK,GAAG;oBAC1B,GAAGtC,oBAAoBsC,KAAK;oBAC5BE,OAAO;gBACT;YACF;QACF;IACF;AACF,EAAC;AAED;;;CAGC,GACD,SAASd,mCAAmC,EAC1CH,cAAc,EACdI,aAAa,EACbpB,aAAa,EAKd;IACC,MAAMkC,mBAAmBlB,eAAemB,QAAQ;IAEhD,MAAMA,WAA8B,OAAOC,OAAOC;QAChD,2CAA2C;QAC3C,IAAIH,kBAAkB;YACpB,8DAA8D;YAC9D,MAAMI,iBAAiB,MAAMJ,iBAAiBE,OAAcC;YAC5D,IAAIC,mBAAmB,MAAM;gBAC3B,OAAOA;YACT;QACF;QAEA,8CAA8C;QAC9C,IAAI,CAACF,OAAO;YACV,OAAO;QACT;QAEA,MAAM,EAAEG,cAAc,EAAEC,cAAc,EAAEC,aAAa,EAAEC,GAAG,EAAE,GAAGL;QAC/D,MAAMM,QAAQ9D,UAAoBuD;QAElC,4CAA4C;QAC5C,IAAIK,iBAAiB5D,UAAoB4D,mBAAmBE,OAAO;YACjE,OAAO;QACT;QAEA,mDAAmD;QACnD,IAAIC,aAA8B;QAClC,IAAI,OAAOD,UAAU,YAAY,OAAOA,UAAU,UAAU;YAC1D,IAAI;gBACFC,aAAa,MAAMF,IAAIG,OAAO,CAACC,QAAQ,CAAC;oBACtCC,IAAIJ;oBACJ7B,YAAYM;oBACZ4B,OAAO;oBACPR,gBAAgBA,kBAAkB;oBAClCE;oBACAO,QAAQ;wBAAE,CAACjD,cAAc,EAAE;oBAAK;gBAClC;YACF,EAAE,OAAM;gBACN,OAAO,CAAC,uBAAuB,EAAE2C,MAAM,UAAU,CAAC;YACpD;QACF;QAEA,IAAI,CAACC,YAAY;YACf,OAAO,CAAC,uBAAuB,EAAED,MAAM,UAAU,CAAC;QACpD;QAEA,MAAMO,eAAyB,AAACN,UAAU,CAAC5C,cAAc,IAAiB,EAAE;QAE5E,wDAAwD;QACxD,IAAIkD,aAAarB,MAAM,KAAK,GAAG;YAC7B,OAAO;QACT;QAEA,sCAAsC;QACtC,IAAIU,kBAAkBW,aAAaC,QAAQ,CAACZ,iBAAiB;YAC3D,OAAO;QACT;QAEA,OAAO,CAAC,gBAAgB,EAAEI,MAAM,oCAAoC,EAAEJ,eAAe,CAAC,CAAC;IACzF;IAEAvB,eAAemB,QAAQ,GAAGA;AAC5B;AAEA;;CAEC,GACD,SAASd,gBAAgB,EACvBlC,MAAM,EACNM,mBAAmB,EACnBI,eAAe,EACfO,2BAA2B,EAC3BJ,aAAa,EAOd;IACC,MAAMoD,oBAA8B1B,OAAOC,IAAI,CAACvB,6BAA6BiD,GAAG,CAAC,CAACzD;QAChF,MAAM0D,oBAAoBnE,OAAOE,WAAW,EAAEkB,KAAK,CAACgD,IAAMA,EAAE3D,IAAI,KAAKA;QACrE,OAAO;YACL4D,OAAOF,mBAAmBG,QAAQC,UAAU9D;YAC5CwC,OAAOxC;QACT;IACF;IAEA,MAAM+D,YAAyB;QAC7BlD,MAAMT;QACNU,MAAM;QACNqB,OAAO;YACL6B,YAAY;gBACVC,OAAO;oBACLC,MAAM;oBACNC,aAAa;wBACXX;wBACAvD;oBACF;gBACF;YACF;YACAmE,UAAU;QACZ;QACA9C,SAAS;QACTmB,SAASe;IACX;IAEA3D,oBAAoBa,MAAM,GAAGb,oBAAoBa,MAAM,IAAI,EAAE;IAC7Db,oBAAoBa,MAAM,CAAC2D,IAAI,CAACN;IAEhC,8EAA8E;IAC9E,iDAAiD;IACjD,IAAI,qBAAqBlE,qBAAqB;QAC5CA,oBAAoByE,eAAe,GAAGpF,iBAAiB;YACrDwB,QAAQb,oBAAoBa,MAAM;QACpC;IACF;AACF;AAEA;;CAEC,GACD,SAASiB,gBAAgB,EACvBpC,MAAM,EACNM,mBAAmB,EACnB+B,eAAe,EACf3B,eAAe,EACf4B,YAAY,EAOb;IACC,MAAM,EAAEhB,IAAI,EAAEsB,OAAOoC,SAAS,EAAE,GAAGC,YAAY,GAAG5C;IAElD,MAAM6C,eAAe5E,oBAAoBa,MAAM,EAAEgE,KAC/C,CAAC9D,QAAU,UAAUA,SAASA,MAAMC,IAAI,KAAKA;IAG/C,IAAI4D,cAAc;QAChB;IACF;IAEA,MAAM/C,YAAuB;QAC3B,0FAA0F;QAC1F,GAAG8C,UAAU;QACb,qDAAqD;QACrD3D;QACAC,MAAM;QACNI,YAAY;YAACrB,oBAAoBG,IAAI;eAAK6B;SAAa;QACvDP,SAAS;QACTqD,IAAI1E;QACJ,qBAAqB;QACrBkC,OAAO;YACL,GAAGoC,SAAS;QACd;IACF;IAEA1E,oBAAoBa,MAAM,GAAGb,oBAAoBa,MAAM,IAAI,EAAE;IAC7Db,oBAAoBa,MAAM,CAAC2D,IAAI,CAAC3C;IAEhC,kDAAkD;IAClD3C,kBAAkB;QAChBQ;QACAqB,OAAOc;QACPkD,OAAO/E,oBAAoB+E,KAAK;QAChCC,mBAAmB;QACnBC,kBAAkBjF,oBAAoBiF,gBAAgB;IACxD;IAEA,8EAA8E;IAC9EjF,oBAAoByE,eAAe,GAAGpF,iBAAiB;QACrDwB,QAAQb,oBAAoBa,MAAM;IACpC;AACF;AAEA;;CAEC,GACD,SAASwB,sBAAsB,EAC7BrC,mBAAmB,EACnBW,2BAA2B,EAI5B;IACC,qDAAqD;IACrD,MAAMuE,4BAAoD,CAAC;IAC3D,KAAK,MAAM,CAAC/E,MAAMgF,cAAc,IAAIlD,OAAOmD,OAAO,CAACzE,6BAA8B;QAC/EuE,yBAAyB,CAAC/E,KAAK,GAAGgF,cAAc3E,SAAS;IAC3D;IAEAR,oBAAoBqF,KAAK,GAAGrF,oBAAoBqF,KAAK,IAAI,CAAC;IAC1DrF,oBAAoBqF,KAAK,CAACC,WAAW,GAAG;WAClCtF,oBAAoBqF,KAAK,CAACC,WAAW,IAAI,EAAE;QAC/C/F,+BAA+B;YAAE4C,oBAAoB+C;QAA0B;KAChF;AACH;AAEA;;CAEC,GACD,SAAS3C,iBAAiB,EACxB7C,MAAM,EACNM,mBAAmB,EACnBC,eAAe,EAKhB;IACC,MAAMsF,UAAU,CAAC,UAAU,EAAEvF,oBAAoBG,IAAI,EAAE;IACvD,MAAMqF,OAAOvF,gBAAgBqC,KAAK,CAAC6B,UAAU,CAACqB,IAAI;IAElD,oCAAoC;IACpC9F,OAAO4C,KAAK,GAAG5C,OAAO4C,KAAK,IAAI,CAAC;IAChC5C,OAAO4C,KAAK,CAAC6B,UAAU,GAAGzE,OAAO4C,KAAK,CAAC6B,UAAU,IAAI,CAAC;IACtDzE,OAAO4C,KAAK,CAAC6B,UAAU,CAACsB,OAAO,GAAG/F,OAAO4C,KAAK,CAAC6B,UAAU,CAACsB,OAAO,IAAI,CAAC;IACtE/F,OAAO4C,KAAK,CAAC6B,UAAU,CAACsB,OAAO,CAACC,IAAI,GAAGhG,OAAO4C,KAAK,CAAC6B,UAAU,CAACsB,OAAO,CAACC,IAAI,IAAI,EAAE;IAEjF,8BAA8B;IAC9B,MAAMC,SAASjG,OAAO4C,KAAK,CAAC6B,UAAU,CAACsB,OAAO,CAACC,IAAI,CAACb,IAAI,CAAC,CAACe,MAAQA,IAAIzF,IAAI,KAAKoF;IAE/E,IAAI,CAACI,QAAQ;QACXjG,OAAO4C,KAAK,CAAC6B,UAAU,CAACsB,OAAO,CAACC,IAAI,CAAClB,IAAI,CAAC;YACxCrE,MAAMoF;YACNpB,YAAY;gBACV0B,SAAS;oBACPC,aAAa;wBACXxE,yBAAyBtB,oBAAoBG,IAAI;oBACnD;oBACAkE,MAAM;gBACR;gBACAmB;YACF;YACAzB,OAAO/D,oBAAoBgE,MAAM,EAAEC,UAAUjE,oBAAoBG,IAAI;QACvE;IACF;AACF"}

package/dist/hierarchy/sanitizeHierarchyCollection.d.ts

@@ -0,0 +1,14 @@
+import type { CollectionConfig } from '../collections/config/types.js';
+import type { Config } from '../config/types.js';
+/**
+ * Sanitizes hierarchy configuration for a single collection.
+ *
+ * This is phase 1 of hierarchy setup, called during individual collection sanitization.
+ * It normalizes the hierarchy config, creates the parent field if needed, adds hooks,
+ * and sets up the sanitized config structure.
+ *
+ * Phase 2 (`resolveHierarchyCollections`) runs after all collections are sanitized
+ * to establish cross-collection relationships.
+ */
+export declare const sanitizeHierarchyCollection: (collectionConfig: CollectionConfig, _config: Config) => void;
+//# sourceMappingURL=sanitizeHierarchyCollection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeHierarchyCollection.d.ts","sourceRoot":"","sources":["../../src/hierarchy/sanitizeHierarchyCollection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAgBhD;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,qBACpB,gBAAgB,WACzB,MAAM,KACd,IAkIF,CAAA"}

package/dist/hierarchy/sanitizeHierarchyCollection.js

@@ -0,0 +1,117 @@
+import { fieldAffectsData } from '../fields/config/types.js';
+import { slugify as defaultSlugify } from '../utilities/slugify.js';
+import { addHierarchyToCollection } from './addHierarchyToCollection.js';
+import { buildParentField } from './buildParentField.js';
+import { DEFAULT_ALLOW_HAS_MANY, DEFAULT_HIERARCHY_TREE_LIMIT, getHierarchyFieldName, HIERARCHY_SLUG_PATH_FIELD, HIERARCHY_TITLE_PATH_FIELD } from './constants.js';
+import { ensureSafeCollectionsChange } from './hooks/ensureSafeCollectionsChange.js';
+/**
+ * Sanitizes hierarchy configuration for a single collection.
+ *
+ * This is phase 1 of hierarchy setup, called during individual collection sanitization.
+ * It normalizes the hierarchy config, creates the parent field if needed, adds hooks,
+ * and sets up the sanitized config structure.
+ *
+ * Phase 2 (`resolveHierarchyCollections`) runs after all collections are sanitized
+ * to establish cross-collection relationships.
+ */ export const sanitizeHierarchyCollection = (collectionConfig, _config)=>{
+    if (!collectionConfig.hierarchy) {
+        collectionConfig.hierarchy = false;
+        return;
+    }
+    // Normalize boolean to object and apply parentFieldName default
+    const defaultParentFieldName = getHierarchyFieldName(collectionConfig.slug);
+    if (collectionConfig.hierarchy === true) {
+        collectionConfig.hierarchy = {
+            parentFieldName: defaultParentFieldName
+        };
+    }
+    const parentFieldName = collectionConfig.hierarchy.parentFieldName ?? defaultParentFieldName;
+    // Check if parent field already exists
+    const existingParentField = collectionConfig.fields.find((field)=>fieldAffectsData(field) && field.name === parentFieldName);
+    if (existingParentField) {
+        // Validate existing parent field configuration
+        if (existingParentField.type !== 'relationship') {
+            throw new Error(`Hierarchy parent field "${parentFieldName}" in collection "${collectionConfig.slug}" must be a relationship field`);
+        }
+        if (existingParentField.hasMany !== false) {
+            throw new Error(`Hierarchy parent field "${parentFieldName}" in collection "${collectionConfig.slug}" must have hasMany set to false`);
+        }
+        if (existingParentField.localized === true) {
+            throw new Error(`Hierarchy parent field "${parentFieldName}" in collection "${collectionConfig.slug}" cannot be localized. The parent relationship must be consistent across all locales.`);
+        }
+    } else {
+        // Auto-create parent field if it doesn't exist
+        // useHeaderButton defaults to true - parent selection via header button with miller columns
+        const useHeaderButton = collectionConfig.hierarchy.admin?.useHeaderButton ?? true;
+        const parentField = buildParentField({
+            collectionSlug: collectionConfig.slug,
+            injectHeaderButton: useHeaderButton,
+            parentFieldName
+        });
+        collectionConfig.fields.unshift(parentField);
+    }
+    // Apply defaults for optional fields
+    const slugPathFieldName = collectionConfig.hierarchy.slugPathFieldName || HIERARCHY_SLUG_PATH_FIELD;
+    const titlePathFieldName = collectionConfig.hierarchy.titlePathFieldName || HIERARCHY_TITLE_PATH_FIELD;
+    const allowHasMany = collectionConfig.hierarchy.allowHasMany ?? DEFAULT_ALLOW_HAS_MANY;
+    const rawCollectionSpecific = collectionConfig.hierarchy.collectionSpecific;
+    const collectionSpecific = rawCollectionSpecific === true ? {
+        fieldName: 'hierarchyType'
+    } : rawCollectionSpecific ? {
+        fieldName: rawCollectionSpecific.fieldName ?? 'hierarchyType'
+    } : false;
+    const joinField = collectionConfig.hierarchy.joinField ? collectionConfig.hierarchy.joinField : undefined;
+    const slugify = collectionConfig.hierarchy.slugify ?? ((text)=>defaultSlugify(text) ?? '');
+    const treeLimit = collectionConfig.hierarchy.admin?.treeLimit ?? DEFAULT_HIERARCHY_TREE_LIMIT;
+    const iconComponent = collectionConfig.hierarchy.admin?.components?.Icon;
+    const slugField = collectionConfig.hierarchy.slugField;
+    // Apply hierarchy to collection (adds fields and hooks)
+    addHierarchyToCollection({
+        collectionConfig,
+        parentFieldName: collectionConfig.hierarchy.parentFieldName,
+        slugFieldName: slugField,
+        slugPathFieldName,
+        titlePathFieldName
+    });
+    // If collectionSpecific, add beforeValidate hook to enforce scope inheritance
+    // (hierarchyType field is added in resolveHierarchyCollections after discovery)
+    if (collectionSpecific) {
+        // Use parentFieldName for both - backward compatible configs use the same field name everywhere
+        if (!collectionConfig.hooks) {
+            collectionConfig.hooks = {};
+        }
+        if (!collectionConfig.hooks.beforeValidate) {
+            collectionConfig.hooks.beforeValidate = [];
+        }
+        collectionConfig.hooks.beforeValidate.push(ensureSafeCollectionsChange({
+            folderFieldName: parentFieldName,
+            foldersSlug: collectionConfig.slug,
+            parentFieldName,
+            typeFieldName: collectionSpecific.fieldName
+        }));
+    }
+    // Set sanitized hierarchy config (cast needed as we're transitioning from HierarchyConfig to SanitizedHierarchyConfig)
+    const useHeaderButton = collectionConfig.hierarchy.admin?.useHeaderButton ?? false;
+    const injectSidebarTab = collectionConfig.hierarchy.admin?.injectSidebarTab ?? true;
+    collectionConfig.hierarchy = {
+        admin: {
+            components: {
+                Icon: iconComponent || '@payloadcms/ui#TagIcon'
+            },
+            injectSidebarTab,
+            treeLimit,
+            useHeaderButton
+        },
+        allowHasMany,
+        collectionSpecific,
+        joinField,
+        parentFieldName,
+        relatedCollections: {},
+        slugField,
+        slugify,
+        slugPathFieldName,
+        titlePathFieldName
+    };
+};
+
+//# sourceMappingURL=sanitizeHierarchyCollection.js.map

package/dist/hierarchy/sanitizeHierarchyCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/sanitizeHierarchyCollection.ts"],"sourcesContent":["import type { CollectionConfig } from '../collections/config/types.js'\nimport type { Config } from '../config/types.js'\nimport type { SanitizedHierarchyConfig } from './types.js'\n\nimport { fieldAffectsData } from '../fields/config/types.js'\nimport { slugify as defaultSlugify } from '../utilities/slugify.js'\nimport { addHierarchyToCollection } from './addHierarchyToCollection.js'\nimport { buildParentField } from './buildParentField.js'\nimport {\n  DEFAULT_ALLOW_HAS_MANY,\n  DEFAULT_HIERARCHY_TREE_LIMIT,\n  getHierarchyFieldName,\n  HIERARCHY_SLUG_PATH_FIELD,\n  HIERARCHY_TITLE_PATH_FIELD,\n} from './constants.js'\nimport { ensureSafeCollectionsChange } from './hooks/ensureSafeCollectionsChange.js'\n\n/**\n * Sanitizes hierarchy configuration for a single collection.\n *\n * This is phase 1 of hierarchy setup, called during individual collection sanitization.\n * It normalizes the hierarchy config, creates the parent field if needed, adds hooks,\n * and sets up the sanitized config structure.\n *\n * Phase 2 (`resolveHierarchyCollections`) runs after all collections are sanitized\n * to establish cross-collection relationships.\n */\nexport const sanitizeHierarchyCollection = (\n  collectionConfig: CollectionConfig,\n  _config: Config,\n): void => {\n  if (!collectionConfig.hierarchy) {\n    collectionConfig.hierarchy = false\n    return\n  }\n\n  // Normalize boolean to object and apply parentFieldName default\n  const defaultParentFieldName = getHierarchyFieldName(collectionConfig.slug)\n\n  if (collectionConfig.hierarchy === true) {\n    collectionConfig.hierarchy = {\n      parentFieldName: defaultParentFieldName,\n    }\n  }\n\n  const parentFieldName = collectionConfig.hierarchy.parentFieldName ?? defaultParentFieldName\n\n  // Check if parent field already exists\n  const existingParentField = collectionConfig.fields.find(\n    (field) => fieldAffectsData(field) && field.name === parentFieldName,\n  )\n\n  if (existingParentField) {\n    // Validate existing parent field configuration\n    if (existingParentField.type !== 'relationship') {\n      throw new Error(\n        `Hierarchy parent field \"${parentFieldName}\" in collection \"${collectionConfig.slug}\" must be a relationship field`,\n      )\n    }\n\n    if (existingParentField.hasMany !== false) {\n      throw new Error(\n        `Hierarchy parent field \"${parentFieldName}\" in collection \"${collectionConfig.slug}\" must have hasMany set to false`,\n      )\n    }\n\n    if (existingParentField.localized === true) {\n      throw new Error(\n        `Hierarchy parent field \"${parentFieldName}\" in collection \"${collectionConfig.slug}\" cannot be localized. The parent relationship must be consistent across all locales.`,\n      )\n    }\n  } else {\n    // Auto-create parent field if it doesn't exist\n    // useHeaderButton defaults to true - parent selection via header button with miller columns\n    const useHeaderButton = collectionConfig.hierarchy.admin?.useHeaderButton ?? true\n\n    const parentField = buildParentField({\n      collectionSlug: collectionConfig.slug,\n      injectHeaderButton: useHeaderButton,\n      parentFieldName,\n    })\n\n    collectionConfig.fields.unshift(parentField)\n  }\n\n  // Apply defaults for optional fields\n  const slugPathFieldName =\n    collectionConfig.hierarchy.slugPathFieldName || HIERARCHY_SLUG_PATH_FIELD\n  const titlePathFieldName =\n    collectionConfig.hierarchy.titlePathFieldName || HIERARCHY_TITLE_PATH_FIELD\n  const allowHasMany = collectionConfig.hierarchy.allowHasMany ?? DEFAULT_ALLOW_HAS_MANY\n  const rawCollectionSpecific = collectionConfig.hierarchy.collectionSpecific\n  const collectionSpecific: { fieldName: string } | false =\n    rawCollectionSpecific === true\n      ? { fieldName: 'hierarchyType' }\n      : rawCollectionSpecific\n        ? { fieldName: rawCollectionSpecific.fieldName ?? 'hierarchyType' }\n        : false\n  const joinField = collectionConfig.hierarchy.joinField\n    ? collectionConfig.hierarchy.joinField\n    : undefined\n  const slugify =\n    collectionConfig.hierarchy.slugify ?? ((text: string) => defaultSlugify(text) ?? '')\n  const treeLimit = collectionConfig.hierarchy.admin?.treeLimit ?? DEFAULT_HIERARCHY_TREE_LIMIT\n  const iconComponent = collectionConfig.hierarchy.admin?.components?.Icon\n\n  const slugField = collectionConfig.hierarchy.slugField\n\n  // Apply hierarchy to collection (adds fields and hooks)\n  addHierarchyToCollection({\n    collectionConfig,\n    parentFieldName: collectionConfig.hierarchy.parentFieldName,\n    slugFieldName: slugField,\n    slugPathFieldName,\n    titlePathFieldName,\n  })\n\n  // If collectionSpecific, add beforeValidate hook to enforce scope inheritance\n  // (hierarchyType field is added in resolveHierarchyCollections after discovery)\n  if (collectionSpecific) {\n    // Use parentFieldName for both - backward compatible configs use the same field name everywhere\n    if (!collectionConfig.hooks) {\n      collectionConfig.hooks = {}\n    }\n    if (!collectionConfig.hooks.beforeValidate) {\n      collectionConfig.hooks.beforeValidate = []\n    }\n    collectionConfig.hooks.beforeValidate.push(\n      ensureSafeCollectionsChange({\n        folderFieldName: parentFieldName,\n        foldersSlug: collectionConfig.slug,\n        parentFieldName,\n        typeFieldName: collectionSpecific.fieldName,\n      }),\n    )\n  }\n\n  // Set sanitized hierarchy config (cast needed as we're transitioning from HierarchyConfig to SanitizedHierarchyConfig)\n  const useHeaderButton = collectionConfig.hierarchy.admin?.useHeaderButton ?? false\n  const injectSidebarTab = collectionConfig.hierarchy.admin?.injectSidebarTab ?? true\n\n  ;(collectionConfig as unknown as { hierarchy: SanitizedHierarchyConfig }).hierarchy = {\n    admin: {\n      components: {\n        Icon: iconComponent || '@payloadcms/ui#TagIcon',\n      },\n      injectSidebarTab,\n      treeLimit,\n      useHeaderButton,\n    },\n    allowHasMany,\n    collectionSpecific,\n    joinField,\n    parentFieldName,\n    relatedCollections: {},\n    slugField,\n    slugify,\n    slugPathFieldName,\n    titlePathFieldName,\n  }\n}\n"],"names":["fieldAffectsData","slugify","defaultSlugify","addHierarchyToCollection","buildParentField","DEFAULT_ALLOW_HAS_MANY","DEFAULT_HIERARCHY_TREE_LIMIT","getHierarchyFieldName","HIERARCHY_SLUG_PATH_FIELD","HIERARCHY_TITLE_PATH_FIELD","ensureSafeCollectionsChange","sanitizeHierarchyCollection","collectionConfig","_config","hierarchy","defaultParentFieldName","slug","parentFieldName","existingParentField","fields","find","field","name","type","Error","hasMany","localized","useHeaderButton","admin","parentField","collectionSlug","injectHeaderButton","unshift","slugPathFieldName","titlePathFieldName","allowHasMany","rawCollectionSpecific","collectionSpecific","fieldName","joinField","undefined","text","treeLimit","iconComponent","components","Icon","slugField","slugFieldName","hooks","beforeValidate","push","folderFieldName","foldersSlug","typeFieldName","injectSidebarTab","relatedCollections"],"mappings":"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"}

package/dist/hierarchy/types.d.ts

@@ -0,0 +1,155 @@
+import type { PayloadComponent } from '../config/types.js';
+import type { JoinField } from '../fields/config/types.js';
+/**
+ * User-configurable options for the hierarchy join field.
+ * Excludes properties that are auto-generated: type, collection, on, hasMany
+ */
+export type HierarchyJoinFieldConfig = {
+    name: string;
+} & Omit<Partial<JoinField>, 'collection' | 'hasMany' | 'name' | 'on' | 'type'>;
+/**
+ * Configuration options for hierarchy feature
+ *
+ * Hierarchies are always self-referential - documents can only nest under other documents
+ * from the same collection.
+ */
+export type HierarchyConfig = {
+    /**
+     * UI configuration for hierarchy
+     */
+    admin?: {
+        /**
+         * Custom components for hierarchy UI
+         */
+        components?: {
+            /**
+             * Custom icon component for hierarchy items
+             */
+            Icon?: PayloadComponent;
+        };
+        /**
+         * Whether to inject a sidebar tab for this hierarchy collection
+         * @default true
+         */
+        injectSidebarTab?: boolean;
+        /**
+         * Maximum number of items to load in tree views
+         * @default 100
+         */
+        treeLimit?: number;
+        /**
+         * Whether to use a header button for parent selection instead of inline field.
+         * When true, the parent field is hidden and a button is injected into the document header.
+         * @default true
+         */
+        useHeaderButton?: boolean;
+    };
+    /**
+     * Whether related documents can have multiple values of this hierarchy
+     * Set to false for folder-like behavior (single parent), true for tag-like behavior (multiple)
+     * @default true
+     */
+    allowHasMany?: boolean;
+    /**
+     * Whether this hierarchy is scoped to specific collections
+     * When true or an object, hierarchy items can be restricted to certain collections
+     * @default false
+     */
+    collectionSpecific?: {
+        /**
+         * Name of the select field for specifying allowed collections
+         * @default 'hierarchyType'
+         */
+        fieldName?: string;
+    } | boolean;
+    /**
+     * Configure a join field to query all children (nested hierarchy items and related documents)
+     * If not set, no join field is created.
+     * You can pass additional JoinField options (admin, defaultLimit, defaultSort, etc.)
+     * that will be merged with the auto-generated config.
+     */
+    joinField?: HierarchyJoinFieldConfig;
+    /**
+     * Name of the field that references the parent document
+     * Will automatically create this field if it does not exist
+     * @default '_h_${collectionSlug}' (e.g., '_h_folders' for a collection with slug 'folders')
+     */
+    parentFieldName: string;
+    /**
+     * Name of the field to use for slug path generation.
+     * When set, uses this field's value directly instead of slugifying the title.
+     * Useful when you have a dedicated slug field (e.g., 'slug') separate from the title.
+     * @example 'slug' - uses the 'slug' field value as-is for path segments
+     */
+    slugField?: string;
+    /**
+     * Custom function to slugify text for path generation
+     * Used by computeSlugPath() utility for generating slug-based breadcrumb paths
+     * Only used when slugField is not set.
+     * Defaults to internal slugify implementation
+     */
+    slugify?: (text: string) => string;
+    /**
+     * Name of the virtual field that will contain the slug-based breadcrumb path
+     * @default HIERARCHY_SLUG_PATH_FIELD ('_h_slugPath')
+     */
+    slugPathFieldName?: string;
+    /**
+     * Name of the virtual field that will contain the title-based breadcrumb path
+     * @default HIERARCHY_TITLE_PATH_FIELD ('_h_titlePath')
+     */
+    titlePathFieldName?: string;
+};
+/**
+ * Sanitized hierarchy configuration with all defaults applied
+ */
+export type SanitizedHierarchyConfig = {
+    admin: {
+        components: {
+            Icon: PayloadComponent;
+        };
+        injectSidebarTab: boolean;
+        treeLimit: number;
+        useHeaderButton: boolean;
+    };
+    allowHasMany: boolean;
+    collectionSpecific: {
+        fieldName: string;
+    } | false;
+    /**
+     * Join field configuration, or undefined if not enabled
+     */
+    joinField?: HierarchyJoinFieldConfig;
+    parentFieldName: string;
+    /**
+     * Auto-populated during validation - maps collection slug to field info
+     */
+    relatedCollections: Record<string, SanitizedHierarchyRelatedCollection>;
+    /**
+     * Field name for slug values, or undefined to use slugified title
+     */
+    slugField?: string;
+    slugify: (text: string) => string;
+    slugPathFieldName: string;
+    titlePathFieldName: string;
+};
+/**
+ * Information about how a collection relates to this hierarchy
+ */
+export type SanitizedHierarchyRelatedCollection = {
+    fieldName: string;
+    hasMany: boolean;
+};
+/**
+ * Client-safe hierarchy configuration (excludes functions that can't cross server-client boundary)
+ */
+export type ClientHierarchyConfig = Omit<SanitizedHierarchyConfig, 'slugify'>;
+/**
+ * Breadcrumb item for folder hierarchies
+ * @deprecated Use hierarchy breadcrumbs instead
+ */
+export type FolderBreadcrumb = {
+    id: number | string;
+    name: string;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/hierarchy/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAE1D;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,MAAM,CAAA;CACb,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC,CAAA;AAE/E;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,KAAK,CAAC,EAAE;QACN;;WAEG;QACH,UAAU,CAAC,EAAE;YACX;;eAEG;YACH,IAAI,CAAC,EAAE,gBAAgB,CAAA;SACxB,CAAA;QACD;;;WAGG;QACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;QAC1B;;;WAGG;QACH,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB;;;;WAIG;QACH,eAAe,CAAC,EAAE,OAAO,CAAA;KAC1B,CAAA;IACD;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB;;;;OAIG;IACH,kBAAkB,CAAC,EACf;QACE;;;WAGG;QACH,SAAS,CAAC,EAAE,MAAM,CAAA;KACnB,GACD,OAAO,CAAA;IACX;;;;;OAKG;IACH,SAAS,CAAC,EAAE,wBAAwB,CAAA;IACpC;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAA;IACvB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IAClC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE;QACL,UAAU,EAAE;YACV,IAAI,EAAE,gBAAgB,CAAA;SACvB,CAAA;QACD,gBAAgB,EAAE,OAAO,CAAA;QACzB,SAAS,EAAE,MAAM,CAAA;QACjB,eAAe,EAAE,OAAO,CAAA;KACzB,CAAA;IACD,YAAY,EAAE,OAAO,CAAA;IACrB,kBAAkB,EACd;QACE,SAAS,EAAE,MAAM,CAAA;KAClB,GACD,KAAK,CAAA;IACT;;OAEG;IACH,SAAS,CAAC,EAAE,wBAAwB,CAAA;IACpC,eAAe,EAAE,MAAM,CAAA;IACvB;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,mCAAmC,CAAC,CAAA;IACvE;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IACjC,iBAAiB,EAAE,MAAM,CAAA;IACzB,kBAAkB,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,mCAAmC,GAAG;IAChD,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,wBAAwB,EAAE,SAAS,CAAC,CAAA;AAE7E;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA"}

package/dist/hierarchy/types.js

@@ -0,0 +1,6 @@
+/**
+ * Breadcrumb item for folder hierarchies
+ * @deprecated Use hierarchy breadcrumbs instead
+ */ export { };
+
+//# sourceMappingURL=types.js.map

package/dist/hierarchy/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/types.ts"],"sourcesContent":["import type { PayloadComponent } from '../config/types.js'\nimport type { JoinField } from '../fields/config/types.js'\n\n/**\n * User-configurable options for the hierarchy join field.\n * Excludes properties that are auto-generated: type, collection, on, hasMany\n */\nexport type HierarchyJoinFieldConfig = {\n  name: string\n} & Omit<Partial<JoinField>, 'collection' | 'hasMany' | 'name' | 'on' | 'type'>\n\n/**\n * Configuration options for hierarchy feature\n *\n * Hierarchies are always self-referential - documents can only nest under other documents\n * from the same collection.\n */\nexport type HierarchyConfig = {\n  /**\n   * UI configuration for hierarchy\n   */\n  admin?: {\n    /**\n     * Custom components for hierarchy UI\n     */\n    components?: {\n      /**\n       * Custom icon component for hierarchy items\n       */\n      Icon?: PayloadComponent\n    }\n    /**\n     * Whether to inject a sidebar tab for this hierarchy collection\n     * @default true\n     */\n    injectSidebarTab?: boolean\n    /**\n     * Maximum number of items to load in tree views\n     * @default 100\n     */\n    treeLimit?: number\n    /**\n     * Whether to use a header button for parent selection instead of inline field.\n     * When true, the parent field is hidden and a button is injected into the document header.\n     * @default true\n     */\n    useHeaderButton?: boolean\n  }\n  /**\n   * Whether related documents can have multiple values of this hierarchy\n   * Set to false for folder-like behavior (single parent), true for tag-like behavior (multiple)\n   * @default true\n   */\n  allowHasMany?: boolean\n  /**\n   * Whether this hierarchy is scoped to specific collections\n   * When true or an object, hierarchy items can be restricted to certain collections\n   * @default false\n   */\n  collectionSpecific?:\n    | {\n        /**\n         * Name of the select field for specifying allowed collections\n         * @default 'hierarchyType'\n         */\n        fieldName?: string\n      }\n    | boolean\n  /**\n   * Configure a join field to query all children (nested hierarchy items and related documents)\n   * If not set, no join field is created.\n   * You can pass additional JoinField options (admin, defaultLimit, defaultSort, etc.)\n   * that will be merged with the auto-generated config.\n   */\n  joinField?: HierarchyJoinFieldConfig\n  /**\n   * Name of the field that references the parent document\n   * Will automatically create this field if it does not exist\n   * @default '_h_${collectionSlug}' (e.g., '_h_folders' for a collection with slug 'folders')\n   */\n  parentFieldName: string\n  /**\n   * Name of the field to use for slug path generation.\n   * When set, uses this field's value directly instead of slugifying the title.\n   * Useful when you have a dedicated slug field (e.g., 'slug') separate from the title.\n   * @example 'slug' - uses the 'slug' field value as-is for path segments\n   */\n  slugField?: string\n  /**\n   * Custom function to slugify text for path generation\n   * Used by computeSlugPath() utility for generating slug-based breadcrumb paths\n   * Only used when slugField is not set.\n   * Defaults to internal slugify implementation\n   */\n  slugify?: (text: string) => string\n  /**\n   * Name of the virtual field that will contain the slug-based breadcrumb path\n   * @default HIERARCHY_SLUG_PATH_FIELD ('_h_slugPath')\n   */\n  slugPathFieldName?: string\n  /**\n   * Name of the virtual field that will contain the title-based breadcrumb path\n   * @default HIERARCHY_TITLE_PATH_FIELD ('_h_titlePath')\n   */\n  titlePathFieldName?: string\n}\n\n/**\n * Sanitized hierarchy configuration with all defaults applied\n */\nexport type SanitizedHierarchyConfig = {\n  admin: {\n    components: {\n      Icon: PayloadComponent\n    }\n    injectSidebarTab: boolean\n    treeLimit: number\n    useHeaderButton: boolean\n  }\n  allowHasMany: boolean\n  collectionSpecific:\n    | {\n        fieldName: string\n      }\n    | false\n  /**\n   * Join field configuration, or undefined if not enabled\n   */\n  joinField?: HierarchyJoinFieldConfig\n  parentFieldName: string\n  /**\n   * Auto-populated during validation - maps collection slug to field info\n   */\n  relatedCollections: Record<string, SanitizedHierarchyRelatedCollection>\n  /**\n   * Field name for slug values, or undefined to use slugified title\n   */\n  slugField?: string\n  slugify: (text: string) => string\n  slugPathFieldName: string\n  titlePathFieldName: string\n}\n\n/**\n * Information about how a collection relates to this hierarchy\n */\nexport type SanitizedHierarchyRelatedCollection = {\n  fieldName: string\n  hasMany: boolean\n}\n\n/**\n * Client-safe hierarchy configuration (excludes functions that can't cross server-client boundary)\n */\nexport type ClientHierarchyConfig = Omit<SanitizedHierarchyConfig, 'slugify'>\n\n/**\n * Breadcrumb item for folder hierarchies\n * @deprecated Use hierarchy breadcrumbs instead\n */\nexport type FolderBreadcrumb = {\n  id: number | string\n  name: string\n}\n"],"names":[],"mappings":"AA4JA;;;CAGC,GACD,WAGC"}

package/dist/hierarchy/utils/buildLocalizedHierarchyPaths.d.ts

@@ -0,0 +1,77 @@
+import type { PayloadRequest } from '../../types/index.js';
+type BuildLocalizedPathsArgs = {
+    /**
+     * Optional parent's slug paths by locale (e.g., { en: "/blog/tech", es: "/blog/tecnologia" })
+     * If provided, these paths will be prepended to the generated slug segments
+     */
+    parentSlugPath?: Record<string, string>;
+    /**
+     * Optional parent's title paths by locale (e.g., { en: "Blog / Tech", es: "Blog / Tecnología" })
+     * If provided, these paths will be prepended to the generated title segments
+     */
+    parentTitlePath?: Record<string, string>;
+    /**
+     * The Payload request object - used to access locale configuration and fallback settings
+     */
+    req: PayloadRequest;
+    /**
+     * Function to convert title text into URL-safe slug segments.
+     * Only used when slugValue is not provided.
+     */
+    slugify: (val: string) => string;
+    /**
+     * Optional pre-computed slug value by locale.
+     * When provided, uses these values directly instead of slugifying the title.
+     */
+    slugValue?: Record<string, string>;
+    /**
+     * The localized title value object (e.g., { en: "Home", es: "Inicio", de: "Startseite" })
+     */
+    titleValue: Record<string, string>;
+};
+type BuildLocalizedPathsResult = {
+    slugPath: Record<string, string>;
+    titlePath: Record<string, string>;
+};
+/**
+ * Builds localized slug and title paths for all configured locales.
+ * Applies proper fallback locale handling and optionally prepends parent paths.
+ *
+ * This utility is used when `locale: 'all'` is requested and the title field is localized,
+ * generating a path for each locale with proper fallback handling.
+ *
+ * @example
+ * ```ts
+ * // Without parent (root document)
+ * buildLocalizedPaths({
+ *   req,
+ *   slugify: (val) => val.toLowerCase().replace(/\s/g, '-'),
+ *   titleValue: { en: "Home", es: "Inicio", de: "" }
+ * })
+ * // Returns:
+ * // {
+ * //   slugPath: { en: "home", es: "inicio", de: "home" }, // 'de' falls back to 'en'
+ * //   titlePath: { en: "Home", es: "Inicio", de: "Home" }
+ * // }
+ *
+ * // With parent paths
+ * buildLocalizedPaths({
+ *   parentSlugPath: { en: "/blog", es: "/blog" },
+ *   parentTitlePath: { en: "Blog", es: "Blog" },
+ *   req,
+ *   slugify: (val) => val.toLowerCase().replace(/\s/g, '-'),
+ *   titleValue: { en: "Tech News", es: "Noticias Tecnológicas" }
+ * })
+ * // Returns:
+ * // {
+ * //   slugPath: { en: "/blog/tech-news", es: "/blog/noticias-tecnologicas" },
+ * //   titlePath: { en: "Blog / Tech News", es: "Blog / Noticias Tecnológicas" }
+ * // }
+ * ```
+ *
+ * @param args - Configuration for building localized paths
+ * @returns Object containing slugPath and titlePath, each mapping locale codes to path strings
+ */
+export declare function buildLocalizedHierarchyPaths(args: BuildLocalizedPathsArgs): BuildLocalizedPathsResult;
+export {};
+//# sourceMappingURL=buildLocalizedHierarchyPaths.d.ts.map

package/dist/hierarchy/utils/buildLocalizedHierarchyPaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildLocalizedHierarchyPaths.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/utils/buildLocalizedHierarchyPaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAI1D,KAAK,uBAAuB,GAAG;IAC7B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxC;;OAEG;IACH,GAAG,EAAE,cAAc,CAAA;IACnB;;;OAGG;IACH,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IAChC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACnC,CAAA;AAED,KAAK,yBAAyB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,uBAAuB,GAC5B,yBAAyB,CA6C3B"}

package/dist/hierarchy/utils/buildLocalizedHierarchyPaths.js

@@ -0,0 +1,77 @@
+import { getLocalizedValue } from './getLocalizedValue.js';
+/**
+ * Builds localized slug and title paths for all configured locales.
+ * Applies proper fallback locale handling and optionally prepends parent paths.
+ *
+ * This utility is used when `locale: 'all'` is requested and the title field is localized,
+ * generating a path for each locale with proper fallback handling.
+ *
+ * @example
+ * ```ts
+ * // Without parent (root document)
+ * buildLocalizedPaths({
+ *   req,
+ *   slugify: (val) => val.toLowerCase().replace(/\s/g, '-'),
+ *   titleValue: { en: "Home", es: "Inicio", de: "" }
+ * })
+ * // Returns:
+ * // {
+ * //   slugPath: { en: "home", es: "inicio", de: "home" }, // 'de' falls back to 'en'
+ * //   titlePath: { en: "Home", es: "Inicio", de: "Home" }
+ * // }
+ *
+ * // With parent paths
+ * buildLocalizedPaths({
+ *   parentSlugPath: { en: "/blog", es: "/blog" },
+ *   parentTitlePath: { en: "Blog", es: "Blog" },
+ *   req,
+ *   slugify: (val) => val.toLowerCase().replace(/\s/g, '-'),
+ *   titleValue: { en: "Tech News", es: "Noticias Tecnológicas" }
+ * })
+ * // Returns:
+ * // {
+ * //   slugPath: { en: "/blog/tech-news", es: "/blog/noticias-tecnologicas" },
+ * //   titlePath: { en: "Blog / Tech News", es: "Blog / Noticias Tecnológicas" }
+ * // }
+ * ```
+ *
+ * @param args - Configuration for building localized paths
+ * @returns Object containing slugPath and titlePath, each mapping locale codes to path strings
+ */ export function buildLocalizedHierarchyPaths(args) {
+    const { parentSlugPath, parentTitlePath, req, slugify, slugValue, titleValue } = args;
+    const slugPathsByLocale = {};
+    const titlePathsByLocale = {};
+    const locales = req.payload.config.localization ? req.payload.config.localization.localeCodes : [];
+    for (const loc of locales){
+        const localizedTitle = getLocalizedValue({
+            fallbackLocale: req.fallbackLocale,
+            fieldType: 'text',
+            locale: loc,
+            value: titleValue
+        });
+        if (localizedTitle) {
+            // Use provided slugValue if available, otherwise slugify the title
+            let slugSegment;
+            if (slugValue) {
+                const localizedSlug = getLocalizedValue({
+                    fallbackLocale: req.fallbackLocale,
+                    fieldType: 'text',
+                    locale: loc,
+                    value: slugValue
+                });
+                slugSegment = localizedSlug || slugify(localizedTitle);
+            } else {
+                slugSegment = slugify(localizedTitle);
+            }
+            const titleSegment = localizedTitle;
+            slugPathsByLocale[loc] = parentSlugPath ? `${parentSlugPath[loc]}/${slugSegment}` : slugSegment;
+            titlePathsByLocale[loc] = parentTitlePath ? `${parentTitlePath[loc]}/${titleSegment}` : titleSegment;
+        }
+    }
+    return {
+        slugPath: slugPathsByLocale,
+        titlePath: titlePathsByLocale
+    };
+}
+
+//# sourceMappingURL=buildLocalizedHierarchyPaths.js.map

package/dist/hierarchy/utils/buildLocalizedHierarchyPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hierarchy/utils/buildLocalizedHierarchyPaths.ts"],"sourcesContent":["import type { PayloadRequest } from '../../types/index.js'\n\nimport { getLocalizedValue } from './getLocalizedValue.js'\n\ntype BuildLocalizedPathsArgs = {\n  /**\n   * Optional parent's slug paths by locale (e.g., { en: \"/blog/tech\", es: \"/blog/tecnologia\" })\n   * If provided, these paths will be prepended to the generated slug segments\n   */\n  parentSlugPath?: Record<string, string>\n  /**\n   * Optional parent's title paths by locale (e.g., { en: \"Blog / Tech\", es: \"Blog / Tecnología\" })\n   * If provided, these paths will be prepended to the generated title segments\n   */\n  parentTitlePath?: Record<string, string>\n  /**\n   * The Payload request object - used to access locale configuration and fallback settings\n   */\n  req: PayloadRequest\n  /**\n   * Function to convert title text into URL-safe slug segments.\n   * Only used when slugValue is not provided.\n   */\n  slugify: (val: string) => string\n  /**\n   * Optional pre-computed slug value by locale.\n   * When provided, uses these values directly instead of slugifying the title.\n   */\n  slugValue?: Record<string, string>\n  /**\n   * The localized title value object (e.g., { en: \"Home\", es: \"Inicio\", de: \"Startseite\" })\n   */\n  titleValue: Record<string, string>\n}\n\ntype BuildLocalizedPathsResult = {\n  slugPath: Record<string, string>\n  titlePath: Record<string, string>\n}\n\n/**\n * Builds localized slug and title paths for all configured locales.\n * Applies proper fallback locale handling and optionally prepends parent paths.\n *\n * This utility is used when `locale: 'all'` is requested and the title field is localized,\n * generating a path for each locale with proper fallback handling.\n *\n * @example\n * ```ts\n * // Without parent (root document)\n * buildLocalizedPaths({\n *   req,\n *   slugify: (val) => val.toLowerCase().replace(/\\s/g, '-'),\n *   titleValue: { en: \"Home\", es: \"Inicio\", de: \"\" }\n * })\n * // Returns:\n * // {\n * //   slugPath: { en: \"home\", es: \"inicio\", de: \"home\" }, // 'de' falls back to 'en'\n * //   titlePath: { en: \"Home\", es: \"Inicio\", de: \"Home\" }\n * // }\n *\n * // With parent paths\n * buildLocalizedPaths({\n *   parentSlugPath: { en: \"/blog\", es: \"/blog\" },\n *   parentTitlePath: { en: \"Blog\", es: \"Blog\" },\n *   req,\n *   slugify: (val) => val.toLowerCase().replace(/\\s/g, '-'),\n *   titleValue: { en: \"Tech News\", es: \"Noticias Tecnológicas\" }\n * })\n * // Returns:\n * // {\n * //   slugPath: { en: \"/blog/tech-news\", es: \"/blog/noticias-tecnologicas\" },\n * //   titlePath: { en: \"Blog / Tech News\", es: \"Blog / Noticias Tecnológicas\" }\n * // }\n * ```\n *\n * @param args - Configuration for building localized paths\n * @returns Object containing slugPath and titlePath, each mapping locale codes to path strings\n */\nexport function buildLocalizedHierarchyPaths(\n  args: BuildLocalizedPathsArgs,\n): BuildLocalizedPathsResult {\n  const { parentSlugPath, parentTitlePath, req, slugify, slugValue, titleValue } = args\n\n  const slugPathsByLocale: Record<string, string> = {}\n  const titlePathsByLocale: Record<string, string> = {}\n\n  const locales = req.payload.config.localization ? req.payload.config.localization.localeCodes : []\n\n  for (const loc of locales) {\n    const localizedTitle = getLocalizedValue({\n      fallbackLocale: req.fallbackLocale,\n      fieldType: 'text',\n      locale: loc,\n      value: titleValue,\n    })\n\n    if (localizedTitle) {\n      // Use provided slugValue if available, otherwise slugify the title\n      let slugSegment: string\n      if (slugValue) {\n        const localizedSlug = getLocalizedValue({\n          fallbackLocale: req.fallbackLocale,\n          fieldType: 'text',\n          locale: loc,\n          value: slugValue,\n        })\n        slugSegment = localizedSlug || slugify(localizedTitle)\n      } else {\n        slugSegment = slugify(localizedTitle)\n      }\n      const titleSegment = localizedTitle\n\n      slugPathsByLocale[loc] = parentSlugPath\n        ? `${parentSlugPath[loc]}/${slugSegment}`\n        : slugSegment\n      titlePathsByLocale[loc] = parentTitlePath\n        ? `${parentTitlePath[loc]}/${titleSegment}`\n        : titleSegment\n    }\n  }\n\n  return {\n    slugPath: slugPathsByLocale,\n    titlePath: titlePathsByLocale,\n  }\n}\n"],"names":["getLocalizedValue","buildLocalizedHierarchyPaths","args","parentSlugPath","parentTitlePath","req","slugify","slugValue","titleValue","slugPathsByLocale","titlePathsByLocale","locales","payload","config","localization","localeCodes","loc","localizedTitle","fallbackLocale","fieldType","locale","value","slugSegment","localizedSlug","titleSegment","slugPath","titlePath"],"mappings":"AAEA,SAASA,iBAAiB,QAAQ,yBAAwB;AAsC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCC,GACD,OAAO,SAASC,6BACdC,IAA6B;IAE7B,MAAM,EAAEC,cAAc,EAAEC,eAAe,EAAEC,GAAG,EAAEC,OAAO,EAAEC,SAAS,EAAEC,UAAU,EAAE,GAAGN;IAEjF,MAAMO,oBAA4C,CAAC;IACnD,MAAMC,qBAA6C,CAAC;IAEpD,MAAMC,UAAUN,IAAIO,OAAO,CAACC,MAAM,CAACC,YAAY,GAAGT,IAAIO,OAAO,CAACC,MAAM,CAACC,YAAY,CAACC,WAAW,GAAG,EAAE;IAElG,KAAK,MAAMC,OAAOL,QAAS;QACzB,MAAMM,iBAAiBjB,kBAAkB;YACvCkB,gBAAgBb,IAAIa,cAAc;YAClCC,WAAW;YACXC,QAAQJ;YACRK,OAAOb;QACT;QAEA,IAAIS,gBAAgB;YAClB,mEAAmE;YACnE,IAAIK;YACJ,IAAIf,WAAW;gBACb,MAAMgB,gBAAgBvB,kBAAkB;oBACtCkB,gBAAgBb,IAAIa,cAAc;oBAClCC,WAAW;oBACXC,QAAQJ;oBACRK,OAAOd;gBACT;gBACAe,cAAcC,iBAAiBjB,QAAQW;YACzC,OAAO;gBACLK,cAAchB,QAAQW;YACxB;YACA,MAAMO,eAAeP;YAErBR,iBAAiB,CAACO,IAAI,GAAGb,iBACrB,GAAGA,cAAc,CAACa,IAAI,CAAC,CAAC,EAAEM,aAAa,GACvCA;YACJZ,kBAAkB,CAACM,IAAI,GAAGZ,kBACtB,GAAGA,eAAe,CAACY,IAAI,CAAC,CAAC,EAAEQ,cAAc,GACzCA;QACN;IACF;IAEA,OAAO;QACLC,UAAUhB;QACViB,WAAWhB;IACb;AACF"}

package/dist/hierarchy/utils/computePaths.d.ts

@@ -0,0 +1,31 @@
+import type { SanitizedCollectionConfig } from '../../collections/config/types.js';
+import type { Document, PayloadRequest } from '../../types/index.js';
+type ComputePathsArgs = {
+    collection: SanitizedCollectionConfig;
+    doc: Document;
+    draft?: boolean;
+    locale?: string;
+    parentFieldName: string;
+    req: PayloadRequest;
+    slugPathFieldName?: string;
+    titlePathFieldName?: string;
+};
+type ComputePathsResult = {
+    slugPath: Record<string, string> | string;
+    titlePath: Record<string, string> | string;
+};
+/**
+ * Computes both slug and title breadcrumb paths for a document by walking up the parent chain.
+ * More efficient than computing them separately since it only walks the chain once.
+ *
+ * Note: Ancestor fetches always use `overrideAccess: true` to ensure paths are complete.
+ * If a user can read a document, they should see its full breadcrumb path even if they
+ * cannot read all ancestor documents. This prevents broken breadcrumbs and provides
+ * better UX at the cost of minimal information leakage (ancestor titles in paths).
+ *
+ * @param args - Configuration for path computation
+ * @returns Object with slugPath and titlePath
+ */
+export declare function computePaths(args: ComputePathsArgs): Promise<ComputePathsResult>;
+export {};
+//# sourceMappingURL=computePaths.d.ts.map

package/dist/hierarchy/utils/computePaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computePaths.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/utils/computePaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAClF,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAQpE,KAAK,gBAAgB,GAAG;IACtB,UAAU,EAAE,yBAAyB,CAAA;IACrC,GAAG,EAAE,QAAQ,CAAA;IACb,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,MAAM,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B,CAAA;AAED,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAA;IACzC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAA;CAC3C,CAAA;AAgFD;;;;;;;;;;;GAWG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA2dtF"}