{"version":3,"file":"toStringArrayUnRecursive-CWupSHrG.cjs","names":["isNil","isArray","isEmptyArray","isPlainObject","createMessage","isArray","isString","isFinite","isBoolean","isBigInt","isNull"],"sources":["../src/conversions/arrays/transforms/filterNilArray.ts","../src/conversions/arrays/casts/toStringArrayUnRecursive.ts"],"sourcesContent":["import type {\n  FilterNilArray,\n  FilterNilArrayFromTuple,\n  PreserveMutability\n} from \"./_private/filterNilArray.types\";\n\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isEmptyArray } from \"@/predicates/is/isEmptyArray\";\n\n/** ------------------------------------------------------------------------------------\n * * ***Utility: `filterNilArray`.***\n * -------------------------------------------------------------------------------------\n * **Removes `null` and `undefined` values from an array, including nested arrays.**\n *\n * ---\n * - **Behavior:**\n *     - Returns `undefined` if the input is explicitly `undefined` or `null`.\n *     - Returns `[]` if input is empty or all elements are removed after filtering.\n *     - Recursively filters nested arrays while preserving structure.\n *     - Ensures proper type inference for safer downstream operations.\n *\n * ---\n * @template A - The type of elements in the array.\n * @param {T[]|null|undefined} input - The array to be filtered.\n * @returns {T[] | undefined} A new array with `null` and `undefined` values removed,\n *                            or `undefined` if the input is explicitly `undefined`\n *                            or `null`.\n *\n * ---\n * @example\n * ```ts\n * filterNilArray([1, null, 2, undefined, 3]);\n * // ➔ [1, 2, 3]\n * filterNilArray([null, undefined]);\n * // ➔ []\n * filterNilArray(undefined);\n * // ➔ undefined\n * filterNilArray(null);\n * // ➔ undefined\n * filterNilArray([]);\n * // ➔ []\n * filterNilArray([[[]]]);\n * // ➔ []\n * filterNilArray([[[],undefined,null]]);\n * // ➔ []\n * filterNilArray([1, [null, 2, [undefined, 3]]]);\n * // ➔ [1, [2, [3]]]\n * ```\n */\nexport function filterNilArray(input: null | undefined): undefined;\nexport function filterNilArray<A extends readonly unknown[]>(\n  input: A\n): PreserveMutability<A, FilterNilArrayFromTuple<A>>;\nexport function filterNilArray<A extends readonly unknown[]>(\n  input: A | null | undefined\n): PreserveMutability<A, FilterNilArrayFromTuple<A>> | undefined;\nexport function filterNilArray<A>(\n  input: (A | null | undefined)[] | null | undefined\n): FilterNilArray<A> | undefined;\nexport function filterNilArray(\n  input: readonly unknown[] | null | undefined\n): unknown[] | undefined;\nexport function filterNilArray(input: unknown[]): unknown[];\nexport function filterNilArray(input: unknown): unknown {\n  if (isNil(input)) return undefined;\n  if (!isArray(input)) return [];\n\n  const filtered = input.reduce<unknown[]>((output, element) => {\n    if (!isNil(element)) {\n      if (isArray(element)) {\n        const cleanedNested = filterNilArray(element);\n        if (cleanedNested && !isEmptyArray(cleanedNested)) {\n          output.push(cleanedNested);\n        }\n      } else {\n        output.push(element);\n      }\n    }\n    return output;\n  }, []);\n\n  return filtered;\n}\n","import type {\n  ToStringArrayUnRecursiveOptions,\n  ToStringArrayUnRecursiveReturn\n} from \"./toStringArrayUnRecursive.types\";\n\nimport { createMessage } from \"@/_private/logger\";\n\nimport { isNull } from \"@/predicates/is/isNull\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isFinite } from \"@/predicates/is/isFinite\";\nimport { isBigInt } from \"@/predicates/is/isBigInt\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\n\nimport { filterNilArray } from \"../transforms/filterNilArray\";\n\n/** ------------------------------------------------------------------------------------------------\n * * ***Utility: `toStringArrayUnRecursive`.***\n * -------------------------------------------------------------------------------------------------\n * **Converts all values in a flat array into string representations.**\n *\n * ---\n * - **Behavior:**\n *     - Only processes **flat arrays** (non-recursive).\n *     - Supports input values: `string`, `number`, `bigint`, `boolean`,\n *       `null`, `undefined`.\n *     - Invalid values (`null` and `undefined`) can be **removed** or **kept**\n *       depending on the option.\n *     - Other unsupported types will be converted to `undefined` (and removed\n *       if `removeInvalidValue=true`).\n *\n * ---\n * - **Note:**\n *     - _For recursive / nested arrays, use ***`toStringDeep` utility function*** instead._\n *\n * ---\n * @template T - Element type of the input array.\n * @template R - Whether invalid values should be removed (`true`) or kept (`false`).\n *\n * ---\n * @param {Array<string | number | bigint | boolean | null | undefined> | null | undefined} [array]\n *         The array to convert, returns `undefined` if not an array.\n * @param {ToStringArrayUnRecursiveOptions<RemoveInvalidValue>} [options]\n *         Options to control transformation behavior, defaults to `{ removeInvalidValue: true }`.\n * @param {RemoveInvalidValue extends true ? boolean : boolean} [options.removeInvalidValue=true]\n *         Whether to remove invalid values (`null`, `undefined`, or unsupported types),\n *         default: `true`.\n *\n * ---\n * @returns {RemoveInvalidValue extends true ? string[] : (string | null | undefined)[]}\n *         A new array of string representations, with invalid values optionally removed.\n *\n * ---\n * @example\n * 1. #### Convert numbers and strings:\n *    ```ts\n *    toStringArrayUnRecursive([\n *      1,\n *      2,\n *      \"3\"\n *    ]);\n *    // ➔ [\"1\", \"2\", \"3\"]\n *    ```\n *    ---\n * 2. #### Remove null and undefined values:\n *    ```ts\n *    toStringArrayUnRecursive(\n *      [\n *        1,\n *        null,\n *        undefined,\n *        \"abc\"\n *      ],\n *      {\n *        removeInvalidValue: true\n *      }\n *    );\n *    // ➔ [\"1\", \"abc\"]\n *    ```\n *    ---\n * 3. #### Keep null and undefined values:\n *    ```ts\n *    toStringArrayUnRecursive(\n *      [\n *        1,\n *        null,\n *        undefined,\n *        \"abc\"\n *      ],\n *      {\n *        removeInvalidValue: false\n *      }\n *    );\n *    // ➔ [\"1\", null, undefined, \"abc\"]\n *    ```\n *    ---\n * 4. #### Convert booleans and bigint:\n *    ```ts\n *    toStringArrayUnRecursive([\n *      true,\n *      false,\n *      10n\n *    ]);\n *    // ➔ [\"true\", \"false\", \"10\"]\n *    ```\n *    ---\n * 5. #### Invalid non-array input:\n *    ```ts\n *    toStringArrayUnRecursive(null);\n *    // ➔ undefined\n *\n *    toStringArrayUnRecursive(undefined);\n *    // ➔ undefined\n *\n *    toStringArrayUnRecursive(1);\n *    // ➔ undefined\n *\n *    toStringArrayUnRecursive(\"string\");\n *    // ➔ undefined\n *    ```\n */\nexport function toStringArrayUnRecursive(\n  array?: undefined | null,\n  options?: ToStringArrayUnRecursiveOptions<boolean>\n): undefined;\nexport function toStringArrayUnRecursive(\n  array?: Array<never>,\n  options?: ToStringArrayUnRecursiveOptions<boolean>\n): [];\nexport function toStringArrayUnRecursive<T, R extends boolean = true>(\n  array?: Array<T> | readonly T[] | null,\n  options?: ToStringArrayUnRecursiveOptions<R>\n): ToStringArrayUnRecursiveReturn<T, R>;\nexport function toStringArrayUnRecursive<T = unknown>(\n  array?: T,\n  options?: ToStringArrayUnRecursiveOptions<boolean>\n): undefined;\nexport function toStringArrayUnRecursive<T>(\n  array?: Array<T> | readonly T[] | null,\n  options: ToStringArrayUnRecursiveOptions<boolean> = {}\n) {\n  if (!isPlainObject(options)) options = {};\n\n  const riv = options.removeInvalidValue ?? true;\n\n  assertIsBoolean(riv, {\n    message: ({ currentType, validType }) =>\n      createMessage(\n        \"toStringArrayUnRecursive\",\n        `Parameter \\`removeInvalidValue\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n      )\n  });\n\n  if (isArray(array)) {\n    // Convert each item in the array to a string, or null/undefined if it's not a valid value.\n    const result = Array.from(array, (x) => {\n      // Convert finite number, boolean, bigInt or string to string\n      if (isString(x) || isFinite(x) || isBoolean(x) || isBigInt(x))\n        return String(x);\n\n      // Handle null or undefined values\n      return isNull(x) ? null : undefined;\n    });\n\n    // Remove invalid values (null, undefined) if specified in options\n    if (riv) return filterNilArray(result);\n\n    return result;\n  }\n\n  // Return undefined if no array is provided\n  return undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgEA,SAAgB,eAAe,OAAyB;CACtD,IAAIA,qBAAM,KAAK,GAAG,OAAO;CACzB,IAAI,CAACC,uBAAQ,KAAK,GAAG,OAAO,CAAC;CAgB7B,OAdiB,MAAM,QAAmB,QAAQ,YAAY;EAC5D,IAAI,CAACD,qBAAM,OAAO,GAChB,IAAIC,uBAAQ,OAAO,GAAG;GACpB,MAAM,gBAAgB,eAAe,OAAO;GAC5C,IAAI,iBAAiB,CAACC,kCAAa,aAAa,GAC9C,OAAO,KAAK,aAAa;EAE7B,OACE,OAAO,KAAK,OAAO;EAGvB,OAAO;CACT,GAAG,CAAC,CAEU;AAChB;;;;ACwDA,SAAgB,yBACd,OACA,UAAoD,CAAC,GACrD;CACA,IAAI,CAACC,6BAAc,OAAO,GAAG,UAAU,CAAC;CAExC,MAAM,MAAM,QAAQ,sBAAsB;CAE1C,+BAAgB,KAAK,EACnB,UAAU,EAAE,aAAa,gBACvBC,6BACE,4BACA,qGAAqG,UAAU,sBAAsB,YAAY,IACnJ,EACJ,CAAC;CAED,IAAIC,uBAAQ,KAAK,GAAG;EAElB,MAAM,SAAS,MAAM,KAAK,QAAQ,MAAM;GAEtC,IAAIC,wBAAS,CAAC,KAAKC,0BAAS,CAAC,KAAKC,yBAAU,CAAC,KAAKC,0BAAS,CAAC,GAC1D,OAAO,OAAO,CAAC;GAGjB,OAAOC,sBAAO,CAAC,IAAI,OAAO;EAC5B,CAAC;EAGD,IAAI,KAAK,OAAO,eAAe,MAAM;EAErC,OAAO;CACT;AAIF"}