payload 3.84.1 → 4.0.0-internal.38b7f1d

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"}