@depup/payload 3.79.1-depup.0

package/dist/utilities/getEntityPermissions/populateFieldPermissions.js

@@ -0,0 +1,236 @@
+import { tabHasName } from '../../fields/config/types.js';
+const isThenable = (value)=>value != null && typeof value.then === 'function';
+/**
+ * Helper to set a permission value that might be a promise.
+ * If it's a promise, creates a chained promise that resolves to update the target,
+ * stores the promise temporarily, and adds it to the promises array for later resolution.
+ */ const setPermission = (// eslint-disable-next-line @typescript-eslint/no-explicit-any
+target, operation, value, promises)=>{
+    if (isThenable(value)) {
+        // Create a single permission object that will be mutated in place
+        // This ensures all references (including cached blocks) see the resolved value
+        const permissionObj = {
+            permission: value
+        };
+        target[operation] = permissionObj;
+        const permissionPromise = value.then((result)=>{
+            // Mutate the permission property in place so all references see the update
+            permissionObj.permission = result;
+        });
+        promises.push(permissionPromise);
+    } else {
+        target[operation] = {
+            permission: value
+        };
+    }
+};
+/**
+ * Build up permissions object and run access functions for each field of an entity
+ * This function is synchronous and collects all async work into the promises array
+ */ export const populateFieldPermissions = ({ id, blockReferencesPermissions, data, fields, operations, parentPermissionsObject, permissionsObject, promises, req })=>{
+    for (const field of fields){
+        // Set up permissions for all operations
+        for (const operation of operations){
+            const parentPermissionForOperation = parentPermissionsObject[operation]?.permission;
+            // Fields don't have all operations of a collection
+            if (operation === 'delete' || operation === 'readVersions' || operation === 'unlock') {
+                continue;
+            }
+            if ('name' in field && field.name) {
+                if (!permissionsObject[field.name]) {
+                    permissionsObject[field.name] = {};
+                }
+                const fieldPermissions = permissionsObject[field.name];
+                if ('access' in field && field.access && typeof field.access[operation] === 'function') {
+                    const accessResult = field.access[operation]({
+                        id,
+                        data,
+                        doc: data,
+                        req
+                    });
+                    // Handle both sync and async access results
+                    if (isThenable(accessResult)) {
+                        const booleanPromise = accessResult.then((result)=>Boolean(result));
+                        setPermission(fieldPermissions, operation, booleanPromise, promises);
+                    } else {
+                        setPermission(fieldPermissions, operation, Boolean(accessResult), promises);
+                    }
+                } else {
+                    // Inherit from parent (which might be a promise)
+                    setPermission(fieldPermissions, operation, parentPermissionForOperation, promises);
+                }
+            }
+        }
+        // Handle named fields with nested content
+        if ('name' in field && field.name) {
+            const fieldPermissions = permissionsObject[field.name];
+            if ('fields' in field && field.fields) {
+                if (!fieldPermissions.fields) {
+                    fieldPermissions.fields = {};
+                }
+                populateFieldPermissions({
+                    id,
+                    blockReferencesPermissions,
+                    data,
+                    fields: field.fields,
+                    operations,
+                    parentPermissionsObject: fieldPermissions,
+                    permissionsObject: fieldPermissions.fields,
+                    promises,
+                    req
+                });
+            }
+            if ('blocks' in field && field.blocks?.length || 'blockReferences' in field && field.blockReferences?.length) {
+                if (!fieldPermissions.blocks) {
+                    fieldPermissions.blocks = {};
+                }
+                const blocksPermissions = fieldPermissions.blocks;
+                // Set up permissions for all operations for all blocks
+                for (const operation of operations){
+                    // Fields don't have all operations of a collection
+                    if (operation === 'delete' || operation === 'readVersions' || operation === 'unlock') {
+                        continue;
+                    }
+                    const parentPermissionForOperation = parentPermissionsObject[operation]?.permission;
+                    for (const _block of field.blockReferences ?? field.blocks){
+                        const block = typeof _block === 'string' ? req.payload.blocks[_block] : _block;
+                        // Skip if block doesn't exist (invalid block reference)
+                        if (!block) {
+                            continue;
+                        }
+                        // Handle block references - check if we've seen this block before
+                        if (typeof _block === 'string') {
+                            const blockReferencePermissions = blockReferencesPermissions[_block];
+                            if (blockReferencePermissions) {
+                                // Reference the cached permissions (may be a promise or resolved object)
+                                blocksPermissions[block.slug] = blockReferencePermissions;
+                                continue;
+                            }
+                        }
+                        // Initialize block permissions object if needed
+                        if (!blocksPermissions[block.slug]) {
+                            blocksPermissions[block.slug] = {};
+                        }
+                        const blockPermission = blocksPermissions[block.slug];
+                        // Set permission for this operation
+                        if (!blockPermission[operation]) {
+                            const fieldPermission = fieldPermissions[operation]?.permission ?? parentPermissionForOperation;
+                            // Inherit from field permission (which might be a promise)
+                            setPermission(blockPermission, operation, fieldPermission, promises);
+                        }
+                    }
+                }
+                // Process nested content for each unique block (once per block, not once per operation)
+                const processedBlocks = new Set();
+                for (const _block of field.blockReferences ?? field.blocks){
+                    const block = typeof _block === 'string' ? req.payload.blocks[_block] : _block;
+                    // Skip if block doesn't exist (invalid block reference)
+                    if (!block || processedBlocks.has(block.slug)) {
+                        continue;
+                    }
+                    processedBlocks.add(block.slug);
+                    const blockPermission = blocksPermissions[block.slug];
+                    if (!blockPermission) {
+                        continue;
+                    }
+                    if (!blockPermission.fields) {
+                        blockPermission.fields = {};
+                    }
+                    // Handle block references with caching - store as promise that will be resolved later
+                    if (typeof _block === 'string' && !blockReferencesPermissions[_block]) {
+                        // Mark this block as being processed by storing a reference
+                        blockReferencesPermissions[_block] = blockPermission;
+                    }
+                    // Recursively process block fields synchronously
+                    populateFieldPermissions({
+                        id,
+                        blockReferencesPermissions,
+                        data,
+                        fields: block.fields,
+                        operations,
+                        parentPermissionsObject: blockPermission,
+                        permissionsObject: blockPermission.fields,
+                        promises,
+                        req
+                    });
+                }
+            }
+        }
+        // Handle unnamed group fields
+        if ('fields' in field && field.fields && !('name' in field && field.name)) {
+            // Field does not have a name => same parentPermissionsObject
+            populateFieldPermissions({
+                id,
+                blockReferencesPermissions,
+                data,
+                fields: field.fields,
+                operations,
+                // Field does not have a name here => use parent permissions object
+                parentPermissionsObject,
+                permissionsObject,
+                promises,
+                req
+            });
+        }
+        // Handle tabs fields
+        if (field.type === 'tabs') {
+            // Process tabs for all operations
+            for (const operation of operations){
+                // Fields don't have all operations of a collection
+                if (operation === 'delete' || operation === 'readVersions' || operation === 'unlock') {
+                    continue;
+                }
+                const parentPermissionForOperation = parentPermissionsObject[operation]?.permission;
+                for (const tab of field.tabs){
+                    if (tabHasName(tab)) {
+                        if (!permissionsObject[tab.name]) {
+                            permissionsObject[tab.name] = {
+                                fields: {}
+                            };
+                        }
+                        const tabPermissions = permissionsObject[tab.name];
+                        if (!tabPermissions[operation]) {
+                            // Inherit from parent (which might be a promise)
+                            setPermission(tabPermissions, operation, parentPermissionForOperation, promises);
+                        }
+                    }
+                }
+            }
+            for (const tab of field.tabs){
+                if (tabHasName(tab)) {
+                    const tabPermissions = permissionsObject[tab.name];
+                    if (!tabPermissions.fields) {
+                        tabPermissions.fields = {};
+                    }
+                    populateFieldPermissions({
+                        id,
+                        blockReferencesPermissions,
+                        data,
+                        fields: tab.fields,
+                        operations,
+                        parentPermissionsObject: tabPermissions,
+                        permissionsObject: tabPermissions.fields,
+                        promises,
+                        req
+                    });
+                } else {
+                    // Tab does not have a name => same parentPermissionsObject
+                    populateFieldPermissions({
+                        id,
+                        blockReferencesPermissions,
+                        data,
+                        fields: tab.fields,
+                        operations,
+                        // Tab does not have a name here => use parent permissions object
+                        parentPermissionsObject,
+                        permissionsObject,
+                        promises,
+                        req
+                    });
+                }
+            }
+        }
+    }
+};
+
+//# sourceMappingURL=populateFieldPermissions.js.map

package/dist/utilities/getEntityPermissions/populateFieldPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/getEntityPermissions/populateFieldPermissions.ts"],"sourcesContent":["import type {\n  BlockPermissions,\n  BlocksPermissions,\n  CollectionPermission,\n  FieldPermissions,\n  FieldsPermissions,\n  GlobalPermission,\n  Permission,\n} from '../../auth/types.js'\nimport type { DefaultDocumentIDType } from '../../index.js'\nimport type { AllOperations, JsonObject, PayloadRequest } from '../../types/index.js'\nimport type { BlockReferencesPermissions } from './getEntityPermissions.js'\n\nimport { type Field, tabHasName } from '../../fields/config/types.js'\n\nconst isThenable = (value: unknown): value is Promise<unknown> =>\n  value != null && typeof (value as { then?: unknown }).then === 'function'\n\n/**\n * Helper to set a permission value that might be a promise.\n * If it's a promise, creates a chained promise that resolves to update the target,\n * stores the promise temporarily, and adds it to the promises array for later resolution.\n */\nconst setPermission = (\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  target: any,\n  operation: AllOperations,\n  value: boolean | Promise<boolean> | undefined,\n  promises: Promise<void>[],\n): void => {\n  if (isThenable(value)) {\n    // Create a single permission object that will be mutated in place\n    // This ensures all references (including cached blocks) see the resolved value\n    const permissionObj = { permission: value as any }\n    target[operation] = permissionObj\n\n    const permissionPromise = value.then((result) => {\n      // Mutate the permission property in place so all references see the update\n      permissionObj.permission = result\n    })\n\n    promises.push(permissionPromise)\n  } else {\n    target[operation] = { permission: value }\n  }\n}\n\n/**\n * Build up permissions object and run access functions for each field of an entity\n * This function is synchronous and collects all async work into the promises array\n */\nexport const populateFieldPermissions = ({\n  id,\n  blockReferencesPermissions,\n  data,\n  fields,\n  operations,\n  parentPermissionsObject,\n  permissionsObject,\n  promises,\n  req,\n}: {\n  blockReferencesPermissions: BlockReferencesPermissions\n  data: JsonObject | undefined\n  fields: Field[]\n  id?: DefaultDocumentIDType\n  /**\n   * Operations to check access for\n   */\n  operations: AllOperations[]\n  parentPermissionsObject: CollectionPermission | FieldPermissions | GlobalPermission\n  permissionsObject: FieldsPermissions\n  promises: Promise<void>[]\n  req: PayloadRequest\n}): void => {\n  for (const field of fields) {\n    // Set up permissions for all operations\n    for (const operation of operations) {\n      const parentPermissionForOperation = (\n        parentPermissionsObject[operation as keyof typeof parentPermissionsObject] as Permission\n      )?.permission\n\n      // Fields don't have all operations of a collection\n      if (operation === 'delete' || operation === 'readVersions' || operation === 'unlock') {\n        continue\n      }\n\n      if ('name' in field && field.name) {\n        if (!permissionsObject[field.name]) {\n          permissionsObject[field.name] = {} as FieldPermissions\n        }\n        const fieldPermissions: FieldPermissions = permissionsObject[field.name]!\n\n        if ('access' in field && field.access && typeof field.access[operation] === 'function') {\n          const accessResult = field.access[operation]({\n            id,\n            data,\n            doc: data,\n            req,\n            // We cannot include siblingData or blockData here, as we do not have siblingData/blockData available once we reach block or array\n            // rows, as we're calculating schema permissions, which do not include individual rows.\n            // For consistency, it's thus better to never include the siblingData and blockData\n          })\n\n          // Handle both sync and async access results\n          if (isThenable(accessResult)) {\n            const booleanPromise = accessResult.then((result) => Boolean(result))\n            setPermission(fieldPermissions, operation, booleanPromise, promises)\n          } else {\n            setPermission(fieldPermissions, operation, Boolean(accessResult), promises)\n          }\n        } else {\n          // Inherit from parent (which might be a promise)\n          setPermission(fieldPermissions, operation, parentPermissionForOperation, promises)\n        }\n      }\n    }\n\n    // Handle named fields with nested content\n    if ('name' in field && field.name) {\n      const fieldPermissions: FieldPermissions = permissionsObject[field.name]!\n\n      if ('fields' in field && field.fields) {\n        if (!fieldPermissions.fields) {\n          fieldPermissions.fields = {}\n        }\n\n        populateFieldPermissions({\n          id,\n          blockReferencesPermissions,\n          data,\n          fields: field.fields,\n          operations,\n          parentPermissionsObject: fieldPermissions,\n          permissionsObject: fieldPermissions.fields,\n          promises,\n          req,\n        })\n      }\n\n      if (\n        ('blocks' in field && field.blocks?.length) ||\n        ('blockReferences' in field && field.blockReferences?.length)\n      ) {\n        if (!fieldPermissions.blocks) {\n          fieldPermissions.blocks = {}\n        }\n        const blocksPermissions: BlocksPermissions = fieldPermissions.blocks\n\n        // Set up permissions for all operations for all blocks\n        for (const operation of operations) {\n          // Fields don't have all operations of a collection\n          if (operation === 'delete' || operation === 'readVersions' || operation === 'unlock') {\n            continue\n          }\n\n          const parentPermissionForOperation = (\n            parentPermissionsObject[operation as keyof typeof parentPermissionsObject] as Permission\n          )?.permission\n\n          for (const _block of field.blockReferences ?? field.blocks) {\n            const block = typeof _block === 'string' ? req.payload.blocks[_block] : _block\n\n            // Skip if block doesn't exist (invalid block reference)\n            if (!block) {\n              continue\n            }\n\n            // Handle block references - check if we've seen this block before\n            if (typeof _block === 'string') {\n              const blockReferencePermissions = blockReferencesPermissions[_block]\n              if (blockReferencePermissions) {\n                // Reference the cached permissions (may be a promise or resolved object)\n                blocksPermissions[block.slug] = blockReferencePermissions as BlockPermissions\n                continue\n              }\n            }\n\n            // Initialize block permissions object if needed\n            if (!blocksPermissions[block.slug]) {\n              blocksPermissions[block.slug] = {} as BlockPermissions\n            }\n\n            const blockPermission = blocksPermissions[block.slug]!\n\n            // Set permission for this operation\n            if (!blockPermission[operation]) {\n              const fieldPermission =\n                fieldPermissions[operation]?.permission ?? parentPermissionForOperation\n\n              // Inherit from field permission (which might be a promise)\n              setPermission(blockPermission, operation, fieldPermission, promises)\n            }\n          }\n        }\n\n        // Process nested content for each unique block (once per block, not once per operation)\n        const processedBlocks = new Set<string>()\n        for (const _block of field.blockReferences ?? field.blocks) {\n          const block = typeof _block === 'string' ? req.payload.blocks[_block] : _block\n\n          // Skip if block doesn't exist (invalid block reference)\n          if (!block || processedBlocks.has(block.slug)) {\n            continue\n          }\n          processedBlocks.add(block.slug)\n\n          const blockPermission = blocksPermissions[block.slug]\n          if (!blockPermission) {\n            continue\n          }\n\n          if (!blockPermission.fields) {\n            blockPermission.fields = {}\n          }\n\n          // Handle block references with caching - store as promise that will be resolved later\n          if (typeof _block === 'string' && !blockReferencesPermissions[_block]) {\n            // Mark this block as being processed by storing a reference\n            blockReferencesPermissions[_block] = blockPermission\n          }\n\n          // Recursively process block fields synchronously\n          populateFieldPermissions({\n            id,\n            blockReferencesPermissions,\n            data,\n            fields: block.fields,\n            operations,\n            parentPermissionsObject: blockPermission,\n            permissionsObject: blockPermission.fields,\n            promises,\n            req,\n          })\n        }\n      }\n    }\n\n    // Handle unnamed group fields\n    if ('fields' in field && field.fields && !('name' in field && field.name)) {\n      // Field does not have a name => same parentPermissionsObject\n      populateFieldPermissions({\n        id,\n        blockReferencesPermissions,\n        data,\n        fields: field.fields,\n        operations,\n        // Field does not have a name here => use parent permissions object\n        parentPermissionsObject,\n        permissionsObject,\n        promises,\n        req,\n      })\n    }\n\n    // Handle tabs fields\n    if (field.type === 'tabs') {\n      // Process tabs for all operations\n      for (const operation of operations) {\n        // Fields don't have all operations of a collection\n        if (operation === 'delete' || operation === 'readVersions' || operation === 'unlock') {\n          continue\n        }\n\n        const parentPermissionForOperation = (\n          parentPermissionsObject[operation as keyof typeof parentPermissionsObject] as Permission\n        )?.permission\n\n        for (const tab of field.tabs) {\n          if (tabHasName(tab)) {\n            if (!permissionsObject[tab.name]) {\n              permissionsObject[tab.name] = { fields: {} } as FieldPermissions\n            }\n\n            const tabPermissions = permissionsObject[tab.name]!\n            if (!tabPermissions[operation]) {\n              // Inherit from parent (which might be a promise)\n              setPermission(tabPermissions, operation, parentPermissionForOperation, promises)\n            }\n          }\n        }\n      }\n\n      for (const tab of field.tabs) {\n        if (tabHasName(tab)) {\n          const tabPermissions: FieldPermissions = permissionsObject[tab.name]!\n\n          if (!tabPermissions.fields) {\n            tabPermissions.fields = {}\n          }\n\n          populateFieldPermissions({\n            id,\n            blockReferencesPermissions,\n            data,\n            fields: tab.fields,\n            operations,\n            parentPermissionsObject: tabPermissions,\n            permissionsObject: tabPermissions.fields,\n            promises,\n            req,\n          })\n        } else {\n          // Tab does not have a name => same parentPermissionsObject\n          populateFieldPermissions({\n            id,\n            blockReferencesPermissions,\n            data,\n            fields: tab.fields,\n            operations,\n            // Tab does not have a name here => use parent permissions object\n            parentPermissionsObject,\n            permissionsObject,\n            promises,\n            req,\n          })\n        }\n      }\n    }\n  }\n}\n"],"names":["tabHasName","isThenable","value","then","setPermission","target","operation","promises","permissionObj","permission","permissionPromise","result","push","populateFieldPermissions","id","blockReferencesPermissions","data","fields","operations","parentPermissionsObject","permissionsObject","req","field","parentPermissionForOperation","name","fieldPermissions","access","accessResult","doc","booleanPromise","Boolean","blocks","length","blockReferences","blocksPermissions","_block","block","payload","blockReferencePermissions","slug","blockPermission","fieldPermission","processedBlocks","Set","has","add","type","tab","tabs","tabPermissions"],"mappings":"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"}

package/dist/utilities/getFieldByPath.d.ts

@@ -0,0 +1,22 @@
+import type { SanitizedConfig } from '../config/types.js';
+import type { FlattenedField } from '../fields/config/types.js';
+/**
+ * Get the field by its schema path, e.g. group.title, array.group.title
+ * If there were any localized on the path, `pathHasLocalized` will be true and `localizedPath` will look like:
+ * `group.<locale>.title` // group is localized here
+ */
+export declare const getFieldByPath: ({ config, fields, includeRelationships, localizedPath, path, }: {
+    config?: SanitizedConfig;
+    fields: FlattenedField[];
+    includeRelationships?: boolean;
+    localizedPath?: string;
+    /**
+     * The schema path, e.g. `array.group.title`
+     */
+    path: string;
+}) => {
+    field: FlattenedField;
+    localizedPath: string;
+    pathHasLocalized: boolean;
+} | null;
+//# sourceMappingURL=getFieldByPath.d.ts.map

package/dist/utilities/getFieldByPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFieldByPath.d.ts","sourceRoot":"","sources":["../../src/utilities/getFieldByPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAE/D;;;;GAIG;AACH,eAAO,MAAM,cAAc,mEAMxB;IACD,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;CACb,KAAG;IACF,KAAK,EAAE,cAAc,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,gBAAgB,EAAE,OAAO,CAAA;CAC1B,GAAG,IA4EH,CAAA"}

package/dist/utilities/getFieldByPath.js

@@ -0,0 +1,67 @@
+/**
+ * Get the field by its schema path, e.g. group.title, array.group.title
+ * If there were any localized on the path, `pathHasLocalized` will be true and `localizedPath` will look like:
+ * `group.<locale>.title` // group is localized here
+ */ export const getFieldByPath = ({ config, fields, includeRelationships = false, localizedPath = '', path })=>{
+    let currentFields = fields;
+    let currentField = null;
+    const segments = path.split('.');
+    let pathHasLocalized = false;
+    while(segments.length > 0){
+        const segment = segments.shift();
+        localizedPath = `${localizedPath ? `${localizedPath}.` : ''}${segment}`;
+        const field = currentFields.find((each)=>each.name === segment);
+        if (!field) {
+            return null;
+        }
+        if (field.localized) {
+            pathHasLocalized = true;
+            localizedPath = `${localizedPath}.<locale>`;
+        }
+        if ('flattenedFields' in field) {
+            currentFields = field.flattenedFields;
+        }
+        if (config && includeRelationships && (field.type === 'relationship' || field.type === 'upload') && !Array.isArray(field.relationTo)) {
+            const flattenedFields = config.collections.find((e)=>e.slug === field.relationTo)?.flattenedFields;
+            if (flattenedFields) {
+                currentFields = flattenedFields;
+            }
+            if (segments.length === 1 && segments[0] === 'id') {
+                return {
+                    field,
+                    localizedPath,
+                    pathHasLocalized
+                };
+            }
+        }
+        if ('blocks' in field && segments.length > 0) {
+            const blockSlug = segments[0];
+            const block = field.blocks.find((b)=>b.slug === blockSlug);
+            if (block) {
+                segments.shift();
+                localizedPath = `${localizedPath}.${blockSlug}`;
+                if (segments.length === 0) {
+                    return null;
+                }
+                return getFieldByPath({
+                    config,
+                    fields: block.flattenedFields,
+                    includeRelationships,
+                    localizedPath,
+                    path: segments.join('.')
+                });
+            }
+        }
+        currentField = field;
+    }
+    if (!currentField) {
+        return null;
+    }
+    return {
+        field: currentField,
+        localizedPath,
+        pathHasLocalized
+    };
+};
+
+//# sourceMappingURL=getFieldByPath.js.map

package/dist/utilities/getFieldByPath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/getFieldByPath.ts"],"sourcesContent":["import type { SanitizedConfig } from '../config/types.js'\nimport type { FlattenedField } from '../fields/config/types.js'\n\n/**\n * Get the field by its schema path, e.g. group.title, array.group.title\n * If there were any localized on the path, `pathHasLocalized` will be true and `localizedPath` will look like:\n * `group.<locale>.title` // group is localized here\n */\nexport const getFieldByPath = ({\n  config,\n  fields,\n  includeRelationships = false,\n  localizedPath = '',\n  path,\n}: {\n  config?: SanitizedConfig\n  fields: FlattenedField[]\n  includeRelationships?: boolean\n  localizedPath?: string\n  /**\n   * The schema path, e.g. `array.group.title`\n   */\n  path: string\n}): {\n  field: FlattenedField\n  localizedPath: string\n  pathHasLocalized: boolean\n} | null => {\n  let currentFields: FlattenedField[] = fields\n\n  let currentField: FlattenedField | null = null\n\n  const segments = path.split('.')\n\n  let pathHasLocalized = false\n\n  while (segments.length > 0) {\n    const segment = segments.shift()\n\n    localizedPath = `${localizedPath ? `${localizedPath}.` : ''}${segment}`\n    const field = currentFields.find((each) => each.name === segment)\n\n    if (!field) {\n      return null\n    }\n\n    if (field.localized) {\n      pathHasLocalized = true\n      localizedPath = `${localizedPath}.<locale>`\n    }\n\n    if ('flattenedFields' in field) {\n      currentFields = field.flattenedFields\n    }\n\n    if (\n      config &&\n      includeRelationships &&\n      (field.type === 'relationship' || field.type === 'upload') &&\n      !Array.isArray(field.relationTo)\n    ) {\n      const flattenedFields = config.collections.find(\n        (e) => e.slug === field.relationTo,\n      )?.flattenedFields\n      if (flattenedFields) {\n        currentFields = flattenedFields\n      }\n\n      if (segments.length === 1 && segments[0] === 'id') {\n        return { field, localizedPath, pathHasLocalized }\n      }\n    }\n\n    if ('blocks' in field && segments.length > 0) {\n      const blockSlug = segments[0]\n      const block = field.blocks.find((b) => b.slug === blockSlug)\n\n      if (block) {\n        segments.shift()\n        localizedPath = `${localizedPath}.${blockSlug}`\n\n        if (segments.length === 0) {\n          return null\n        }\n\n        return getFieldByPath({\n          config,\n          fields: block.flattenedFields,\n          includeRelationships,\n          localizedPath,\n          path: segments.join('.'),\n        })\n      }\n    }\n\n    currentField = field\n  }\n\n  if (!currentField) {\n    return null\n  }\n\n  return { field: currentField, localizedPath, pathHasLocalized }\n}\n"],"names":["getFieldByPath","config","fields","includeRelationships","localizedPath","path","currentFields","currentField","segments","split","pathHasLocalized","length","segment","shift","field","find","each","name","localized","flattenedFields","type","Array","isArray","relationTo","collections","e","slug","blockSlug","block","blocks","b","join"],"mappings":"AAGA;;;;CAIC,GACD,OAAO,MAAMA,iBAAiB,CAAC,EAC7BC,MAAM,EACNC,MAAM,EACNC,uBAAuB,KAAK,EAC5BC,gBAAgB,EAAE,EAClBC,IAAI,EAUL;IAKC,IAAIC,gBAAkCJ;IAEtC,IAAIK,eAAsC;IAE1C,MAAMC,WAAWH,KAAKI,KAAK,CAAC;IAE5B,IAAIC,mBAAmB;IAEvB,MAAOF,SAASG,MAAM,GAAG,EAAG;QAC1B,MAAMC,UAAUJ,SAASK,KAAK;QAE9BT,gBAAgB,GAAGA,gBAAgB,GAAGA,cAAc,CAAC,CAAC,GAAG,KAAKQ,SAAS;QACvE,MAAME,QAAQR,cAAcS,IAAI,CAAC,CAACC,OAASA,KAAKC,IAAI,KAAKL;QAEzD,IAAI,CAACE,OAAO;YACV,OAAO;QACT;QAEA,IAAIA,MAAMI,SAAS,EAAE;YACnBR,mBAAmB;YACnBN,gBAAgB,GAAGA,cAAc,SAAS,CAAC;QAC7C;QAEA,IAAI,qBAAqBU,OAAO;YAC9BR,gBAAgBQ,MAAMK,eAAe;QACvC;QAEA,IACElB,UACAE,wBACCW,CAAAA,MAAMM,IAAI,KAAK,kBAAkBN,MAAMM,IAAI,KAAK,QAAO,KACxD,CAACC,MAAMC,OAAO,CAACR,MAAMS,UAAU,GAC/B;YACA,MAAMJ,kBAAkBlB,OAAOuB,WAAW,CAACT,IAAI,CAC7C,CAACU,IAAMA,EAAEC,IAAI,KAAKZ,MAAMS,UAAU,GACjCJ;YACH,IAAIA,iBAAiB;gBACnBb,gBAAgBa;YAClB;YAEA,IAAIX,SAASG,MAAM,KAAK,KAAKH,QAAQ,CAAC,EAAE,KAAK,MAAM;gBACjD,OAAO;oBAAEM;oBAAOV;oBAAeM;gBAAiB;YAClD;QACF;QAEA,IAAI,YAAYI,SAASN,SAASG,MAAM,GAAG,GAAG;YAC5C,MAAMgB,YAAYnB,QAAQ,CAAC,EAAE;YAC7B,MAAMoB,QAAQd,MAAMe,MAAM,CAACd,IAAI,CAAC,CAACe,IAAMA,EAAEJ,IAAI,KAAKC;YAElD,IAAIC,OAAO;gBACTpB,SAASK,KAAK;gBACdT,gBAAgB,GAAGA,cAAc,CAAC,EAAEuB,WAAW;gBAE/C,IAAInB,SAASG,MAAM,KAAK,GAAG;oBACzB,OAAO;gBACT;gBAEA,OAAOX,eAAe;oBACpBC;oBACAC,QAAQ0B,MAAMT,eAAe;oBAC7BhB;oBACAC;oBACAC,MAAMG,SAASuB,IAAI,CAAC;gBACtB;YACF;QACF;QAEAxB,eAAeO;IACjB;IAEA,IAAI,CAACP,cAAc;QACjB,OAAO;IACT;IAEA,OAAO;QAAEO,OAAOP;QAAcH;QAAeM;IAAiB;AAChE,EAAC"}

package/dist/utilities/getFieldByPath.spec.js

@@ -0,0 +1,157 @@
+import { assert } from 'ts-essentials';
+import { describe, it, expect } from 'vitest';
+import { flattenAllFields } from './flattenAllFields.js';
+import { getFieldByPath } from './getFieldByPath.js';
+const fields = flattenAllFields({
+    fields: [
+        {
+            type: 'text',
+            name: 'text'
+        },
+        {
+            type: 'text',
+            name: 'textLocalized',
+            localized: true
+        },
+        {
+            type: 'array',
+            name: 'array',
+            fields: [
+                {
+                    name: 'text',
+                    type: 'text'
+                },
+                {
+                    name: 'textLocalized',
+                    localized: true,
+                    type: 'text'
+                },
+                {
+                    name: 'group',
+                    type: 'group',
+                    fields: [
+                        {
+                            name: 'text',
+                            type: 'text'
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            type: 'tabs',
+            tabs: [
+                {
+                    name: 'tab',
+                    fields: [
+                        {
+                            type: 'array',
+                            name: 'localizedArray',
+                            localized: true,
+                            fields: [
+                                {
+                                    name: 'text',
+                                    type: 'text'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            type: 'blocks',
+            name: 'blocks',
+            blocks: [
+                {
+                    slug: 'block1',
+                    fields: [
+                        {
+                            name: 'text1',
+                            type: 'text'
+                        }
+                    ]
+                },
+                {
+                    slug: 'block2',
+                    fields: [
+                        {
+                            name: 'text2',
+                            type: 'text'
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+});
+describe('getFieldByPath', ()=>{
+    it('asserts getFieldByPath', ()=>{
+        const assert_1 = getFieldByPath({
+            fields,
+            path: 'text'
+        });
+        assert(assert_1);
+        expect(assert_1.field).toBe(fields[0]);
+        expect(assert_1.pathHasLocalized).toBe(false);
+        const assert_2 = getFieldByPath({
+            fields,
+            path: 'textLocalized'
+        });
+        assert(assert_2);
+        expect(assert_2.field).toBe(fields[1]);
+        expect(assert_2.pathHasLocalized).toBe(true);
+        expect(assert_2.localizedPath).toBe('textLocalized.<locale>');
+        const arrayField = fields[2];
+        const assert_3 = getFieldByPath({
+            fields,
+            path: 'array'
+        });
+        assert(assert_3);
+        expect(assert_3.field).toBe(arrayField);
+        expect(assert_3.pathHasLocalized).toBe(false);
+        const assert_4 = getFieldByPath({
+            fields,
+            path: 'array.text'
+        });
+        assert(assert_4);
+        expect(assert_4.field).toBe(arrayField.flattenedFields[0]);
+        expect(assert_4.pathHasLocalized).toBe(false);
+        const assert_5 = getFieldByPath({
+            fields,
+            path: 'array.textLocalized'
+        });
+        assert(assert_5);
+        expect(assert_5.field).toBe(arrayField.flattenedFields[1]);
+        expect(assert_5.pathHasLocalized).toBe(true);
+        expect(assert_5.localizedPath).toBe('array.textLocalized.<locale>');
+        const groupWithinArray = arrayField.flattenedFields[2];
+        const assert_6 = getFieldByPath({
+            fields,
+            path: 'array.group.text'
+        });
+        assert(assert_6);
+        expect(assert_6.field).toBe(groupWithinArray.flattenedFields[0]);
+        expect(assert_6.pathHasLocalized).toBe(false);
+        const assert_7 = getFieldByPath({
+            fields,
+            path: 'tab.localizedArray.text'
+        });
+        assert(assert_7);
+        expect(assert_7.field).toBe(fields[3].flattenedFields[0].flattenedFields[0]);
+        expect(assert_7.pathHasLocalized).toBe(true);
+        expect(assert_7.localizedPath).toBe('tab.localizedArray.<locale>.text');
+    });
+    it('gets field nested within block', ()=>{
+        const fieldInBlock = getFieldByPath({
+            fields,
+            path: 'blocks.block2.text2'
+        });
+        expect(fieldInBlock?.field).toBeDefined();
+        const sourceField = fields[4].blocks?.[1].flattenedFields?.[0];
+        expect(sourceField).toBeDefined();
+        expect(fieldInBlock?.field).toBe(sourceField);
+    });
+});
+
+//# sourceMappingURL=getFieldByPath.spec.js.map

package/dist/utilities/getFieldByPath.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/getFieldByPath.spec.ts"],"sourcesContent":["import { assert } from 'ts-essentials'\nimport { describe, it, expect } from 'vitest'\nimport { flattenAllFields } from './flattenAllFields.js'\nimport { getFieldByPath } from './getFieldByPath.js'\nimport type { FlattenedArrayField, FlattenedGroupField } from '../fields/config/types.js'\n\nconst fields = flattenAllFields({\n  fields: [\n    {\n      type: 'text',\n      name: 'text',\n    },\n    {\n      type: 'text',\n      name: 'textLocalized',\n      localized: true,\n    },\n    {\n      type: 'array',\n      name: 'array',\n      fields: [\n        {\n          name: 'text',\n          type: 'text',\n        },\n        {\n          name: 'textLocalized',\n          localized: true,\n          type: 'text',\n        },\n        {\n          name: 'group',\n          type: 'group',\n          fields: [\n            {\n              name: 'text',\n              type: 'text',\n            },\n          ],\n        },\n      ],\n    },\n    {\n      type: 'tabs',\n      tabs: [\n        {\n          name: 'tab',\n          fields: [\n            {\n              type: 'array',\n              name: 'localizedArray',\n              localized: true,\n              fields: [\n                {\n                  name: 'text',\n                  type: 'text',\n                },\n              ],\n            },\n          ],\n        },\n      ],\n    },\n    {\n      type: 'blocks',\n      name: 'blocks',\n      blocks: [\n        {\n          slug: 'block1',\n          fields: [\n            {\n              name: 'text1',\n              type: 'text',\n            },\n          ],\n        },\n        {\n          slug: 'block2',\n          fields: [\n            {\n              name: 'text2',\n              type: 'text',\n            },\n          ],\n        },\n      ],\n    },\n  ],\n})\n\ndescribe('getFieldByPath', () => {\n  it('asserts getFieldByPath', () => {\n    const assert_1 = getFieldByPath({ fields, path: 'text' })\n    assert(assert_1)\n    expect(assert_1.field).toBe(fields[0])\n    expect(assert_1.pathHasLocalized).toBe(false)\n\n    const assert_2 = getFieldByPath({ fields, path: 'textLocalized' })\n    assert(assert_2)\n    expect(assert_2.field).toBe(fields[1])\n    expect(assert_2.pathHasLocalized).toBe(true)\n    expect(assert_2.localizedPath).toBe('textLocalized.<locale>')\n\n    const arrayField = fields[2] as FlattenedArrayField\n    const assert_3 = getFieldByPath({ fields, path: 'array' })\n    assert(assert_3)\n    expect(assert_3.field).toBe(arrayField)\n    expect(assert_3.pathHasLocalized).toBe(false)\n\n    const assert_4 = getFieldByPath({ fields, path: 'array.text' })\n    assert(assert_4)\n    expect(assert_4.field).toBe(arrayField.flattenedFields[0])\n    expect(assert_4.pathHasLocalized).toBe(false)\n\n    const assert_5 = getFieldByPath({ fields, path: 'array.textLocalized' })\n    assert(assert_5)\n    expect(assert_5.field).toBe(arrayField.flattenedFields[1])\n    expect(assert_5.pathHasLocalized).toBe(true)\n    expect(assert_5.localizedPath).toBe('array.textLocalized.<locale>')\n\n    const groupWithinArray = arrayField.flattenedFields[2] as FlattenedGroupField\n    const assert_6 = getFieldByPath({ fields, path: 'array.group.text' })\n    assert(assert_6)\n    expect(assert_6.field).toBe(groupWithinArray.flattenedFields[0])\n    expect(assert_6.pathHasLocalized).toBe(false)\n\n    const assert_7 = getFieldByPath({ fields, path: 'tab.localizedArray.text' })\n    assert(assert_7)\n    expect(assert_7.field).toBe((fields[3] as any).flattenedFields[0].flattenedFields[0])\n    expect(assert_7.pathHasLocalized).toBe(true)\n    expect(assert_7.localizedPath).toBe('tab.localizedArray.<locale>.text')\n  })\n\n  it('gets field nested within block', () => {\n    const fieldInBlock = getFieldByPath({ fields, path: 'blocks.block2.text2' })\n    expect(fieldInBlock?.field).toBeDefined()\n\n    const sourceField = (fields[4] as any).blocks?.[1].flattenedFields?.[0]\n    expect(sourceField).toBeDefined()\n    expect(fieldInBlock?.field).toBe(sourceField)\n  })\n})\n"],"names":["assert","describe","it","expect","flattenAllFields","getFieldByPath","fields","type","name","localized","tabs","blocks","slug","assert_1","path","field","toBe","pathHasLocalized","assert_2","localizedPath","arrayField","assert_3","assert_4","flattenedFields","assert_5","groupWithinArray","assert_6","assert_7","fieldInBlock","toBeDefined","sourceField"],"mappings":"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"}

package/dist/utilities/getFieldPermissions.d.ts

@@ -0,0 +1,26 @@
+import type { SanitizedDocumentPermissions, SanitizedFieldPermissions, SanitizedFieldsPermissions } from '../auth/types.js';
+import type { ClientField, Field } from '../fields/config/types.js';
+import type { Operation } from '../types/index.js';
+/**
+ * Gets read and operation-level permissions for a given field based on cascading field permissions.
+ * @returns An object with the following properties:
+ * - `operation`: Whether the user has permission to perform the operation on the field (`create` or `update`).
+ * - `permissions`: The field-level permissions.
+ * - `read`: Whether the user has permission to read the field.
+ */
+export declare const getFieldPermissions: ({ collectionPermissions, field, operation, parentName, permissions, }: {
+    readonly collectionPermissions?: SanitizedDocumentPermissions;
+    readonly field: ClientField | Field;
+    readonly operation: Operation;
+    readonly parentName: string;
+    readonly permissions: SanitizedFieldPermissions | SanitizedFieldsPermissions;
+}) => {
+    operation: boolean;
+    /**
+     * The field-level permissions. This can be equal to the permissions passed to the
+     * `getFieldPermissions` function if the field has no name.
+     */
+    permissions: SanitizedFieldPermissions | SanitizedFieldsPermissions;
+    read: boolean;
+};
+//# sourceMappingURL=getFieldPermissions.d.ts.map

package/dist/utilities/getFieldPermissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFieldPermissions.d.ts","sourceRoot":"","sources":["../../src/utilities/getFieldPermissions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,4BAA4B,EAC5B,yBAAyB,EACzB,0BAA0B,EAC3B,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAA;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAElD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,0EAM7B;IACD,QAAQ,CAAC,qBAAqB,CAAC,EAAE,4BAA4B,CAAA;IAC7D,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,KAAK,CAAA;IACnC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,WAAW,EAAE,yBAAyB,GAAG,0BAA0B,CAAA;CAC7E,KAAG;IACF,SAAS,EAAE,OAAO,CAAA;IAClB;;;OAGG;IACH,WAAW,EAAE,yBAAyB,GAAG,0BAA0B,CAAA;IACnE,IAAI,EAAE,OAAO,CAAA;CA6Dd,CAAA"}

package/dist/utilities/getFieldPermissions.js

@@ -0,0 +1,40 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ /**
+ * Gets read and operation-level permissions for a given field based on cascading field permissions.
+ * @returns An object with the following properties:
+ * - `operation`: Whether the user has permission to perform the operation on the field (`create` or `update`).
+ * - `permissions`: The field-level permissions.
+ * - `read`: Whether the user has permission to read the field.
+ */ export const getFieldPermissions = ({ collectionPermissions, field, operation, parentName, permissions })=>{
+    // First, calculate permissions using the existing logic
+    const fieldOperation = permissions === true || permissions?.[operation] === true || permissions?.[parentName] === true || 'name' in field && typeof permissions === 'object' && permissions?.[field.name] && (permissions[field.name] === true || operation in permissions[field.name] && permissions[field.name][operation]);
+    const fieldPermissions = permissions === undefined || permissions === null || permissions === true ? true : 'name' in field ? permissions[field.name] : permissions;
+    const fieldRead = permissions === true || permissions?.read === true || permissions?.[parentName] === true || 'name' in field && typeof permissions === 'object' && permissions?.[field.name] && (permissions[field.name] === true || 'read' in permissions[field.name] && permissions[field.name].read);
+    // Check if field permissions are effectively empty/missing
+    const hasFieldPermissions = permissions === true || typeof permissions === 'object' && permissions !== null && Object.keys(permissions).length > 0;
+    // If no field permissions are defined, fallback to collection permissions
+    if (!hasFieldPermissions && collectionPermissions) {
+        const collectionRead = Boolean(collectionPermissions.read);
+        let collectionOperation = false;
+        // Check operation-specific permission on collection
+        if (operation === 'create' && 'create' in collectionPermissions) {
+            collectionOperation = Boolean(collectionPermissions.create);
+        } else if (operation === 'update') {
+            collectionOperation = Boolean(collectionPermissions.update);
+        }
+        return {
+            operation: collectionOperation,
+            permissions: {
+                read: collectionRead
+            },
+            read: collectionRead
+        };
+    }
+    // Return the calculated permissions
+    return {
+        operation: Boolean(fieldOperation),
+        permissions: fieldPermissions,
+        read: Boolean(fieldRead)
+    };
+};
+
+//# sourceMappingURL=getFieldPermissions.js.map

package/dist/utilities/getFieldPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/getFieldPermissions.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type {\n  SanitizedDocumentPermissions,\n  SanitizedFieldPermissions,\n  SanitizedFieldsPermissions,\n} from '../auth/types.js'\nimport type { ClientField, Field } from '../fields/config/types.js'\nimport type { Operation } from '../types/index.js'\n\n/**\n * Gets read and operation-level permissions for a given field based on cascading field permissions.\n * @returns An object with the following properties:\n * - `operation`: Whether the user has permission to perform the operation on the field (`create` or `update`).\n * - `permissions`: The field-level permissions.\n * - `read`: Whether the user has permission to read the field.\n */\nexport const getFieldPermissions = ({\n  collectionPermissions,\n  field,\n  operation,\n  parentName,\n  permissions,\n}: {\n  readonly collectionPermissions?: SanitizedDocumentPermissions\n  readonly field: ClientField | Field\n  readonly operation: Operation\n  readonly parentName: string\n  readonly permissions: SanitizedFieldPermissions | SanitizedFieldsPermissions\n}): {\n  operation: boolean\n  /**\n   * The field-level permissions. This can be equal to the permissions passed to the\n   * `getFieldPermissions` function if the field has no name.\n   */\n  permissions: SanitizedFieldPermissions | SanitizedFieldsPermissions\n  read: boolean\n} => {\n  // First, calculate permissions using the existing logic\n  const fieldOperation =\n    permissions === true ||\n    permissions?.[operation as keyof typeof permissions] === true ||\n    permissions?.[parentName as keyof typeof permissions] === true ||\n    ('name' in field &&\n      typeof permissions === 'object' &&\n      permissions?.[field.name as keyof typeof permissions] &&\n      (permissions[field.name as keyof typeof permissions] === true ||\n        (operation in (permissions as any)[field.name] &&\n          (permissions as any)[field.name][operation])))\n\n  const fieldPermissions =\n    permissions === undefined || permissions === null || permissions === true\n      ? true\n      : 'name' in field\n        ? (permissions as any)[field.name]\n        : permissions\n\n  const fieldRead =\n    permissions === true ||\n    permissions?.read === true ||\n    permissions?.[parentName as keyof typeof permissions] === true ||\n    ('name' in field &&\n      typeof permissions === 'object' &&\n      permissions?.[field.name as keyof typeof permissions] &&\n      ((permissions as any)[field.name] === true ||\n        ('read' in (permissions as any)[field.name] && (permissions as any)[field.name].read)))\n\n  // Check if field permissions are effectively empty/missing\n  const hasFieldPermissions =\n    permissions === true ||\n    (typeof permissions === 'object' && permissions !== null && Object.keys(permissions).length > 0)\n\n  // If no field permissions are defined, fallback to collection permissions\n  if (!hasFieldPermissions && collectionPermissions) {\n    const collectionRead = Boolean(collectionPermissions.read)\n    let collectionOperation = false\n\n    // Check operation-specific permission on collection\n    if (operation === 'create' && 'create' in collectionPermissions) {\n      collectionOperation = Boolean(collectionPermissions.create)\n    } else if (operation === 'update') {\n      collectionOperation = Boolean(collectionPermissions.update)\n    }\n\n    return {\n      operation: collectionOperation,\n      permissions: { read: collectionRead } as SanitizedFieldPermissions,\n      read: collectionRead,\n    }\n  }\n\n  // Return the calculated permissions\n  return {\n    operation: Boolean(fieldOperation),\n    permissions: fieldPermissions,\n    read: Boolean(fieldRead),\n  }\n}\n"],"names":["getFieldPermissions","collectionPermissions","field","operation","parentName","permissions","fieldOperation","name","fieldPermissions","undefined","fieldRead","read","hasFieldPermissions","Object","keys","length","collectionRead","Boolean","collectionOperation","create","update"],"mappings":"AAAA,qDAAqD,GASrD;;;;;;CAMC,GACD,OAAO,MAAMA,sBAAsB,CAAC,EAClCC,qBAAqB,EACrBC,KAAK,EACLC,SAAS,EACTC,UAAU,EACVC,WAAW,EAOZ;IASC,wDAAwD;IACxD,MAAMC,iBACJD,gBAAgB,QAChBA,aAAa,CAACF,UAAsC,KAAK,QACzDE,aAAa,CAACD,WAAuC,KAAK,QACzD,UAAUF,SACT,OAAOG,gBAAgB,YACvBA,aAAa,CAACH,MAAMK,IAAI,CAA6B,IACpDF,CAAAA,WAAW,CAACH,MAAMK,IAAI,CAA6B,KAAK,QACtDJ,aAAa,AAACE,WAAmB,CAACH,MAAMK,IAAI,CAAC,IAC5C,AAACF,WAAmB,CAACH,MAAMK,IAAI,CAAC,CAACJ,UAAU;IAEnD,MAAMK,mBACJH,gBAAgBI,aAAaJ,gBAAgB,QAAQA,gBAAgB,OACjE,OACA,UAAUH,QACR,AAACG,WAAmB,CAACH,MAAMK,IAAI,CAAC,GAChCF;IAER,MAAMK,YACJL,gBAAgB,QAChBA,aAAaM,SAAS,QACtBN,aAAa,CAACD,WAAuC,KAAK,QACzD,UAAUF,SACT,OAAOG,gBAAgB,YACvBA,aAAa,CAACH,MAAMK,IAAI,CAA6B,IACpD,CAAA,AAACF,WAAmB,CAACH,MAAMK,IAAI,CAAC,KAAK,QACnC,UAAU,AAACF,WAAmB,CAACH,MAAMK,IAAI,CAAC,IAAI,AAACF,WAAmB,CAACH,MAAMK,IAAI,CAAC,CAACI,IAAI;IAE1F,2DAA2D;IAC3D,MAAMC,sBACJP,gBAAgB,QACf,OAAOA,gBAAgB,YAAYA,gBAAgB,QAAQQ,OAAOC,IAAI,CAACT,aAAaU,MAAM,GAAG;IAEhG,0EAA0E;IAC1E,IAAI,CAACH,uBAAuBX,uBAAuB;QACjD,MAAMe,iBAAiBC,QAAQhB,sBAAsBU,IAAI;QACzD,IAAIO,sBAAsB;QAE1B,oDAAoD;QACpD,IAAIf,cAAc,YAAY,YAAYF,uBAAuB;YAC/DiB,sBAAsBD,QAAQhB,sBAAsBkB,MAAM;QAC5D,OAAO,IAAIhB,cAAc,UAAU;YACjCe,sBAAsBD,QAAQhB,sBAAsBmB,MAAM;QAC5D;QAEA,OAAO;YACLjB,WAAWe;YACXb,aAAa;gBAAEM,MAAMK;YAAe;YACpCL,MAAMK;QACR;IACF;IAEA,oCAAoC;IACpC,OAAO;QACLb,WAAWc,QAAQX;QACnBD,aAAaG;QACbG,MAAMM,QAAQP;IAChB;AACF,EAAC"}