@depup/payload 3.79.1-depup.0

package/dist/utilities/logError.d.ts

@@ -0,0 +1,6 @@
+import type { Payload } from '../types/index.js';
+export declare const logError: ({ err, payload }: {
+    err: unknown;
+    payload: Payload;
+}) => void;
+//# sourceMappingURL=logError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logError.d.ts","sourceRoot":"","sources":["../../src/utilities/logError.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAEhD,eAAO,MAAM,QAAQ,qBAAsB;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,KAAG,IAyB/E,CAAA"}

package/dist/utilities/logError.js

@@ -0,0 +1,17 @@
+export const logError = ({ err, payload })=>{
+    let level = 'error';
+    if (err && typeof err === 'object' && 'name' in err && typeof err.name === 'string' && typeof payload.config.loggingLevels[err.name] !== 'undefined') {
+        level = payload.config.loggingLevels[err.name];
+    }
+    if (level) {
+        const logObject = {};
+        if (level === 'info') {
+            logObject.msg = typeof err === 'object' && 'message' in err ? err.message : 'Error';
+        } else {
+            logObject.err = err;
+        }
+        payload.logger[level](logObject);
+    }
+};
+
+//# sourceMappingURL=logError.js.map

package/dist/utilities/logError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/logError.ts"],"sourcesContent":["import type pino from 'pino'\n\nimport type { Payload } from '../types/index.js'\n\nexport const logError = ({ err, payload }: { err: unknown; payload: Payload }): void => {\n  let level: false | pino.Level = 'error'\n\n  if (\n    err &&\n    typeof err === 'object' &&\n    'name' in err &&\n    typeof err.name === 'string' &&\n    typeof payload.config.loggingLevels[err.name as keyof typeof payload.config.loggingLevels] !==\n      'undefined'\n  ) {\n    level = payload.config.loggingLevels[err.name as keyof typeof payload.config.loggingLevels]\n  }\n\n  if (level) {\n    const logObject: { err?: unknown; msg?: unknown } = {}\n\n    if (level === 'info') {\n      logObject.msg = typeof err === 'object' && 'message' in err! ? err.message : 'Error'\n    } else {\n      logObject.err = err\n    }\n\n    payload.logger[level](logObject)\n  }\n}\n"],"names":["logError","err","payload","level","name","config","loggingLevels","logObject","msg","message","logger"],"mappings":"AAIA,OAAO,MAAMA,WAAW,CAAC,EAAEC,GAAG,EAAEC,OAAO,EAAsC;IAC3E,IAAIC,QAA4B;IAEhC,IACEF,OACA,OAAOA,QAAQ,YACf,UAAUA,OACV,OAAOA,IAAIG,IAAI,KAAK,YACpB,OAAOF,QAAQG,MAAM,CAACC,aAAa,CAACL,IAAIG,IAAI,CAA8C,KACxF,aACF;QACAD,QAAQD,QAAQG,MAAM,CAACC,aAAa,CAACL,IAAIG,IAAI,CAA8C;IAC7F;IAEA,IAAID,OAAO;QACT,MAAMI,YAA8C,CAAC;QAErD,IAAIJ,UAAU,QAAQ;YACpBI,UAAUC,GAAG,GAAG,OAAOP,QAAQ,YAAY,aAAaA,MAAOA,IAAIQ,OAAO,GAAG;QAC/E,OAAO;YACLF,UAAUN,GAAG,GAAGA;QAClB;QAEAC,QAAQQ,MAAM,CAACP,MAAM,CAACI;IACxB;AACF,EAAC"}

package/dist/utilities/logger.d.ts

@@ -0,0 +1,12 @@
+import { type Logger } from 'pino';
+import { type PinoPretty } from 'pino-pretty';
+import type { Config } from '../config/types.js';
+/**
+ * Payload internal logger. Uses Pino.
+ * This allows you to bring your own logger instance and let payload use it
+ */
+export type PayloadLogger = Logger;
+export declare const prettySyncLoggerDestination: PinoPretty.PrettyStream;
+export declare const defaultLoggerOptions: PinoPretty.PrettyStream;
+export declare const getLogger: (name?: string, logger?: Config["logger"]) => PayloadLogger;
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utilities/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAQ,MAAM,MAAM,CAAA;AACxC,OAAO,EAAS,KAAK,UAAU,EAAsB,MAAM,aAAa,CAAA;AAExE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAEhD;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAA;AAQlC,eAAO,MAAM,2BAA2B,EAAE,UAAU,CAAC,YAInD,CAAA;AAEF,eAAO,MAAM,oBAAoB,EAAE,UAAU,CAAC,YAAmC,CAAA;AAEjF,eAAO,MAAM,SAAS,2BAA+B,MAAM,CAAC,QAAQ,CAAC,KAAG,aA2BvE,CAAA"}

package/dist/utilities/logger.js

@@ -0,0 +1,38 @@
+import { pino } from 'pino';
+import { build } from 'pino-pretty';
+const prettyOptions = {
+    colorize: true,
+    ignore: 'pid,hostname',
+    translateTime: 'SYS:HH:MM:ss'
+};
+export const prettySyncLoggerDestination = build({
+    ...prettyOptions,
+    destination: 1,
+    sync: true
+});
+export const defaultLoggerOptions = build(prettyOptions);
+export const getLogger = (name = 'payload', logger)=>{
+    if (!logger) {
+        return pino(defaultLoggerOptions);
+    }
+    // Synchronous logger used by bin scripts
+    if (logger === 'sync') {
+        return pino(prettySyncLoggerDestination);
+    }
+    // Check if logger is an object
+    if ('options' in logger) {
+        const { destination, options } = logger;
+        if (!options.name) {
+            options.name = name;
+        }
+        if (!options.enabled) {
+            options.enabled = process.env.DISABLE_LOGGING !== 'true';
+        }
+        return pino(options, destination);
+    } else {
+        // Instantiated logger
+        return logger;
+    }
+};
+
+//# sourceMappingURL=logger.js.map

package/dist/utilities/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/logger.ts"],"sourcesContent":["import { type Logger, pino } from 'pino'\nimport { build, type PinoPretty, type PrettyOptions } from 'pino-pretty'\n\nimport type { Config } from '../config/types.js'\n\n/**\n * Payload internal logger. Uses Pino.\n * This allows you to bring your own logger instance and let payload use it\n */\nexport type PayloadLogger = Logger\n\nconst prettyOptions: PrettyOptions = {\n  colorize: true,\n  ignore: 'pid,hostname',\n  translateTime: 'SYS:HH:MM:ss',\n}\n\nexport const prettySyncLoggerDestination: PinoPretty.PrettyStream = build({\n  ...prettyOptions,\n  destination: 1, // stdout\n  sync: true,\n})\n\nexport const defaultLoggerOptions: PinoPretty.PrettyStream = build(prettyOptions)\n\nexport const getLogger = (name = 'payload', logger?: Config['logger']): PayloadLogger => {\n  if (!logger) {\n    return pino(defaultLoggerOptions)\n  }\n\n  // Synchronous logger used by bin scripts\n  if (logger === 'sync') {\n    return pino(prettySyncLoggerDestination)\n  }\n\n  // Check if logger is an object\n  if ('options' in logger) {\n    const { destination, options } = logger\n\n    if (!options.name) {\n      options.name = name\n    }\n\n    if (!options.enabled) {\n      options.enabled = process.env.DISABLE_LOGGING !== 'true'\n    }\n\n    return pino(options, destination)\n  } else {\n    // Instantiated logger\n    return logger\n  }\n}\n"],"names":["pino","build","prettyOptions","colorize","ignore","translateTime","prettySyncLoggerDestination","destination","sync","defaultLoggerOptions","getLogger","name","logger","options","enabled","process","env","DISABLE_LOGGING"],"mappings":"AAAA,SAAsBA,IAAI,QAAQ,OAAM;AACxC,SAASC,KAAK,QAA6C,cAAa;AAUxE,MAAMC,gBAA+B;IACnCC,UAAU;IACVC,QAAQ;IACRC,eAAe;AACjB;AAEA,OAAO,MAAMC,8BAAuDL,MAAM;IACxE,GAAGC,aAAa;IAChBK,aAAa;IACbC,MAAM;AACR,GAAE;AAEF,OAAO,MAAMC,uBAAgDR,MAAMC,eAAc;AAEjF,OAAO,MAAMQ,YAAY,CAACC,OAAO,SAAS,EAAEC;IAC1C,IAAI,CAACA,QAAQ;QACX,OAAOZ,KAAKS;IACd;IAEA,yCAAyC;IACzC,IAAIG,WAAW,QAAQ;QACrB,OAAOZ,KAAKM;IACd;IAEA,+BAA+B;IAC/B,IAAI,aAAaM,QAAQ;QACvB,MAAM,EAAEL,WAAW,EAAEM,OAAO,EAAE,GAAGD;QAEjC,IAAI,CAACC,QAAQF,IAAI,EAAE;YACjBE,QAAQF,IAAI,GAAGA;QACjB;QAEA,IAAI,CAACE,QAAQC,OAAO,EAAE;YACpBD,QAAQC,OAAO,GAAGC,QAAQC,GAAG,CAACC,eAAe,KAAK;QACpD;QAEA,OAAOjB,KAAKa,SAASN;IACvB,OAAO;QACL,sBAAsB;QACtB,OAAOK;IACT;AACF,EAAC"}

package/dist/utilities/mapAsync.d.ts

@@ -0,0 +1,2 @@
+export declare function mapAsync<T, U>(arr: T[], callbackfn: (item: T, index: number, array: T[]) => Promise<U>): Promise<U[]>;
+//# sourceMappingURL=mapAsync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mapAsync.d.ts","sourceRoot":"","sources":["../../src/utilities/mapAsync.ts"],"names":[],"mappings":"AAAA,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACjC,GAAG,EAAE,CAAC,EAAE,EACR,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,CAAC,EAAE,CAAC,CAEd"}

package/dist/utilities/mapAsync.js

@@ -0,0 +1,5 @@
+export async function mapAsync(arr, callbackfn) {
+    return Promise.all(arr.map(callbackfn));
+}
+
+//# sourceMappingURL=mapAsync.js.map

package/dist/utilities/mapAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/mapAsync.ts"],"sourcesContent":["export async function mapAsync<T, U>(\n  arr: T[],\n  callbackfn: (item: T, index: number, array: T[]) => Promise<U>,\n): Promise<U[]> {\n  return Promise.all(arr.map(callbackfn))\n}\n"],"names":["mapAsync","arr","callbackfn","Promise","all","map"],"mappings":"AAAA,OAAO,eAAeA,SACpBC,GAAQ,EACRC,UAA8D;IAE9D,OAAOC,QAAQC,GAAG,CAACH,IAAII,GAAG,CAACH;AAC7B"}

package/dist/utilities/mergeHeaders.d.ts

@@ -0,0 +1,2 @@
+export declare const mergeHeaders: (sourceHeaders: Headers, destinationHeaders: Headers) => Headers;
+//# sourceMappingURL=mergeHeaders.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeHeaders.d.ts","sourceRoot":"","sources":["../../src/utilities/mergeHeaders.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,kBAAmB,OAAO,sBAAsB,OAAO,KAAG,OAUlF,CAAA"}

package/dist/utilities/mergeHeaders.js

@@ -0,0 +1,11 @@
+export const mergeHeaders = (sourceHeaders, destinationHeaders)=>{
+    // Create a new Headers object
+    const combinedHeaders = new Headers(destinationHeaders);
+    // Append sourceHeaders to combinedHeaders
+    sourceHeaders.forEach((value, key)=>{
+        combinedHeaders.append(key, value);
+    });
+    return combinedHeaders;
+};
+
+//# sourceMappingURL=mergeHeaders.js.map

package/dist/utilities/mergeHeaders.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/mergeHeaders.ts"],"sourcesContent":["export const mergeHeaders = (sourceHeaders: Headers, destinationHeaders: Headers): Headers => {\n  // Create a new Headers object\n  const combinedHeaders = new Headers(destinationHeaders)\n\n  // Append sourceHeaders to combinedHeaders\n  sourceHeaders.forEach((value, key) => {\n    combinedHeaders.append(key, value)\n  })\n\n  return combinedHeaders\n}\n"],"names":["mergeHeaders","sourceHeaders","destinationHeaders","combinedHeaders","Headers","forEach","value","key","append"],"mappings":"AAAA,OAAO,MAAMA,eAAe,CAACC,eAAwBC;IACnD,8BAA8B;IAC9B,MAAMC,kBAAkB,IAAIC,QAAQF;IAEpC,0CAA0C;IAC1CD,cAAcI,OAAO,CAAC,CAACC,OAAOC;QAC5BJ,gBAAgBK,MAAM,CAACD,KAAKD;IAC9B;IAEA,OAAOH;AACT,EAAC"}

package/dist/utilities/mergeListSearchAndWhere.d.ts

@@ -0,0 +1,12 @@
+import type { ClientCollectionConfig } from '../collections/config/client.js';
+import type { SanitizedCollectionConfig } from '../collections/config/types.js';
+import type { Where } from '../types/index.js';
+export declare const hoistQueryParamsToAnd: (currentWhere: Where, incomingWhere: Where) => Where;
+type Args = {
+    collectionConfig: ClientCollectionConfig | SanitizedCollectionConfig;
+    search: string;
+    where?: Where;
+};
+export declare const mergeListSearchAndWhere: ({ collectionConfig, search, where }: Args) => Where;
+export {};
+//# sourceMappingURL=mergeListSearchAndWhere.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeListSearchAndWhere.d.ts","sourceRoot":"","sources":["../../src/utilities/mergeListSearchAndWhere.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAA;AAC7E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAC/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAI9C,eAAO,MAAM,qBAAqB,iBAAkB,KAAK,iBAAiB,KAAK,UAsB9E,CAAA;AAED,KAAK,IAAI,GAAG;IACV,gBAAgB,EAAE,sBAAsB,GAAG,yBAAyB,CAAA;IACpE,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,KAAK,CAAA;CACd,CAAA;AAED,eAAO,MAAM,uBAAuB,wCAA8C,IAAI,KAAG,KAwBxF,CAAA"}

package/dist/utilities/mergeListSearchAndWhere.js

@@ -0,0 +1,52 @@
+const isEmptyObject = (obj)=>Object.keys(obj).length === 0;
+export const hoistQueryParamsToAnd = (currentWhere, incomingWhere)=>{
+    if (isEmptyObject(incomingWhere)) {
+        return currentWhere;
+    }
+    if (isEmptyObject(currentWhere)) {
+        return incomingWhere;
+    }
+    if ('and' in currentWhere && currentWhere.and) {
+        currentWhere.and.push(incomingWhere);
+    } else if ('or' in currentWhere) {
+        currentWhere = {
+            and: [
+                currentWhere,
+                incomingWhere
+            ]
+        };
+    } else {
+        currentWhere = {
+            and: [
+                currentWhere,
+                incomingWhere
+            ]
+        };
+    }
+    return currentWhere;
+};
+export const mergeListSearchAndWhere = ({ collectionConfig, search, where = {} })=>{
+    if (search) {
+        let copyOfWhere = {
+            ...where || {}
+        };
+        const searchAsConditions = (collectionConfig.admin.listSearchableFields || [
+            collectionConfig.admin?.useAsTitle || 'id'
+        ]).map((fieldName)=>({
+                [fieldName]: {
+                    like: search
+                }
+            }));
+        if (searchAsConditions.length > 0) {
+            copyOfWhere = hoistQueryParamsToAnd(copyOfWhere, {
+                or: searchAsConditions
+            });
+        }
+        if (!isEmptyObject(copyOfWhere)) {
+            where = copyOfWhere;
+        }
+    }
+    return where;
+};
+
+//# sourceMappingURL=mergeListSearchAndWhere.js.map

package/dist/utilities/mergeListSearchAndWhere.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/mergeListSearchAndWhere.ts"],"sourcesContent":["import type { ClientCollectionConfig } from '../collections/config/client.js'\nimport type { SanitizedCollectionConfig } from '../collections/config/types.js'\nimport type { Where } from '../types/index.js'\n\nconst isEmptyObject = (obj: object) => Object.keys(obj).length === 0\n\nexport const hoistQueryParamsToAnd = (currentWhere: Where, incomingWhere: Where) => {\n  if (isEmptyObject(incomingWhere)) {\n    return currentWhere\n  }\n\n  if (isEmptyObject(currentWhere)) {\n    return incomingWhere\n  }\n\n  if ('and' in currentWhere && currentWhere.and) {\n    currentWhere.and.push(incomingWhere)\n  } else if ('or' in currentWhere) {\n    currentWhere = {\n      and: [currentWhere, incomingWhere],\n    }\n  } else {\n    currentWhere = {\n      and: [currentWhere, incomingWhere],\n    }\n  }\n\n  return currentWhere\n}\n\ntype Args = {\n  collectionConfig: ClientCollectionConfig | SanitizedCollectionConfig\n  search: string\n  where?: Where\n}\n\nexport const mergeListSearchAndWhere = ({ collectionConfig, search, where = {} }: Args): Where => {\n  if (search) {\n    let copyOfWhere = { ...(where || {}) }\n\n    const searchAsConditions = (\n      collectionConfig.admin.listSearchableFields || [collectionConfig.admin?.useAsTitle || 'id']\n    ).map((fieldName) => ({\n      [fieldName]: {\n        like: search,\n      },\n    }))\n\n    if (searchAsConditions.length > 0) {\n      copyOfWhere = hoistQueryParamsToAnd(copyOfWhere, {\n        or: searchAsConditions,\n      })\n    }\n\n    if (!isEmptyObject(copyOfWhere)) {\n      where = copyOfWhere\n    }\n  }\n\n  return where\n}\n"],"names":["isEmptyObject","obj","Object","keys","length","hoistQueryParamsToAnd","currentWhere","incomingWhere","and","push","mergeListSearchAndWhere","collectionConfig","search","where","copyOfWhere","searchAsConditions","admin","listSearchableFields","useAsTitle","map","fieldName","like","or"],"mappings":"AAIA,MAAMA,gBAAgB,CAACC,MAAgBC,OAAOC,IAAI,CAACF,KAAKG,MAAM,KAAK;AAEnE,OAAO,MAAMC,wBAAwB,CAACC,cAAqBC;IACzD,IAAIP,cAAcO,gBAAgB;QAChC,OAAOD;IACT;IAEA,IAAIN,cAAcM,eAAe;QAC/B,OAAOC;IACT;IAEA,IAAI,SAASD,gBAAgBA,aAAaE,GAAG,EAAE;QAC7CF,aAAaE,GAAG,CAACC,IAAI,CAACF;IACxB,OAAO,IAAI,QAAQD,cAAc;QAC/BA,eAAe;YACbE,KAAK;gBAACF;gBAAcC;aAAc;QACpC;IACF,OAAO;QACLD,eAAe;YACbE,KAAK;gBAACF;gBAAcC;aAAc;QACpC;IACF;IAEA,OAAOD;AACT,EAAC;AAQD,OAAO,MAAMI,0BAA0B,CAAC,EAAEC,gBAAgB,EAAEC,MAAM,EAAEC,QAAQ,CAAC,CAAC,EAAQ;IACpF,IAAID,QAAQ;QACV,IAAIE,cAAc;YAAE,GAAID,SAAS,CAAC,CAAC;QAAE;QAErC,MAAME,qBAAqB,AACzBJ,CAAAA,iBAAiBK,KAAK,CAACC,oBAAoB,IAAI;YAACN,iBAAiBK,KAAK,EAAEE,cAAc;SAAK,AAAD,EAC1FC,GAAG,CAAC,CAACC,YAAe,CAAA;gBACpB,CAACA,UAAU,EAAE;oBACXC,MAAMT;gBACR;YACF,CAAA;QAEA,IAAIG,mBAAmBX,MAAM,GAAG,GAAG;YACjCU,cAAcT,sBAAsBS,aAAa;gBAC/CQ,IAAIP;YACN;QACF;QAEA,IAAI,CAACf,cAAcc,cAAc;YAC/BD,QAAQC;QACV;IACF;IAEA,OAAOD;AACT,EAAC"}

package/dist/utilities/mergeLocalizedData.d.ts

@@ -0,0 +1,20 @@
+import type { Field } from '../fields/config/types.js';
+import type { SanitizedConfig } from '../index.js';
+import type { JsonObject } from '../types/index.js';
+type MergeDataToSelectedLocalesArgs = {
+    configBlockReferences: SanitizedConfig['blocks'];
+    dataWithLocales: JsonObject;
+    docWithLocales: JsonObject;
+    fields: Field[];
+    parentIsLocalized?: boolean;
+    selectedLocales: string[];
+};
+/**
+ * Merges data from dataWithLocales onto docWithLocales for specified locales.
+ * For localized fields, merges only the specified locales while preserving others.
+ * For non-localized fields, keeps existing values from docWithLocales unchanged.
+ * Returns a new object without mutating the original.
+ */
+export declare function mergeLocalizedData({ configBlockReferences, dataWithLocales, docWithLocales, fields, parentIsLocalized, selectedLocales, }: MergeDataToSelectedLocalesArgs): JsonObject;
+export {};
+//# sourceMappingURL=mergeLocalizedData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeLocalizedData.d.ts","sourceRoot":"","sources":["../../src/utilities/mergeLocalizedData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,KAAK,EAAkB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAiCnD,KAAK,8BAA8B,GAAG;IACpC,qBAAqB,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;IAChD,eAAe,EAAE,UAAU,CAAA;IAC3B,cAAc,EAAE,UAAU,CAAA;IAC1B,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,eAAe,EAAE,MAAM,EAAE,CAAA;CAC1B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,MAAM,EACN,iBAAyB,EACzB,eAAe,GAChB,EAAE,8BAA8B,GAAG,UAAU,CAiS7C"}

package/dist/utilities/mergeLocalizedData.js

@@ -0,0 +1,312 @@
+import { fieldAffectsData, fieldShouldBeLocalized, tabHasName } from '../fields/config/types.js';
+/**
+ * Collects field names at the current data level, recursing through pass-through fields
+ * (row, collapsible, unnamed group, unnamed tab) but stopping at named fields.
+ */ function collectFlattenedFieldNames(fields) {
+    const names = new Set();
+    for (const field of fields){
+        if (fieldAffectsData(field)) {
+            names.add(field.name);
+        } else if ('fields' in field && Array.isArray(field.fields)) {
+            // Pass-through fields (row, collapsible, unnamed group)
+            for (const name of collectFlattenedFieldNames(field.fields)){
+                names.add(name);
+            }
+        } else if (field.type === 'tabs') {
+            for (const tab of field.tabs){
+                if (tabHasName(tab)) {
+                    names.add(tab.name);
+                } else {
+                    for (const name of collectFlattenedFieldNames(tab.fields)){
+                        names.add(name);
+                    }
+                }
+            }
+        }
+    }
+    return names;
+}
+/**
+ * Merges data from dataWithLocales onto docWithLocales for specified locales.
+ * For localized fields, merges only the specified locales while preserving others.
+ * For non-localized fields, keeps existing values from docWithLocales unchanged.
+ * Returns a new object without mutating the original.
+ */ export function mergeLocalizedData({ configBlockReferences, dataWithLocales, docWithLocales, fields, parentIsLocalized = false, selectedLocales }) {
+    if (!docWithLocales || typeof docWithLocales !== 'object') {
+        return dataWithLocales || docWithLocales;
+    }
+    const result = {
+        ...docWithLocales
+    };
+    for (const field of fields){
+        if (fieldAffectsData(field)) {
+            // If the parent is localized, all children are inherently "localized"
+            if (parentIsLocalized && dataWithLocales[field.name]) {
+                result[field.name] = dataWithLocales[field.name];
+                continue;
+            }
+            const fieldIsLocalized = fieldShouldBeLocalized({
+                field,
+                parentIsLocalized
+            });
+            switch(field.type){
+                case 'array':
+                    {
+                        if (field.name in dataWithLocales) {
+                            const newValue = dataWithLocales[field.name];
+                            const existingValue = docWithLocales[field.name];
+                            if (fieldIsLocalized) {
+                                // If localized, handle locale keys
+                                if (newValue && typeof newValue === 'object' && !Array.isArray(newValue)) {
+                                    const updatedArray = {
+                                        ...existingValue || {}
+                                    };
+                                    for (const locale of selectedLocales){
+                                        if (locale in newValue) {
+                                            updatedArray[locale] = newValue[locale];
+                                        }
+                                    }
+                                    result[field.name] = updatedArray;
+                                } else {
+                                    // Preserve existing value if new value is not a valid object
+                                    result[field.name] = existingValue;
+                                }
+                            } else if (Array.isArray(newValue)) {
+                                // Non-localized array - still process children for any localized fields
+                                result[field.name] = newValue.map((newItem, index)=>{
+                                    const existingItem = existingValue?.[index] || {};
+                                    return mergeLocalizedData({
+                                        configBlockReferences,
+                                        dataWithLocales: newItem,
+                                        docWithLocales: existingItem,
+                                        fields: field.fields,
+                                        parentIsLocalized,
+                                        selectedLocales
+                                    });
+                                });
+                            }
+                        }
+                        break;
+                    }
+                case 'blocks':
+                    {
+                        if (field.name in dataWithLocales) {
+                            const newValue = dataWithLocales[field.name];
+                            const existingValue = docWithLocales[field.name];
+                            if (fieldIsLocalized) {
+                                // If localized, handle locale keys
+                                if (newValue && typeof newValue === 'object' && !Array.isArray(newValue)) {
+                                    const updatedData = {
+                                        ...existingValue || {}
+                                    };
+                                    for (const locale of selectedLocales){
+                                        if (locale in newValue) {
+                                            updatedData[locale] = newValue[locale];
+                                        }
+                                    }
+                                    result[field.name] = updatedData;
+                                } else {
+                                    // Preserve existing value if new value is not a valid object
+                                    result[field.name] = existingValue;
+                                }
+                            } else if (Array.isArray(newValue)) {
+                                // Non-localized blocks - still process children for any localized fields
+                                result[field.name] = newValue.map((newBlockData, index)=>{
+                                    let block;
+                                    if (configBlockReferences && field.blockReferences) {
+                                        for (const blockOrReference of field.blockReferences){
+                                            if (typeof blockOrReference === 'string') {
+                                                block = configBlockReferences.find((b)=>b.slug === newBlockData.blockType);
+                                            } else {
+                                                block = blockOrReference;
+                                            }
+                                        }
+                                    } else if (field.blocks) {
+                                        block = field.blocks.find((b)=>b.slug === newBlockData.blockType);
+                                    }
+                                    if (block) {
+                                        const blockData = Array.isArray(existingValue) && existingValue[index] ? existingValue[index] : {};
+                                        const merged = mergeLocalizedData({
+                                            configBlockReferences,
+                                            dataWithLocales: newBlockData,
+                                            docWithLocales: blockData,
+                                            fields: block?.fields || [],
+                                            parentIsLocalized,
+                                            selectedLocales
+                                        });
+                                        // blockType, id, blockName are set by Payload internally
+                                        // and not part of block.fields, so they must be preserved explicitly
+                                        merged.blockType = newBlockData.blockType;
+                                        merged.id = newBlockData.id;
+                                        merged.blockName = newBlockData.blockName;
+                                        return merged;
+                                    }
+                                    return newBlockData;
+                                });
+                            }
+                        }
+                        break;
+                    }
+                case 'group':
+                    {
+                        if (fieldAffectsData(field) && field.name) {
+                            // Named groups create a nested data structure
+                            if (field.name in dataWithLocales) {
+                                const newValue = dataWithLocales[field.name];
+                                const existingValue = docWithLocales[field.name];
+                                if (fieldIsLocalized) {
+                                    if (newValue && typeof newValue === 'object' && !Array.isArray(newValue)) {
+                                        const groupData = {
+                                            ...existingValue || {}
+                                        };
+                                        for (const locale of selectedLocales){
+                                            if (locale in newValue && typeof newValue[locale] === 'object') {
+                                                groupData[locale] = newValue[locale];
+                                            }
+                                        }
+                                        result[field.name] = groupData;
+                                    } else {
+                                        // Preserve existing value if new value is not a valid object
+                                        result[field.name] = existingValue;
+                                    }
+                                } else if (typeof newValue === 'object' && !Array.isArray(newValue)) {
+                                    // Non-localized group - still process children for any localized fields
+                                    result[field.name] = mergeLocalizedData({
+                                        configBlockReferences,
+                                        dataWithLocales: newValue,
+                                        docWithLocales: existingValue || {},
+                                        fields: field.fields,
+                                        parentIsLocalized,
+                                        selectedLocales
+                                    });
+                                }
+                            }
+                        }
+                        break;
+                    }
+                default:
+                    {
+                        // For all other data-affecting fields (text, number, select, etc.)
+                        if (fieldIsLocalized) {
+                            if (field.name in dataWithLocales) {
+                                const newValue = dataWithLocales[field.name];
+                                const existingValue = docWithLocales[field.name] || {};
+                                // If localized, handle locale keys
+                                if (newValue && typeof newValue === 'object' && !Array.isArray(newValue)) {
+                                    const merged = {
+                                        ...existingValue
+                                    };
+                                    for (const locale of selectedLocales){
+                                        if (locale in newValue) {
+                                            merged[locale] = newValue[locale];
+                                        }
+                                    }
+                                    result[field.name] = merged;
+                                } else if (parentIsLocalized) {
+                                    // Child of localized parent - replace with new value
+                                    result[field.name] = newValue;
+                                } else {
+                                    // Preserve existing value if new value is not a valid object
+                                    result[field.name] = existingValue;
+                                }
+                            }
+                        } else if (parentIsLocalized) {
+                            result[field.name] = dataWithLocales[field.name];
+                        } else {
+                            result[field.name] = field.name in dataWithLocales ? dataWithLocales[field.name] : docWithLocales[field.name];
+                        }
+                        break;
+                    }
+            }
+        } else {
+            // Layout-only fields that don't affect data structure
+            switch(field.type){
+                case 'collapsible':
+                case 'group':
+                case 'row':
+                    {
+                        // These pass through the same data level
+                        const merged = mergeLocalizedData({
+                            configBlockReferences,
+                            dataWithLocales,
+                            docWithLocales,
+                            fields: field.fields,
+                            parentIsLocalized,
+                            selectedLocales
+                        });
+                        // Only copy fields that belong to this layout field to avoid overwriting already-processed fields
+                        const fieldNames = collectFlattenedFieldNames(field.fields);
+                        for (const name of fieldNames){
+                            if (name in merged) {
+                                result[name] = merged[name];
+                            }
+                        }
+                        break;
+                    }
+                case 'tabs':
+                    {
+                        for (const tab of field.tabs){
+                            if (tabHasName(tab)) {
+                                // Named tabs create a nested data structure and can be localized
+                                const tabIsLocalized = fieldShouldBeLocalized({
+                                    field: tab,
+                                    parentIsLocalized
+                                });
+                                if (tab.name in dataWithLocales) {
+                                    const newValue = dataWithLocales[tab.name];
+                                    const existingValue = docWithLocales[tab.name];
+                                    if (tabIsLocalized) {
+                                        if (newValue && typeof newValue === 'object' && !Array.isArray(newValue)) {
+                                            const merged = {
+                                                ...existingValue || {}
+                                            };
+                                            for (const locale of selectedLocales){
+                                                if (locale in newValue && typeof newValue[locale] === 'object') {
+                                                    merged[locale] = newValue[locale];
+                                                }
+                                            }
+                                            result[tab.name] = merged;
+                                        } else {
+                                            // Preserve existing value if new value is not a valid object
+                                            result[tab.name] = existingValue;
+                                        }
+                                    } else if (typeof newValue === 'object' && !Array.isArray(newValue)) {
+                                        // Non-localized tab - still process children for any localized fields
+                                        result[tab.name] = mergeLocalizedData({
+                                            configBlockReferences,
+                                            dataWithLocales: newValue,
+                                            docWithLocales: existingValue || {},
+                                            fields: tab.fields,
+                                            parentIsLocalized,
+                                            selectedLocales
+                                        });
+                                    }
+                                }
+                            } else {
+                                // Unnamed tabs pass through the same data level
+                                const merged = mergeLocalizedData({
+                                    configBlockReferences,
+                                    dataWithLocales,
+                                    docWithLocales,
+                                    fields: tab.fields,
+                                    parentIsLocalized,
+                                    selectedLocales
+                                });
+                                // Only copy fields that belong to this tab to avoid overwriting already-processed fields
+                                const tabFieldNames = collectFlattenedFieldNames(tab.fields);
+                                for (const name of tabFieldNames){
+                                    if (name in merged) {
+                                        result[name] = merged[name];
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    }
+            }
+        }
+    }
+    return result;
+}
+
+//# sourceMappingURL=mergeLocalizedData.js.map

package/dist/utilities/mergeLocalizedData.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/mergeLocalizedData.ts"],"sourcesContent":["import type { Block, Field, FlattenedBlock } from '../fields/config/types.js'\nimport type { SanitizedConfig } from '../index.js'\nimport type { JsonObject } from '../types/index.js'\n\nimport { fieldAffectsData, fieldShouldBeLocalized, tabHasName } from '../fields/config/types.js'\n\n/**\n * Collects field names at the current data level, recursing through pass-through fields\n * (row, collapsible, unnamed group, unnamed tab) but stopping at named fields.\n */\nfunction collectFlattenedFieldNames(fields: Field[]): Set<string> {\n  const names = new Set<string>()\n  for (const field of fields) {\n    if (fieldAffectsData(field)) {\n      names.add(field.name)\n    } else if ('fields' in field && Array.isArray(field.fields)) {\n      // Pass-through fields (row, collapsible, unnamed group)\n      for (const name of collectFlattenedFieldNames(field.fields)) {\n        names.add(name)\n      }\n    } else if (field.type === 'tabs') {\n      for (const tab of field.tabs) {\n        if (tabHasName(tab)) {\n          names.add(tab.name)\n        } else {\n          for (const name of collectFlattenedFieldNames(tab.fields)) {\n            names.add(name)\n          }\n        }\n      }\n    }\n  }\n  return names\n}\n\ntype MergeDataToSelectedLocalesArgs = {\n  configBlockReferences: SanitizedConfig['blocks']\n  dataWithLocales: JsonObject\n  docWithLocales: JsonObject\n  fields: Field[]\n  parentIsLocalized?: boolean\n  selectedLocales: string[]\n}\n\n/**\n * Merges data from dataWithLocales onto docWithLocales for specified locales.\n * For localized fields, merges only the specified locales while preserving others.\n * For non-localized fields, keeps existing values from docWithLocales unchanged.\n * Returns a new object without mutating the original.\n */\nexport function mergeLocalizedData({\n  configBlockReferences,\n  dataWithLocales,\n  docWithLocales,\n  fields,\n  parentIsLocalized = false,\n  selectedLocales,\n}: MergeDataToSelectedLocalesArgs): JsonObject {\n  if (!docWithLocales || typeof docWithLocales !== 'object') {\n    return dataWithLocales || docWithLocales\n  }\n\n  const result: JsonObject = { ...docWithLocales }\n\n  for (const field of fields) {\n    if (fieldAffectsData(field)) {\n      // If the parent is localized, all children are inherently \"localized\"\n      if (parentIsLocalized && dataWithLocales[field.name]) {\n        result[field.name] = dataWithLocales[field.name]\n        continue\n      }\n\n      const fieldIsLocalized = fieldShouldBeLocalized({ field, parentIsLocalized })\n\n      switch (field.type) {\n        case 'array': {\n          if (field.name in dataWithLocales) {\n            const newValue = dataWithLocales[field.name]\n            const existingValue = docWithLocales[field.name]\n\n            if (fieldIsLocalized) {\n              // If localized, handle locale keys\n              if (newValue && typeof newValue === 'object' && !Array.isArray(newValue)) {\n                const updatedArray: Record<string, unknown> = { ...(existingValue || {}) }\n\n                for (const locale of selectedLocales) {\n                  if (locale in newValue) {\n                    updatedArray[locale] = newValue[locale]\n                  }\n                }\n\n                result[field.name] = updatedArray\n              } else {\n                // Preserve existing value if new value is not a valid object\n                result[field.name] = existingValue\n              }\n            } else if (Array.isArray(newValue)) {\n              // Non-localized array - still process children for any localized fields\n              result[field.name] = newValue.map((newItem: JsonObject, index: number) => {\n                const existingItem = existingValue?.[index] || {}\n\n                return mergeLocalizedData({\n                  configBlockReferences,\n                  dataWithLocales: newItem,\n                  docWithLocales: existingItem,\n                  fields: field.fields,\n                  parentIsLocalized,\n                  selectedLocales,\n                })\n              })\n            }\n          }\n          break\n        }\n\n        case 'blocks': {\n          if (field.name in dataWithLocales) {\n            const newValue = dataWithLocales[field.name]\n            const existingValue = docWithLocales[field.name]\n\n            if (fieldIsLocalized) {\n              // If localized, handle locale keys\n              if (newValue && typeof newValue === 'object' && !Array.isArray(newValue)) {\n                const updatedData: Record<string, unknown> = { ...(existingValue || {}) }\n\n                for (const locale of selectedLocales) {\n                  if (locale in newValue) {\n                    updatedData[locale] = newValue[locale]\n                  }\n                }\n\n                result[field.name] = updatedData\n              } else {\n                // Preserve existing value if new value is not a valid object\n                result[field.name] = existingValue\n              }\n            } else if (Array.isArray(newValue)) {\n              // Non-localized blocks - still process children for any localized fields\n              result[field.name] = newValue.map((newBlockData: JsonObject, index: number) => {\n                let block: Block | FlattenedBlock | undefined\n                if (configBlockReferences && field.blockReferences) {\n                  for (const blockOrReference of field.blockReferences) {\n                    if (typeof blockOrReference === 'string') {\n                      block = configBlockReferences.find((b) => b.slug === newBlockData.blockType)\n                    } else {\n                      block = blockOrReference\n                    }\n                  }\n                } else if (field.blocks) {\n                  block = field.blocks.find((b) => b.slug === newBlockData.blockType)\n                }\n\n                if (block) {\n                  const blockData =\n                    Array.isArray(existingValue) && existingValue[index]\n                      ? (existingValue[index] as JsonObject)\n                      : {}\n\n                  const merged = mergeLocalizedData({\n                    configBlockReferences,\n                    dataWithLocales: newBlockData,\n                    docWithLocales: blockData,\n                    fields: block?.fields || [],\n                    parentIsLocalized,\n                    selectedLocales,\n                  })\n\n                  // blockType, id, blockName are set by Payload internally\n                  // and not part of block.fields, so they must be preserved explicitly\n                  merged.blockType = newBlockData.blockType\n                  merged.id = newBlockData.id\n                  merged.blockName = newBlockData.blockName\n\n                  return merged\n                }\n\n                return newBlockData\n              })\n            }\n          }\n          break\n        }\n\n        case 'group': {\n          if (fieldAffectsData(field) && field.name) {\n            // Named groups create a nested data structure\n            if (field.name in dataWithLocales) {\n              const newValue = dataWithLocales[field.name]\n              const existingValue = docWithLocales[field.name]\n\n              if (fieldIsLocalized) {\n                if (newValue && typeof newValue === 'object' && !Array.isArray(newValue)) {\n                  const groupData: Record<string, unknown> = { ...(existingValue || {}) }\n\n                  for (const locale of selectedLocales) {\n                    if (locale in newValue && typeof newValue[locale] === 'object') {\n                      groupData[locale] = newValue[locale]\n                    }\n                  }\n\n                  result[field.name] = groupData\n                } else {\n                  // Preserve existing value if new value is not a valid object\n                  result[field.name] = existingValue\n                }\n              } else if (typeof newValue === 'object' && !Array.isArray(newValue)) {\n                // Non-localized group - still process children for any localized fields\n                result[field.name] = mergeLocalizedData({\n                  configBlockReferences,\n                  dataWithLocales: newValue,\n                  docWithLocales: existingValue || {},\n                  fields: field.fields,\n                  parentIsLocalized,\n                  selectedLocales,\n                })\n              }\n            }\n          }\n          break\n        }\n\n        default: {\n          // For all other data-affecting fields (text, number, select, etc.)\n          if (fieldIsLocalized) {\n            if (field.name in dataWithLocales) {\n              const newValue = dataWithLocales[field.name]\n              const existingValue = docWithLocales[field.name] || {}\n\n              // If localized, handle locale keys\n              if (newValue && typeof newValue === 'object' && !Array.isArray(newValue)) {\n                const merged: Record<string, unknown> = { ...existingValue }\n\n                for (const locale of selectedLocales) {\n                  if (locale in newValue) {\n                    merged[locale] = newValue[locale]\n                  }\n                }\n\n                result[field.name] = merged\n              } else if (parentIsLocalized) {\n                // Child of localized parent - replace with new value\n                result[field.name] = newValue\n              } else {\n                // Preserve existing value if new value is not a valid object\n                result[field.name] = existingValue\n              }\n            }\n          } else if (parentIsLocalized) {\n            result[field.name] = dataWithLocales[field.name]\n          } else {\n            result[field.name] =\n              field.name in dataWithLocales\n                ? dataWithLocales[field.name]\n                : docWithLocales[field.name]\n          }\n          break\n        }\n      }\n    } else {\n      // Layout-only fields that don't affect data structure\n      switch (field.type) {\n        case 'collapsible':\n        case 'group':\n        case 'row': {\n          // These pass through the same data level\n          const merged = mergeLocalizedData({\n            configBlockReferences,\n            dataWithLocales,\n            docWithLocales,\n            fields: field.fields,\n            parentIsLocalized,\n            selectedLocales,\n          })\n          // Only copy fields that belong to this layout field to avoid overwriting already-processed fields\n          const fieldNames = collectFlattenedFieldNames(field.fields)\n          for (const name of fieldNames) {\n            if (name in merged) {\n              result[name] = merged[name]\n            }\n          }\n          break\n        }\n\n        case 'tabs': {\n          for (const tab of field.tabs) {\n            if (tabHasName(tab)) {\n              // Named tabs create a nested data structure and can be localized\n              const tabIsLocalized = fieldShouldBeLocalized({ field: tab, parentIsLocalized })\n\n              if (tab.name in dataWithLocales) {\n                const newValue = dataWithLocales[tab.name]\n                const existingValue = docWithLocales[tab.name]\n\n                if (tabIsLocalized) {\n                  if (newValue && typeof newValue === 'object' && !Array.isArray(newValue)) {\n                    const merged: Record<string, unknown> = { ...(existingValue || {}) }\n\n                    for (const locale of selectedLocales) {\n                      if (locale in newValue && typeof newValue[locale] === 'object') {\n                        merged[locale] = newValue[locale]\n                      }\n                    }\n\n                    result[tab.name] = merged\n                  } else {\n                    // Preserve existing value if new value is not a valid object\n                    result[tab.name] = existingValue\n                  }\n                } else if (typeof newValue === 'object' && !Array.isArray(newValue)) {\n                  // Non-localized tab - still process children for any localized fields\n                  result[tab.name] = mergeLocalizedData({\n                    configBlockReferences,\n                    dataWithLocales: newValue as JsonObject,\n                    docWithLocales: existingValue || {},\n                    fields: tab.fields,\n                    parentIsLocalized,\n                    selectedLocales,\n                  })\n                }\n              }\n            } else {\n              // Unnamed tabs pass through the same data level\n              const merged = mergeLocalizedData({\n                configBlockReferences,\n                dataWithLocales,\n                docWithLocales,\n                fields: tab.fields,\n                parentIsLocalized,\n                selectedLocales,\n              })\n              // Only copy fields that belong to this tab to avoid overwriting already-processed fields\n              const tabFieldNames = collectFlattenedFieldNames(tab.fields)\n              for (const name of tabFieldNames) {\n                if (name in merged) {\n                  result[name] = merged[name]\n                }\n              }\n            }\n          }\n          break\n        }\n      }\n    }\n  }\n\n  return result\n}\n"],"names":["fieldAffectsData","fieldShouldBeLocalized","tabHasName","collectFlattenedFieldNames","fields","names","Set","field","add","name","Array","isArray","type","tab","tabs","mergeLocalizedData","configBlockReferences","dataWithLocales","docWithLocales","parentIsLocalized","selectedLocales","result","fieldIsLocalized","newValue","existingValue","updatedArray","locale","map","newItem","index","existingItem","updatedData","newBlockData","block","blockReferences","blockOrReference","find","b","slug","blockType","blocks","blockData","merged","id","blockName","groupData","fieldNames","tabIsLocalized","tabFieldNames"],"mappings":"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"}