@ruya.sa/plugin-import-export 3.71.3

package/dist/utilities/parseJSON.d.ts

@@ -0,0 +1,11 @@
+import type { PayloadRequest } from '@ruya.sa/payload';
+export type ParseJSONArgs = {
+    data: Buffer | string;
+    req: PayloadRequest;
+};
+/**
+ * Parses JSON data into an array of record objects.
+ * Validates that the input is an array of documents.
+ */
+export declare const parseJSON: ({ data, req }: ParseJSONArgs) => Record<string, unknown>[];
+//# sourceMappingURL=parseJSON.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parseJSON.d.ts","sourceRoot":"","sources":["../../src/utilities/parseJSON.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAItD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IACrB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,kBAAmB,aAAa,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAiB/E,CAAA"}

package/dist/utilities/parseJSON.js

@@ -0,0 +1,25 @@
+import { APIError } from '@ruya.sa/payload';
+/**
+ * Parses JSON data into an array of record objects.
+ * Validates that the input is an array of documents.
+ */ export const parseJSON = ({ data, req })=>{
+    try {
+        const content = typeof data === 'string' ? data : data.toString('utf-8');
+        const parsed = JSON.parse(content);
+        if (!Array.isArray(parsed)) {
+            throw new APIError('JSON import data must be an array of documents');
+        }
+        return parsed;
+    } catch (err) {
+        req.payload.logger.error({
+            err,
+            msg: 'Error parsing JSON'
+        });
+        if (err instanceof APIError) {
+            throw err;
+        }
+        throw new APIError('Invalid JSON format');
+    }
+};
+
+//# sourceMappingURL=parseJSON.js.map

package/dist/utilities/parseJSON.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/parseJSON.ts"],"sourcesContent":["import type { PayloadRequest } from '@ruya.sa/payload'\n\nimport { APIError } from '@ruya.sa/payload'\n\nexport type ParseJSONArgs = {\n  data: Buffer | string\n  req: PayloadRequest\n}\n\n/**\n * Parses JSON data into an array of record objects.\n * Validates that the input is an array of documents.\n */\nexport const parseJSON = ({ data, req }: ParseJSONArgs): Record<string, unknown>[] => {\n  try {\n    const content = typeof data === 'string' ? data : data.toString('utf-8')\n    const parsed = JSON.parse(content)\n\n    if (!Array.isArray(parsed)) {\n      throw new APIError('JSON import data must be an array of documents')\n    }\n\n    return parsed\n  } catch (err) {\n    req.payload.logger.error({ err, msg: 'Error parsing JSON' })\n    if (err instanceof APIError) {\n      throw err\n    }\n    throw new APIError('Invalid JSON format')\n  }\n}\n"],"names":["APIError","parseJSON","data","req","content","toString","parsed","JSON","parse","Array","isArray","err","payload","logger","error","msg"],"mappings":"AAEA,SAASA,QAAQ,QAAQ,mBAAkB;AAO3C;;;CAGC,GACD,OAAO,MAAMC,YAAY,CAAC,EAAEC,IAAI,EAAEC,GAAG,EAAiB;IACpD,IAAI;QACF,MAAMC,UAAU,OAAOF,SAAS,WAAWA,OAAOA,KAAKG,QAAQ,CAAC;QAChE,MAAMC,SAASC,KAAKC,KAAK,CAACJ;QAE1B,IAAI,CAACK,MAAMC,OAAO,CAACJ,SAAS;YAC1B,MAAM,IAAIN,SAAS;QACrB;QAEA,OAAOM;IACT,EAAE,OAAOK,KAAK;QACZR,IAAIS,OAAO,CAACC,MAAM,CAACC,KAAK,CAAC;YAAEH;YAAKI,KAAK;QAAqB;QAC1D,IAAIJ,eAAeX,UAAU;YAC3B,MAAMW;QACR;QACA,MAAM,IAAIX,SAAS;IACrB;AACF,EAAC"}

package/dist/utilities/processRichTextField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Process rich text fields to ensure proper data types for Lexical editor.
+ * Lexical expects certain properties to be numbers, not strings.
+ */
+export declare const processRichTextField: (value: unknown) => unknown;
+//# sourceMappingURL=processRichTextField.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"processRichTextField.d.ts","sourceRoot":"","sources":["../../src/utilities/processRichTextField.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,oBAAoB,UAAW,OAAO,KAAG,OA4CrD,CAAA"}

package/dist/utilities/processRichTextField.js

@@ -0,0 +1,45 @@
+/**
+ * Process rich text fields to ensure proper data types for Lexical editor.
+ * Lexical expects certain properties to be numbers, not strings.
+ */ export const processRichTextField = (value)=>{
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    // Properties that should be numbers in Lexical
+    const numericProperties = [
+        'detail',
+        'format',
+        'indent',
+        'version',
+        'value',
+        'start',
+        'textFormat',
+        'textStyle'
+    ];
+    const processNode = (node)=>{
+        if (!node || typeof node !== 'object') {
+            return node;
+        }
+        // Process current node's properties
+        const processed = {};
+        for (const [key, val] of Object.entries(node)){
+            if (numericProperties.includes(key) && typeof val === 'string') {
+                // Convert string numbers to actual numbers
+                const num = parseFloat(val);
+                processed[key] = isNaN(num) ? val : num;
+            } else if (key === 'children' && Array.isArray(val)) {
+                // Recursively process children
+                processed[key] = val.map((child)=>processNode(child));
+            } else if (typeof val === 'object' && val !== null) {
+                // Recursively process nested objects
+                processed[key] = processNode(val);
+            } else {
+                processed[key] = val;
+            }
+        }
+        return processed;
+    };
+    return processNode(value);
+};
+
+//# sourceMappingURL=processRichTextField.js.map

package/dist/utilities/processRichTextField.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/processRichTextField.ts"],"sourcesContent":["/**\n * Process rich text fields to ensure proper data types for Lexical editor.\n * Lexical expects certain properties to be numbers, not strings.\n */\nexport const processRichTextField = (value: unknown): unknown => {\n  if (!value || typeof value !== 'object') {\n    return value\n  }\n\n  // Properties that should be numbers in Lexical\n  const numericProperties = [\n    'detail',\n    'format',\n    'indent',\n    'version',\n    'value',\n    'start',\n    'textFormat',\n    'textStyle',\n  ]\n\n  const processNode = (node: any): any => {\n    if (!node || typeof node !== 'object') {\n      return node\n    }\n\n    // Process current node's properties\n    const processed: any = {}\n    for (const [key, val] of Object.entries(node)) {\n      if (numericProperties.includes(key) && typeof val === 'string') {\n        // Convert string numbers to actual numbers\n        const num = parseFloat(val)\n        processed[key] = isNaN(num) ? val : num\n      } else if (key === 'children' && Array.isArray(val)) {\n        // Recursively process children\n        processed[key] = val.map((child) => processNode(child))\n      } else if (typeof val === 'object' && val !== null) {\n        // Recursively process nested objects\n        processed[key] = processNode(val)\n      } else {\n        processed[key] = val\n      }\n    }\n\n    return processed\n  }\n\n  return processNode(value)\n}\n"],"names":["processRichTextField","value","numericProperties","processNode","node","processed","key","val","Object","entries","includes","num","parseFloat","isNaN","Array","isArray","map","child"],"mappings":"AAAA;;;CAGC,GACD,OAAO,MAAMA,uBAAuB,CAACC;IACnC,IAAI,CAACA,SAAS,OAAOA,UAAU,UAAU;QACvC,OAAOA;IACT;IAEA,+CAA+C;IAC/C,MAAMC,oBAAoB;QACxB;QACA;QACA;QACA;QACA;QACA;QACA;QACA;KACD;IAED,MAAMC,cAAc,CAACC;QACnB,IAAI,CAACA,QAAQ,OAAOA,SAAS,UAAU;YACrC,OAAOA;QACT;QAEA,oCAAoC;QACpC,MAAMC,YAAiB,CAAC;QACxB,KAAK,MAAM,CAACC,KAAKC,IAAI,IAAIC,OAAOC,OAAO,CAACL,MAAO;YAC7C,IAAIF,kBAAkBQ,QAAQ,CAACJ,QAAQ,OAAOC,QAAQ,UAAU;gBAC9D,2CAA2C;gBAC3C,MAAMI,MAAMC,WAAWL;gBACvBF,SAAS,CAACC,IAAI,GAAGO,MAAMF,OAAOJ,MAAMI;YACtC,OAAO,IAAIL,QAAQ,cAAcQ,MAAMC,OAAO,CAACR,MAAM;gBACnD,+BAA+B;gBAC/BF,SAAS,CAACC,IAAI,GAAGC,IAAIS,GAAG,CAAC,CAACC,QAAUd,YAAYc;YAClD,OAAO,IAAI,OAAOV,QAAQ,YAAYA,QAAQ,MAAM;gBAClD,qCAAqC;gBACrCF,SAAS,CAACC,IAAI,GAAGH,YAAYI;YAC/B,OAAO;gBACLF,SAAS,CAACC,IAAI,GAAGC;YACnB;QACF;QAEA,OAAOF;IACT;IAEA,OAAOF,YAAYF;AACrB,EAAC"}

package/dist/utilities/removeDisabledFields.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Recursively removes fields from a deeply nested object based on dot-notation paths.
+ *
+ * This utility supports removing:
+ * - Nested fields in plain objects (e.g., "group.value")
+ * - Fields inside arrays of objects (e.g., "group.array.field1")
+ *
+ * It safely traverses both object and array structures and avoids mutating the original input.
+ *
+ * @param obj - The original object to clean.
+ * @param disabled - An array of dot-separated paths indicating which fields to remove.
+ * @returns A deep clone of the original object with specified fields removed.
+ */
+export declare const removeDisabledFields: (obj: Record<string, unknown>, disabled?: string[]) => Record<string, unknown>;
+//# sourceMappingURL=removeDisabledFields.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"removeDisabledFields.d.ts","sourceRoot":"","sources":["../../src/utilities/removeDisabledFields.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,oBAAoB,QAC1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAClB,MAAM,EAAE,KACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CA8DxB,CAAA"}

package/dist/utilities/removeDisabledFields.js

@@ -0,0 +1,66 @@
+/**
+ * Recursively removes fields from a deeply nested object based on dot-notation paths.
+ *
+ * This utility supports removing:
+ * - Nested fields in plain objects (e.g., "group.value")
+ * - Fields inside arrays of objects (e.g., "group.array.field1")
+ *
+ * It safely traverses both object and array structures and avoids mutating the original input.
+ *
+ * @param obj - The original object to clean.
+ * @param disabled - An array of dot-separated paths indicating which fields to remove.
+ * @returns A deep clone of the original object with specified fields removed.
+ */ export const removeDisabledFields = (obj, disabled = [])=>{
+    if (!disabled.length) {
+        return obj;
+    }
+    const clone = structuredClone(obj);
+    // Process each disabled path independently
+    for (const path of disabled){
+        const parts = path.split('.');
+        /**
+     * Recursively walks the object tree according to the dot path,
+     * and deletes the field once the full path is reached.
+     *
+     * @param target - The current object or array being traversed
+     * @param i - The index of the current path part
+     */ const removeRecursively = (target, i = 0)=>{
+            if (target == null) {
+                return;
+            }
+            const key = parts[i];
+            // If at the final part of the path, perform the deletion
+            if (i === parts.length - 1) {
+                // If the current level is an array, delete the key from each item
+                if (Array.isArray(target)) {
+                    for (const item of target){
+                        if (item && typeof item === 'object' && key !== undefined) {
+                            delete item[key];
+                        }
+                    }
+                } else if (typeof target === 'object' && key !== undefined) {
+                    delete target[key];
+                }
+                return;
+            }
+            if (key === undefined) {
+                return;
+            }
+            // Traverse to the next level in the path
+            const next = target[key];
+            if (Array.isArray(next)) {
+                // If the next value is an array, recurse into each item
+                for (const item of next){
+                    removeRecursively(item, i + 1);
+                }
+            } else {
+                // Otherwise, continue down the object path
+                removeRecursively(next, i + 1);
+            }
+        };
+        removeRecursively(clone);
+    }
+    return clone;
+};
+
+//# sourceMappingURL=removeDisabledFields.js.map

package/dist/utilities/removeDisabledFields.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/removeDisabledFields.ts"],"sourcesContent":["/**\n * Recursively removes fields from a deeply nested object based on dot-notation paths.\n *\n * This utility supports removing:\n * - Nested fields in plain objects (e.g., \"group.value\")\n * - Fields inside arrays of objects (e.g., \"group.array.field1\")\n *\n * It safely traverses both object and array structures and avoids mutating the original input.\n *\n * @param obj - The original object to clean.\n * @param disabled - An array of dot-separated paths indicating which fields to remove.\n * @returns A deep clone of the original object with specified fields removed.\n */\n\nexport const removeDisabledFields = (\n  obj: Record<string, unknown>,\n  disabled: string[] = [],\n): Record<string, unknown> => {\n  if (!disabled.length) {\n    return obj\n  }\n\n  const clone = structuredClone(obj)\n\n  // Process each disabled path independently\n  for (const path of disabled) {\n    const parts = path.split('.')\n\n    /**\n     * Recursively walks the object tree according to the dot path,\n     * and deletes the field once the full path is reached.\n     *\n     * @param target - The current object or array being traversed\n     * @param i - The index of the current path part\n     */\n    const removeRecursively = (target: any, i = 0): void => {\n      if (target == null) {\n        return\n      }\n\n      const key = parts[i]\n\n      // If at the final part of the path, perform the deletion\n      if (i === parts.length - 1) {\n        // If the current level is an array, delete the key from each item\n        if (Array.isArray(target)) {\n          for (const item of target) {\n            if (item && typeof item === 'object' && key !== undefined) {\n              delete item[key as keyof typeof item]\n            }\n          }\n        } else if (typeof target === 'object' && key !== undefined) {\n          delete target[key]\n        }\n        return\n      }\n\n      if (key === undefined) {\n        return\n      }\n\n      // Traverse to the next level in the path\n      const next = target[key]\n\n      if (Array.isArray(next)) {\n        // If the next value is an array, recurse into each item\n        for (const item of next) {\n          removeRecursively(item, i + 1)\n        }\n      } else {\n        // Otherwise, continue down the object path\n        removeRecursively(next, i + 1)\n      }\n    }\n\n    removeRecursively(clone)\n  }\n\n  return clone\n}\n"],"names":["removeDisabledFields","obj","disabled","length","clone","structuredClone","path","parts","split","removeRecursively","target","i","key","Array","isArray","item","undefined","next"],"mappings":"AAAA;;;;;;;;;;;;CAYC,GAED,OAAO,MAAMA,uBAAuB,CAClCC,KACAC,WAAqB,EAAE;IAEvB,IAAI,CAACA,SAASC,MAAM,EAAE;QACpB,OAAOF;IACT;IAEA,MAAMG,QAAQC,gBAAgBJ;IAE9B,2CAA2C;IAC3C,KAAK,MAAMK,QAAQJ,SAAU;QAC3B,MAAMK,QAAQD,KAAKE,KAAK,CAAC;QAEzB;;;;;;KAMC,GACD,MAAMC,oBAAoB,CAACC,QAAaC,IAAI,CAAC;YAC3C,IAAID,UAAU,MAAM;gBAClB;YACF;YAEA,MAAME,MAAML,KAAK,CAACI,EAAE;YAEpB,yDAAyD;YACzD,IAAIA,MAAMJ,MAAMJ,MAAM,GAAG,GAAG;gBAC1B,kEAAkE;gBAClE,IAAIU,MAAMC,OAAO,CAACJ,SAAS;oBACzB,KAAK,MAAMK,QAAQL,OAAQ;wBACzB,IAAIK,QAAQ,OAAOA,SAAS,YAAYH,QAAQI,WAAW;4BACzD,OAAOD,IAAI,CAACH,IAAyB;wBACvC;oBACF;gBACF,OAAO,IAAI,OAAOF,WAAW,YAAYE,QAAQI,WAAW;oBAC1D,OAAON,MAAM,CAACE,IAAI;gBACpB;gBACA;YACF;YAEA,IAAIA,QAAQI,WAAW;gBACrB;YACF;YAEA,yCAAyC;YACzC,MAAMC,OAAOP,MAAM,CAACE,IAAI;YAExB,IAAIC,MAAMC,OAAO,CAACG,OAAO;gBACvB,wDAAwD;gBACxD,KAAK,MAAMF,QAAQE,KAAM;oBACvBR,kBAAkBM,MAAMJ,IAAI;gBAC9B;YACF,OAAO;gBACL,2CAA2C;gBAC3CF,kBAAkBQ,MAAMN,IAAI;YAC9B;QACF;QAEAF,kBAAkBL;IACpB;IAEA,OAAOA;AACT,EAAC"}

package/dist/utilities/setNestedValue.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Sets a value deeply into a nested object or array, based on a dot-notation path.
+ *
+ * This function:
+ * - Supports array indexing (e.g., "array.0.field1")
+ * - Creates intermediate arrays/objects as needed
+ * - Mutates the target object directly
+ *
+ * @example
+ * const obj = {}
+ * setNestedValue(obj, 'group.array.0.field1', 'hello')
+ * // Result: { group: { array: [ { field1: 'hello' } ] } }
+ *
+ * @param obj - The target object to mutate.
+ * @param path - A dot-separated string path indicating where to assign the value.
+ * @param value - The value to set at the specified path.
+ */
+export declare const setNestedValue: (obj: Record<string, unknown>, path: string, value: unknown) => void;
+//# sourceMappingURL=setNestedValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setNestedValue.d.ts","sourceRoot":"","sources":["../../src/utilities/setNestedValue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,eAAO,MAAM,cAAc,QACpB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QACtB,MAAM,SACL,OAAO,KACb,IA0CF,CAAA"}

package/dist/utilities/setNestedValue.js

@@ -0,0 +1,55 @@
+/**
+ * Sets a value deeply into a nested object or array, based on a dot-notation path.
+ *
+ * This function:
+ * - Supports array indexing (e.g., "array.0.field1")
+ * - Creates intermediate arrays/objects as needed
+ * - Mutates the target object directly
+ *
+ * @example
+ * const obj = {}
+ * setNestedValue(obj, 'group.array.0.field1', 'hello')
+ * // Result: { group: { array: [ { field1: 'hello' } ] } }
+ *
+ * @param obj - The target object to mutate.
+ * @param path - A dot-separated string path indicating where to assign the value.
+ * @param value - The value to set at the specified path.
+ */ export const setNestedValue = (obj, path, value)=>{
+    const parts = path.split('.');
+    let current = obj;
+    for(let i = 0; i < parts.length; i++){
+        const part = parts[i];
+        const isLast = i === parts.length - 1;
+        const isIndex = !Number.isNaN(Number(part));
+        if (isIndex) {
+            const index = Number(part);
+            // Ensure the current target is an array
+            if (!Array.isArray(current)) {
+                current = [];
+            }
+            // Ensure the array slot is initialized
+            if (!current[index]) {
+                current[index] = {};
+            }
+            if (isLast) {
+                current[index] = value;
+            } else {
+                current = current[index];
+            }
+        } else {
+            // Ensure the object key exists
+            if (isLast) {
+                if (typeof part === 'string') {
+                    current[part] = value;
+                }
+            } else {
+                if (typeof current[part] !== 'object' || current[part] === null) {
+                    current[part] = {};
+                }
+                current = current[part];
+            }
+        }
+    }
+};
+
+//# sourceMappingURL=setNestedValue.js.map

package/dist/utilities/setNestedValue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/setNestedValue.ts"],"sourcesContent":["/**\n * Sets a value deeply into a nested object or array, based on a dot-notation path.\n *\n * This function:\n * - Supports array indexing (e.g., \"array.0.field1\")\n * - Creates intermediate arrays/objects as needed\n * - Mutates the target object directly\n *\n * @example\n * const obj = {}\n * setNestedValue(obj, 'group.array.0.field1', 'hello')\n * // Result: { group: { array: [ { field1: 'hello' } ] } }\n *\n * @param obj - The target object to mutate.\n * @param path - A dot-separated string path indicating where to assign the value.\n * @param value - The value to set at the specified path.\n */\n\nexport const setNestedValue = (\n  obj: Record<string, unknown>,\n  path: string,\n  value: unknown,\n): void => {\n  const parts = path.split('.')\n  let current: any = obj\n\n  for (let i = 0; i < parts.length; i++) {\n    const part = parts[i]\n    const isLast = i === parts.length - 1\n    const isIndex = !Number.isNaN(Number(part))\n\n    if (isIndex) {\n      const index = Number(part)\n\n      // Ensure the current target is an array\n      if (!Array.isArray(current)) {\n        current = []\n      }\n\n      // Ensure the array slot is initialized\n      if (!current[index]) {\n        current[index] = {}\n      }\n\n      if (isLast) {\n        current[index] = value\n      } else {\n        current = current[index] as Record<string, unknown>\n      }\n    } else {\n      // Ensure the object key exists\n      if (isLast) {\n        if (typeof part === 'string') {\n          current[part] = value\n        }\n      } else {\n        if (typeof current[part as string] !== 'object' || current[part as string] === null) {\n          current[part as string] = {}\n        }\n\n        current = current[part as string] as Record<string, unknown>\n      }\n    }\n  }\n}\n"],"names":["setNestedValue","obj","path","value","parts","split","current","i","length","part","isLast","isIndex","Number","isNaN","index","Array","isArray"],"mappings":"AAAA;;;;;;;;;;;;;;;;CAgBC,GAED,OAAO,MAAMA,iBAAiB,CAC5BC,KACAC,MACAC;IAEA,MAAMC,QAAQF,KAAKG,KAAK,CAAC;IACzB,IAAIC,UAAeL;IAEnB,IAAK,IAAIM,IAAI,GAAGA,IAAIH,MAAMI,MAAM,EAAED,IAAK;QACrC,MAAME,OAAOL,KAAK,CAACG,EAAE;QACrB,MAAMG,SAASH,MAAMH,MAAMI,MAAM,GAAG;QACpC,MAAMG,UAAU,CAACC,OAAOC,KAAK,CAACD,OAAOH;QAErC,IAAIE,SAAS;YACX,MAAMG,QAAQF,OAAOH;YAErB,wCAAwC;YACxC,IAAI,CAACM,MAAMC,OAAO,CAACV,UAAU;gBAC3BA,UAAU,EAAE;YACd;YAEA,uCAAuC;YACvC,IAAI,CAACA,OAAO,CAACQ,MAAM,EAAE;gBACnBR,OAAO,CAACQ,MAAM,GAAG,CAAC;YACpB;YAEA,IAAIJ,QAAQ;gBACVJ,OAAO,CAACQ,MAAM,GAAGX;YACnB,OAAO;gBACLG,UAAUA,OAAO,CAACQ,MAAM;YAC1B;QACF,OAAO;YACL,+BAA+B;YAC/B,IAAIJ,QAAQ;gBACV,IAAI,OAAOD,SAAS,UAAU;oBAC5BH,OAAO,CAACG,KAAK,GAAGN;gBAClB;YACF,OAAO;gBACL,IAAI,OAAOG,OAAO,CAACG,KAAe,KAAK,YAAYH,OAAO,CAACG,KAAe,KAAK,MAAM;oBACnFH,OAAO,CAACG,KAAe,GAAG,CAAC;gBAC7B;gBAEAH,UAAUA,OAAO,CAACG,KAAe;YACnC;QACF;IACF;AACF,EAAC"}

package/dist/utilities/sortHelpers.d.ts

@@ -0,0 +1,6 @@
+/** Remove a leading '-' from a sort value (e.g. "-title" -> "title") */
+export declare const stripSortDash: (v?: null | string) => string;
+/** Apply order to a base field (("title","desc") -> "-title") */
+export declare const applySortOrder: (field: string, order: "asc" | "desc") => string;
+export declare const normalizeQueryParam: (v: unknown) => string | undefined;
+//# sourceMappingURL=sortHelpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sortHelpers.d.ts","sourceRoot":"","sources":["../../src/utilities/sortHelpers.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,eAAO,MAAM,aAAa,OAAQ,IAAI,GAAG,MAAM,KAAG,MAAwC,CAAA;AAE1F,iEAAiE;AACjE,eAAO,MAAM,cAAc,UAAW,MAAM,SAAS,KAAK,GAAG,MAAM,KAAG,MAC9B,CAAA;AAGxC,eAAO,MAAM,mBAAmB,MAAO,OAAO,KAAG,MAAM,GAAG,SAQzD,CAAA"}

package/dist/utilities/sortHelpers.js

@@ -0,0 +1,14 @@
+/** Remove a leading '-' from a sort value (e.g. "-title" -> "title") */ export const stripSortDash = (v)=>v ? v.replace(/^-/, '') : '';
+/** Apply order to a base field (("title","desc") -> "-title") */ export const applySortOrder = (field, order)=>order === 'desc' ? `-${field}` : field;
+// Safely coerce query.sort / query.groupBy to a string (ignore arrays)
+export const normalizeQueryParam = (v)=>{
+    if (typeof v === 'string') {
+        return v;
+    }
+    if (Array.isArray(v) && typeof v[0] === 'string') {
+        return v[0];
+    }
+    return undefined;
+};
+
+//# sourceMappingURL=sortHelpers.js.map

package/dist/utilities/sortHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/sortHelpers.ts"],"sourcesContent":["/** Remove a leading '-' from a sort value (e.g. \"-title\" -> \"title\") */\nexport const stripSortDash = (v?: null | string): string => (v ? v.replace(/^-/, '') : '')\n\n/** Apply order to a base field ((\"title\",\"desc\") -> \"-title\") */\nexport const applySortOrder = (field: string, order: 'asc' | 'desc'): string =>\n  order === 'desc' ? `-${field}` : field\n\n// Safely coerce query.sort / query.groupBy to a string (ignore arrays)\nexport const normalizeQueryParam = (v: unknown): string | undefined => {\n  if (typeof v === 'string') {\n    return v\n  }\n  if (Array.isArray(v) && typeof v[0] === 'string') {\n    return v[0]\n  }\n  return undefined\n}\n"],"names":["stripSortDash","v","replace","applySortOrder","field","order","normalizeQueryParam","Array","isArray","undefined"],"mappings":"AAAA,sEAAsE,GACtE,OAAO,MAAMA,gBAAgB,CAACC,IAA+BA,IAAIA,EAAEC,OAAO,CAAC,MAAM,MAAM,GAAG;AAE1F,+DAA+D,GAC/D,OAAO,MAAMC,iBAAiB,CAACC,OAAeC,QAC5CA,UAAU,SAAS,CAAC,CAAC,EAAED,OAAO,GAAGA,MAAK;AAExC,uEAAuE;AACvE,OAAO,MAAME,sBAAsB,CAACL;IAClC,IAAI,OAAOA,MAAM,UAAU;QACzB,OAAOA;IACT;IACA,IAAIM,MAAMC,OAAO,CAACP,MAAM,OAAOA,CAAC,CAAC,EAAE,KAAK,UAAU;QAChD,OAAOA,CAAC,CAAC,EAAE;IACb;IACA,OAAOQ;AACT,EAAC"}

package/dist/utilities/unflattenObject.d.ts

@@ -0,0 +1,11 @@
+import type { FlattenedField, PayloadRequest } from '@ruya.sa/payload';
+import type { FromCSVFunction } from '../types.js';
+type UnflattenArgs = {
+    data: Record<string, unknown>;
+    fields: FlattenedField[];
+    fromCSVFunctions?: Record<string, FromCSVFunction>;
+    req: PayloadRequest;
+};
+export declare const unflattenObject: ({ data, fields, fromCSVFunctions, req, }: UnflattenArgs) => Record<string, unknown>;
+export {};
+//# sourceMappingURL=unflattenObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unflattenObject.d.ts","sourceRoot":"","sources":["../../src/utilities/unflattenObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAIlD,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAClD,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,eAAO,MAAM,eAAe,6CAKzB,aAAa,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CA0TxC,CAAA"}