@rzl-zone/utils-js 3.4.0 → 3.5.0

package/README.md

@@ -70,6 +70,13 @@
   - ✅ Node.js (18.17.0, or higher depending on NextJS version) - With NextJS
   - ✅ Modern browsers (via bundlers like Webpack / Vite)
 
+- **TypeScript Build Info:**
+  - Target: `ES2022`
+  - Module: `ES2022`
+  - Module Resolution: `bundler`
+
+  > ℹ️ Note: These TypeScript settings are used to build the package. Consumers do **not** need to match these settings unless they plan to build or modify the source code.
+
 ---
 
 <h2 id="installation">⚙️ <strong>Installation</strong></h2>
@@ -101,8 +108,6 @@
 - 📦 Works in **Node.js** & modern browsers
 - ❤️ Simple API, easy to extend
 - 🧬 **Next.js support**: helpers for dynamic routes, building URLs, reading env, extracting client IP
-- 🛠 Additional including TypeScript package **`@rzl-zone/ts-types-plus`** types: `OmitStrict`, `PartialOnly`, etc.
-
 ---
 
 <h2 id="nextjs-support">🧬 <strong>Next.js Support</strong></h2>
@@ -146,42 +151,95 @@
   import { | } from "@rzl-zone/utils-js/promises";
   import { | } from "@rzl-zone/utils-js/strings";
   import { | } from "@rzl-zone/utils-js/tailwind";
-  import { | } from "@rzl-zone/utils-js/urls";
-
-  import type { | } from "@rzl-zone/ts-types-plus";
+  import { | } from "@rzl-zone/utils-js/urls"; 
   ```
   #### Place your cursor inside { } or after "@rzl-zone/utils-js/{{ | }}" then press Ctrl+Space to see all available functions/types with full TSDoc hints.
-  ---
-  ### **Hint: Autocomplete**
-
-  **To get the best autocomplete hints for folders and files, add the `types` field in your configuration file:**
-
-  #### # **_TypeScript_**:
-  Add this to your `tsconfig.json`:
-  ```jsonc
-  // tsconfig.json
-  {
-    "compilerOptions": {
-      "types": [
-        "@rzl-zone/utils-js"
-      ]
-    }
-  }
 
-  ```
-  #### # **_JavaScript_:**
-  Add this to your `jsconfig.json`:
-  ```jsonc
-  // jsconfig.json
-  {
-    "compilerOptions": {
-      "types": [
-        "@rzl-zone/utils-js"
-      ]
-    }
-  }
-  ```
-  >ℹ️ ***Tip:*** *For JS projects, consider adding "checkJs": true for better IntelliSense.*
+  > ***⚠️ Note:*** Starting from version `3.4.0+`, the extra TypeScript types (e.g., `OmitStrict`, `PartialOnly`, etc), have been removed from the package. To use them, you now need to install **[`@rzl-zone/ts-types-plus`](https://www.npmjs.com/package/@rzl-zone/ts-types-plus)** separately.
+
+  ---
+  ### **Hint: Autocomplete Setup (Step by Step)**
+
+  #### Make TypeScript & VSCode automatically provide autocomplete for `@rzl-zone/utils-js` without needing triple-slash references in every file:
+
+  - 1️⃣ **Install @rzl-zone/utils-js.**
+
+    - Make sure the package is installed:
+
+      ```bash
+      npm install @rzl-zone/utils-js
+      # or
+      yarn add @rzl-zone/utils-js
+      # or
+      pnpm add @rzl-zone/utils-js
+      ```
+
+  - 2️⃣ **Create a types folder.**
+
+    - Inside your project root, make a folder called `types`:
+
+      ```pgsql
+      project-root/
+        ├─ src/
+        ├─ types/
+        │  └─ index.d.ts
+        ├─ tsconfig.json
+        └─ jsconfig.json
+      ```
+
+  - 3️⃣ **Add the global reference file.**
+
+    - Create `types/index.d.ts` with this content:
+
+      ```ts
+      /// <reference types="@rzl-zone/utils-js" />
+      ``` 
+
+      - This tells TypeScript to include the types from `@rzl-zone/utils-js` globally.
+      - You can add more references here if needed, for example:
+
+      ```ts
+      /// <reference types="node" />
+      /// <reference types="@rzl-zone/utils-js" />
+      ``` 
+
+  - 4️⃣ **Update tsconfig.json.**
+
+    - Make sure not to override "types" (or leave it empty) so TypeScript automatically picks up your types folder:
+
+      ```jsonc
+      // tsconfig.json
+      {
+        "compilerOptions": { 
+          "typeRoots": ["./types", "./node_modules/@types"],
+          // other your config...
+        },
+        "include": ["src", "types"],
+        // other your config...
+      }
+      ```
+      - `typeRoots` tells TS where to look for global type definitions.
+      - The `types` folder comes first, so your references override or add to the default `@types` packages
+
+  - 5️⃣ **Update jsconfig.json (for JavaScript projects).**
+
+    - If you also work with JS, do the same:
+
+      ```jsonc
+      // jsconfig.json
+      {
+        "compilerOptions": {
+          "checkJs": true,  // Optional, enables type checking 
+          "typeRoots": ["./types", "./node_modules/@types"],
+          // other your config...
+        },
+        "include": ["src", "types"],
+        // other your config...
+      }
+      ```
+      >ℹ️ ***Tip:*** *For JS projects, consider adding "checkJs": true for better IntelliSense.*
+    
+  **Now, all types from @rzl-zone/utils-js are globally available, and you don’t need "types": ["@rzl-zone/utils-js"] in tsconfig.json.** 
 
   <!-- - <h4 id="detailed-features--assertions">
       Assertions - 
@@ -219,21 +277,12 @@ console.log(isServer());
 // ➔ `true` if running on server-side, `false` if in browser.
 ```
 
-#### *Example Types Helper Import:*
-
-```ts
-import type { OmitStrict } from "@rzl-zone/ts-types-plus";
-
-type MyType = OmitStrict<OtherType, "omittingProps">;
-// Fully strict TS omit that requires all keys to exist in target
-```
-
 ---
 
 <h2 id="sponsor-this-package">❤️ <strong>Sponsor this package</strong></h2>
 
 **Help support development:**    
-*[👉 Become a sponsor](https://github.com/sponsors/rzl-app)*
+*[👉 **Become a sponsor**](https://github.com/sponsors/rzl-app)*
 
 ---
 

package/dist/assertions/index.cjs

@@ -1 +1,34 @@
-"use strict";var e=require("../chunk-IVL7CKVH.cjs"),r=require("../chunk-HYRQMTRH.cjs"),t=require("../chunk-6JFZL7YE.cjs");require("../chunk-UDA26MCU.cjs");var s=require("../chunk-PZQ6I4JJ.cjs");Object.defineProperty(exports,"assertIsBigInt",{enumerable:!0,get:function(){return e.assertIsBigInt}}),Object.defineProperty(exports,"assertIsNumber",{enumerable:!0,get:function(){return e.assertIsNumber}}),Object.defineProperty(exports,"assertIsString",{enumerable:!0,get:function(){return r.assertIsString}}),Object.defineProperty(exports,"assertIsArray",{enumerable:!0,get:function(){return t.assertIsArray}}),Object.defineProperty(exports,"assertIsBoolean",{enumerable:!0,get:function(){return s.assertIsBoolean}}),Object.defineProperty(exports,"assertIsPlainObject",{enumerable:!0,get:function(){return s.assertIsPlainObject}});
+'use strict';
+
+var chunkIVL7CKVH_cjs = require('../chunk-IVL7CKVH.cjs');
+var chunkHYRQMTRH_cjs = require('../chunk-HYRQMTRH.cjs');
+var chunk6JFZL7YE_cjs = require('../chunk-6JFZL7YE.cjs');
+require('../chunk-UDA26MCU.cjs');
+var chunkPZQ6I4JJ_cjs = require('../chunk-PZQ6I4JJ.cjs');
+
+
+
+Object.defineProperty(exports, "assertIsBigInt", {
+  enumerable: true,
+  get: function () { return chunkIVL7CKVH_cjs.assertIsBigInt; }
+});
+Object.defineProperty(exports, "assertIsNumber", {
+  enumerable: true,
+  get: function () { return chunkIVL7CKVH_cjs.assertIsNumber; }
+});
+Object.defineProperty(exports, "assertIsString", {
+  enumerable: true,
+  get: function () { return chunkHYRQMTRH_cjs.assertIsString; }
+});
+Object.defineProperty(exports, "assertIsArray", {
+  enumerable: true,
+  get: function () { return chunk6JFZL7YE_cjs.assertIsArray; }
+});
+Object.defineProperty(exports, "assertIsBoolean", {
+  enumerable: true,
+  get: function () { return chunkPZQ6I4JJ_cjs.assertIsBoolean; }
+});
+Object.defineProperty(exports, "assertIsPlainObject", {
+  enumerable: true,
+  get: function () { return chunkPZQ6I4JJ_cjs.assertIsPlainObject; }
+});

package/dist/assertions/index.d.ts

@@ -1,4 +1,4 @@
-import{Prettify,PickStrict}from'@rzl-zone/ts-types-plus';import{G as GetPreciseTypeOptions,I as IsNumberOptions,a as IsPlainObjectResult}from'../isPlainObject-CEPWPiXh.js';
+import{Prettify,PickStrict}from'@rzl-zone/ts-types-plus';import{G as GetPreciseTypeOptions,I as IsNumberOptions,a as IsPlainObjectResult}from'../isPlainObject-FWmcJF6k.js';
 /** -------------------------------------------------------
  * * ***Shape of the object passed to custom error message functions.***
  * -------------------------------------------------------
@@ -431,4 +431,4 @@ declare function assertIsPlainObject<T>(value:T,options?:OptionsAssertIs):assert
  * console.log(result.toUpperCase()); // ➔ ✅ type-safe
  * ```
  */
-declare const assertIsString:(value:unknown,options?:OptionsAssertIs)=>asserts value is string;export{assertIsArray,assertIsBigInt,assertIsBoolean,assertIsNumber,assertIsPlainObject,assertIsString};
+declare const assertIsString:(value:unknown,options?:OptionsAssertIs)=>asserts value is string;export{assertIsArray,assertIsBigInt,assertIsBoolean,assertIsNumber,assertIsPlainObject,assertIsString};

package/dist/assertions/index.js

@@ -1 +1,5 @@
-export{assertIsBigInt,assertIsNumber}from"../chunk-3VA554KW.js";export{assertIsString}from"../chunk-SBKGWRS5.js";export{assertIsArray}from"../chunk-CKTLUNWX.js";import"../chunk-QNKGP5DY.js";export{assertIsBoolean,assertIsPlainObject}from"../chunk-CMW2TBOQ.js";
+export { assertIsBigInt, assertIsNumber } from '../chunk-3VA554KW.js';
+export { assertIsString } from '../chunk-SBKGWRS5.js';
+export { assertIsArray } from '../chunk-CKTLUNWX.js';
+import '../chunk-QNKGP5DY.js';
+export { assertIsBoolean, assertIsPlainObject } from '../chunk-CMW2TBOQ.js';

package/dist/chunk-2CQX5CBG.js

@@ -1 +1,247 @@
-import{isEmptyArray as e,isEmptyObject as r}from"./chunk-6JFCSH7J.js";import{noop as t}from"./chunk-YWHHVDT4.js";import{safeStableStringify as o}from"./chunk-PET42Z7W.js";import{isNonEmptyString as n,getPreciseType as s,isNull as a,isUndefined as c,isString as i,isArray as m,isObject as l,isNumber as u,isNaN as v,isError as f,assertIsPlainObject as N,hasOwnProp as d,isBoolean as p,isFunction as g}from"./chunk-CMW2TBOQ.js";var y=(e,r)=>{if(!n(e)||!n(r))throw new TypeError(`Parameter \`dateString\` and \`format\` must be of type \`string\` and not empty-string, but received: "['dateString': \`${s(e)}\` - (current value: \`${o(e)}\`), 'format': \`${s(r)}\` - (current value: \`${o(r)}\`)]".`);const t=e.split(/[-/]/).map(Number);if(3!==t.length||t.some(isNaN))return null;let a,c,i;if("DD/MM/YYYY"===r)[a,c,i]=t;else{if("MM/DD/YYYY"!==r)return null;[c,a,i]=t}c-=1;const m=new Date(i,c,a);return m.getFullYear()!==i||m.getMonth()!==c||m.getDate()!==a?null:m},b=(e={})=>{N(e,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});const r=!!d(e,"convertBooleans")&&e.convertBooleans,o=!!d(e,"convertDates")&&e.convertDates,n=!!d(e,"convertNumbers")&&e.convertNumbers,a=!!d(e,"loggingOnFail")&&e.loggingOnFail,c=!!d(e,"removeEmptyArrays")&&e.removeEmptyArrays,i=!!d(e,"removeEmptyObjects")&&e.removeEmptyObjects,l=!!d(e,"removeNulls")&&e.removeNulls,u=!!d(e,"removeUndefined")&&e.removeUndefined,v=!!d(e,"strictMode")&&e.strictMode,f=!!d(e,"checkSymbols")&&e.checkSymbols,y=!!d(e,"convertNaN")&&e.convertNaN,b=d(e,"customDateFormats")?e.customDateFormats:[],E=d(e,"onError")?e.onError:t;if(!(p(r)&&p(o)&&p(n)&&p(y)&&p(f)&&p(a)&&p(c)&&p(i)&&p(l)&&p(u)&&p(v)&&m(b)&&g(E)))throw new TypeError(`Invalid \`options\` parameter (second argument): \`convertBooleans\`, \`convertDates\`, \`convertNumbers\`, \`loggingOnFail\`, \`removeEmptyArrays\`, \`removeEmptyObjects\`, \`removeNulls\`, \`removeUndefined\`, \`strictMode\` expected to be a \`boolean\` type, \`customDateFormats\` expected to be a \`array\` type and \`onError\` expected to be a \`void function\` type. But received: ['convertBooleans': \`${s(r)}\`, 'convertDates': \`${s(o)}\`, 'convertNumbers': \`${s(n)}\`, 'loggingOnFail': \`${s(a)}\`, 'removeEmptyArrays': \`${s(c)}\`, 'removeEmptyObjects': \`${s(i)}\`, 'removeNulls': \`${s(l)}\`, 'removeUndefined': \`${s(u)}\`, 'strictMode': \`${s(v)}\`, 'customDateFormats': \`${s(b)}\`, 'onError': \`${s(E)}\`].`);return{convertBooleans:r,convertDates:o,convertNumbers:n,convertNaN:y,loggingOnFail:a,removeEmptyArrays:c,removeEmptyObjects:i,removeNulls:l,removeUndefined:u,strictMode:v,customDateFormats:b,onError:E,checkSymbols:f}},E=(t,o={})=>{const n=b(o);if(a(t))return n.removeNulls?void 0:null;if(!c(t)){if(i(t)){const e=t.trim();if(n.convertNaN&&"NaN"===e)return NaN;if(n.convertNumbers&&!isNaN(Number(e)))return Number(e);if(n.convertBooleans){if("true"===e)return!0;if("false"===e)return!1}if(n.convertDates){if(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(e))return new Date(e);if(n.customDateFormats?.length)for(const r of n.customDateFormats){const t=y(e,r);if(t)return t}}return n.strictMode?void 0:e}if(m(t)){const r=t.map(e=>E(e,n)).filter(e=>!c(e));return n.removeEmptyArrays&&e(r)?void 0:r}if(l(t)){const e={};for(const r in t)if(Object.prototype.hasOwnProperty.call(t,r)){const o=E(t[r],n);c(o)||(e[r]=o)}return n.removeEmptyObjects&&r(e,{checkSymbols:n.checkSymbols})?void 0:e}return n.strictMode?void 0:t}n.removeUndefined},D=e=>{if(!i(e)&&!u(e))return 0;const r=String(e).trim().replace(/[^0-9]/g,"");return Number(r)||0};function h(e,r={}){if(a(e))return null;const t=b(r);if(t.convertNaN&&(v(e)||n(e)&&"NaN"===e))return NaN;if(t.convertNumbers&&!v(Number(e))&&u(D(e)))return Number(e);if(i(e))try{let r=function(e){const r=new Set(["\\",'"',"/","b","f","n","r","t","u"]);let t="",o=!1,n=!1,s=!1;for(let a=0;a<e.length;a++){const c=e[a];if(s)o?"'"===c?t+="'":r.has(c)?t+="\\"===c?"\\\\":'"'===c?'\\"':"\\"+c:t+="\\\\"+c:n?'"'===c?t+='\\"':r.has(c)?t+="\\"+c:t+="\\\\"+c:t+="\\"+c,s=!1;else if("\\"!==c){if(o||n){if(o){if("'"===c){t+='"',o=!1;continue}}else if(n&&'"'===c){t+='"',n=!1;continue}}else{if("'"===c){t+='"',o=!0;continue}if('"'===c){t+='"',n=!0;continue}}t+=c}else s=!0}return t}(e);r=t.removeUndefined?r.replace(/,\s*"[^"]*"\s*:\s*undefined(?=\s*[},])/g,"").replace(/"[^"]*"\s*:\s*undefined\s*(,)?/g,""):r.replace(/:\s*undefined(?=\s*[,}])/g,":null"),r=t.convertNaN?r.replace(/:\s*NaN(?=\s*[,}])/g,':"NaN"'):r.replace(/:\s*NaN(?=\s*[,}])/g,':"NaN"').replace(/,\s*"[^"]*"\s*:\s*NaN(?=\s*[},])/g,"").replace(/"[^"]*"\s*:\s*NaN\s*(,)?/g,""),r=r.replace(/,(\s*[}\]])/g,"$1");const o=JSON.parse(r);return E(o,t)}catch(e){return t.loggingOnFail&&console.error("Failed to parsing at `safeJsonParse`:",e),void t.onError(f(e)?new Error(e.message.replace(/^JSON\.parse:/,"Failed to parsing")):new Error(String(e)))}}export{E as cleanParsedData,D as extractDigits,y as parseCustomDate,h as safeJsonParse};
+import { isEmptyArray, isEmptyObject } from './chunk-6JFCSH7J.js';
+import { noop } from './chunk-YWHHVDT4.js';
+import { safeStableStringify } from './chunk-PET42Z7W.js';
+import { isNonEmptyString, getPreciseType, isNull, isUndefined, isString, isArray, isObject, isNumber, isNaN as isNaN$1, isError, assertIsPlainObject, hasOwnProp, isBoolean, isFunction } from './chunk-CMW2TBOQ.js';
+var parseCustomDate = (dateString, format) => {
+  if (!isNonEmptyString(dateString) || !isNonEmptyString(format)) {
+    throw new TypeError(
+      `Parameter \`dateString\` and \`format\` must be of type \`string\` and not empty-string, but received: "['dateString': \`${getPreciseType(
+        dateString
+      )}\` - (current value: \`${safeStableStringify(
+        dateString
+      )}\`), 'format': \`${getPreciseType(
+        format
+      )}\` - (current value: \`${safeStableStringify(format)}\`)]".`
+    );
+  }
+  const dateParts = dateString.split(/[-/]/).map(Number);
+  if (dateParts.length !== 3 || dateParts.some(isNaN)) return null;
+  let day, month, year;
+  if (format === "DD/MM/YYYY") {
+    [day, month, year] = dateParts;
+  } else if (format === "MM/DD/YYYY") {
+    [month, day, year] = dateParts;
+  } else {
+    return null;
+  }
+  month -= 1;
+  const date = new Date(year, month, day);
+  if (date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) {
+    return null;
+  }
+  return date;
+};
+var validateJsonParsingOptions = (optionsValue = {}) => {
+  assertIsPlainObject(optionsValue, {
+    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const convertBooleans = hasOwnProp(optionsValue, "convertBooleans") ? optionsValue.convertBooleans : false;
+  const convertDates = hasOwnProp(optionsValue, "convertDates") ? optionsValue.convertDates : false;
+  const convertNumbers = hasOwnProp(optionsValue, "convertNumbers") ? optionsValue.convertNumbers : false;
+  const loggingOnFail = hasOwnProp(optionsValue, "loggingOnFail") ? optionsValue.loggingOnFail : false;
+  const removeEmptyArrays = hasOwnProp(optionsValue, "removeEmptyArrays") ? optionsValue.removeEmptyArrays : false;
+  const removeEmptyObjects = hasOwnProp(optionsValue, "removeEmptyObjects") ? optionsValue.removeEmptyObjects : false;
+  const removeNulls = hasOwnProp(optionsValue, "removeNulls") ? optionsValue.removeNulls : false;
+  const removeUndefined = hasOwnProp(optionsValue, "removeUndefined") ? optionsValue.removeUndefined : false;
+  const strictMode = hasOwnProp(optionsValue, "strictMode") ? optionsValue.strictMode : false;
+  const checkSymbols = hasOwnProp(optionsValue, "checkSymbols") ? optionsValue.checkSymbols : false;
+  const convertNaN = hasOwnProp(optionsValue, "convertNaN") ? optionsValue.convertNaN : false;
+  const customDateFormats = hasOwnProp(optionsValue, "customDateFormats") ? optionsValue.customDateFormats : [];
+  const onError = hasOwnProp(optionsValue, "onError") ? optionsValue.onError : noop;
+  if (!(isBoolean(convertBooleans) && isBoolean(convertDates) && isBoolean(convertNumbers) && isBoolean(convertNaN) && isBoolean(checkSymbols) && isBoolean(loggingOnFail) && isBoolean(removeEmptyArrays) && isBoolean(removeEmptyObjects) && isBoolean(removeNulls) && isBoolean(removeUndefined) && isBoolean(strictMode) && isArray(customDateFormats) && isFunction(onError))) {
+    throw new TypeError(
+      `Invalid \`options\` parameter (second argument): \`convertBooleans\`, \`convertDates\`, \`convertNumbers\`, \`loggingOnFail\`, \`removeEmptyArrays\`, \`removeEmptyObjects\`, \`removeNulls\`, \`removeUndefined\`, \`strictMode\` expected to be a \`boolean\` type, \`customDateFormats\` expected to be a \`array\` type and \`onError\` expected to be a \`void function\` type. But received: ['convertBooleans': \`${getPreciseType(
+        convertBooleans
+      )}\`, 'convertDates': \`${getPreciseType(
+        convertDates
+      )}\`, 'convertNumbers': \`${getPreciseType(
+        convertNumbers
+      )}\`, 'loggingOnFail': \`${getPreciseType(
+        loggingOnFail
+      )}\`, 'removeEmptyArrays': \`${getPreciseType(
+        removeEmptyArrays
+      )}\`, 'removeEmptyObjects': \`${getPreciseType(
+        removeEmptyObjects
+      )}\`, 'removeNulls': \`${getPreciseType(
+        removeNulls
+      )}\`, 'removeUndefined': \`${getPreciseType(
+        removeUndefined
+      )}\`, 'strictMode': \`${getPreciseType(
+        strictMode
+      )}\`, 'customDateFormats': \`${getPreciseType(
+        customDateFormats
+      )}\`, 'onError': \`${getPreciseType(onError)}\`].`
+    );
+  }
+  return {
+    convertBooleans,
+    convertDates,
+    convertNumbers,
+    convertNaN,
+    loggingOnFail,
+    removeEmptyArrays,
+    removeEmptyObjects,
+    removeNulls,
+    removeUndefined,
+    strictMode,
+    customDateFormats,
+    onError,
+    checkSymbols
+  };
+};
+var cleanParsedData = (data, options = {}) => {
+  const validOptions = validateJsonParsingOptions(options);
+  if (isNull(data)) return validOptions.removeNulls ? void 0 : null;
+  if (isUndefined(data)) return validOptions.removeUndefined ? void 0 : void 0;
+  if (isString(data)) {
+    const trimmed = data.trim();
+    if (validOptions.convertNaN && trimmed === "NaN") return NaN;
+    if (validOptions.convertNumbers && !isNaN(Number(trimmed))) {
+      return Number(trimmed);
+    }
+    if (validOptions.convertBooleans) {
+      if (trimmed === "true") return true;
+      if (trimmed === "false") return false;
+    }
+    if (validOptions.convertDates) {
+      if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(trimmed)) {
+        return new Date(trimmed);
+      }
+      if (validOptions.customDateFormats?.length) {
+        for (const format of validOptions.customDateFormats) {
+          const date = parseCustomDate(trimmed, format);
+          if (date) return date;
+        }
+      }
+    }
+    return validOptions.strictMode ? void 0 : trimmed;
+  }
+  if (isArray(data)) {
+    const cleanedArray = data.map((item) => cleanParsedData(item, validOptions)).filter((item) => !isUndefined(item));
+    return validOptions.removeEmptyArrays && isEmptyArray(cleanedArray) ? void 0 : cleanedArray;
+  }
+  if (isObject(data)) {
+    const cleanedObject = {};
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        const cleanedValue = cleanParsedData(data[key], validOptions);
+        if (!isUndefined(cleanedValue)) {
+          cleanedObject[key] = cleanedValue;
+        }
+      }
+    }
+    return validOptions.removeEmptyObjects && isEmptyObject(cleanedObject, { checkSymbols: validOptions.checkSymbols }) ? void 0 : cleanedObject;
+  }
+  return validOptions.strictMode ? void 0 : data;
+};
+var extractDigits = (value) => {
+  if (!isString(value) && !isNumber(value)) return 0;
+  const cleaned = String(value).trim().replace(/[^0-9]/g, "");
+  return Number(cleaned) || 0;
+};
+function fixSingleQuotesEscapeBackslash(input) {
+  const validEscapes = /* @__PURE__ */ new Set(["\\", '"', "/", "b", "f", "n", "r", "t", "u"]);
+  let output = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escapeNext = false;
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    if (escapeNext) {
+      if (inSingleQuote) {
+        if (c === "'") {
+          output += "'";
+        } else if (validEscapes.has(c)) {
+          if (c === "\\") {
+            output += "\\\\";
+          } else if (c === '"') {
+            output += '\\"';
+          } else {
+            output += "\\" + c;
+          }
+        } else {
+          output += "\\\\" + c;
+        }
+      } else if (inDoubleQuote) {
+        if (c === '"') {
+          output += '\\"';
+        } else if (validEscapes.has(c)) {
+          output += "\\" + c;
+        } else {
+          output += "\\\\" + c;
+        }
+      } else {
+        output += "\\" + c;
+      }
+      escapeNext = false;
+      continue;
+    }
+    if (c === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (c === "'") {
+        output += '"';
+        inSingleQuote = true;
+        continue;
+      }
+      if (c === '"') {
+        output += '"';
+        inDoubleQuote = true;
+        continue;
+      }
+    } else if (inSingleQuote) {
+      if (c === "'") {
+        output += '"';
+        inSingleQuote = false;
+        continue;
+      }
+    } else if (inDoubleQuote) {
+      if (c === '"') {
+        output += '"';
+        inDoubleQuote = false;
+        continue;
+      }
+    }
+    output += c;
+  }
+  return output;
+}
+function safeJsonParse(value, options = {}) {
+  if (isNull(value)) return null;
+  const validOptions = validateJsonParsingOptions(options);
+  if (validOptions.convertNaN && (isNaN$1(value) || isNonEmptyString(value) && value === "NaN")) {
+    return NaN;
+  }
+  if (validOptions.convertNumbers && !isNaN$1(Number(value)) && isNumber(extractDigits(value))) {
+    return Number(value);
+  }
+  if (!isString(value)) return void 0;
+  try {
+    let normalized = fixSingleQuotesEscapeBackslash(value);
+    if (validOptions.removeUndefined) {
+      normalized = normalized.replace(/,\s*"[^"]*"\s*:\s*undefined(?=\s*[},])/g, "").replace(/"[^"]*"\s*:\s*undefined\s*(,)?/g, "");
+    } else {
+      normalized = normalized.replace(/:\s*undefined(?=\s*[,}])/g, ":null");
+    }
+    if (validOptions.convertNaN) {
+      normalized = normalized.replace(/:\s*NaN(?=\s*[,}])/g, ':"NaN"');
+    } else {
+      normalized = normalized.replace(/:\s*NaN(?=\s*[,}])/g, ':"NaN"').replace(/,\s*"[^"]*"\s*:\s*NaN(?=\s*[},])/g, "").replace(/"[^"]*"\s*:\s*NaN\s*(,)?/g, "");
+    }
+    normalized = normalized.replace(/,(\s*[}\]])/g, "$1");
+    const parsed = JSON.parse(normalized);
+    return cleanParsedData(parsed, validOptions);
+  } catch (error) {
+    if (validOptions.loggingOnFail) {
+      console.error("Failed to parsing at `safeJsonParse`:", error);
+    }
+    validOptions.onError(
+      isError(error) ? new Error(error.message.replace(/^JSON\.parse:/, "Failed to parsing")) : new Error(String(error))
+    );
+    return void 0;
+  }
+}
+
+export { cleanParsedData, extractDigits, parseCustomDate, safeJsonParse };

package/dist/chunk-2IOOEY45.cjs

@@ -1 +1,20 @@
-"use strict";var r=require("./chunk-PZQ6I4JJ.cjs");exports.normalizeSpaces=(i,t={withTrim:!0,trimOnly:!1})=>{if(!r.isNonEmptyString(i))return"";r.isPlainObject(t)||(t={});const{trimOnly:e=!1,withTrim:n=!0}=t;return e?i.trim():(n&&(i=i.trim()),i.replace(/\s+/g," "))};
+'use strict';
+
+var chunkPZQ6I4JJ_cjs = require('./chunk-PZQ6I4JJ.cjs');
+var normalizeSpaces = (value, options = {
+  withTrim: true,
+  trimOnly: false
+}) => {
+  if (!chunkPZQ6I4JJ_cjs.isNonEmptyString(value)) return "";
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(options)) {
+    options = {};
+  }
+  const { trimOnly = false, withTrim = true } = options;
+  if (trimOnly) return value.trim();
+  if (withTrim) {
+    value = value.trim();
+  }
+  return value.replace(/\s+/g, " ");
+};
+
+exports.normalizeSpaces = normalizeSpaces;