@salespark/toolkit 2.1.15 → 2.1.17

package/README.md

@@ -544,6 +544,22 @@ isNilOrEmpty(undefined);
 // Result: true
 ```
 
+**`isNilEmptyOrEmptyObject(value: unknown): boolean`** — Checks if value is nil, empty string, or an empty plain object (no own keys).
+
+```javascript
+isNilEmptyOrEmptyObject(null);
+// Result: true
+
+isNilEmptyOrEmptyObject("");
+// Result: true
+
+isNilEmptyOrEmptyObject({});
+// Result: true
+
+isNilEmptyOrEmptyObject({ a: 1 });
+// Result: false
+```
+
 **`hasNilOrEmpty(array: unknown): boolean`** — Checks if any element in array is nil or empty.
 
 ```javascript
@@ -836,29 +852,29 @@ assessSecurityRisks([]);
 // Result: { score: 0, level: "safe", recommendations: ["Content appears safe to use"] }
 ```
 
-**`scrambleString(value: string, secret: string): string`** — Scrambles a string using a repeating secret (XOR) and Base64. Reversible obfuscation only (not crypto).
+**`encodeString(input: string, secret: string): SalesParkContract<any>`** — Base64-encodes a string and scrambles it with the provided secret (obfuscation only).
 
 ```javascript
-const scrambled = scrambleString("Hello", "secret");
-// Result: "..." (base64)
+const encoded = encodeString("Hello", "secret");
+// Result: { status: true, data: "..." }
 
-const original = descrambleString(scrambled, "secret");
-// Result: "Hello"
+const decoded = decodeString(encoded.data, "secret");
+// Result: { status: true, data: "Hello" }
 ```
 
-**`descrambleString(value: string, secret: string): string`** — Reverses `scrambleString` using the same secret.
+**`decodeString(encoded: string, secret: string): SalesParkContract<any>`** — Reverses `encodeString` using the same secret.
 
-**`encodeObject(input: object, secret: string): string`** — JSON-stringifies an object, Base64-encodes it, and scrambles the result (obfuscation only).
+**`encodeObject(input: object, secret: string): SalesParkContract<object>`** — JSON-stringifies an object, Base64-encodes it, and scrambles the result (obfuscation only).
 
 ```javascript
 const encoded = encodeObject({ id: 1, name: "Ana" }, "secret");
-// Result: "..." (base64)
+// Result: { status: true, data: "..." }
 
-const decoded = decodeObject(encoded, "secret");
-// Result: { id: 1, name: "Ana" }
+const decoded = decodeObject(encoded.data, "secret");
+// Result: { status: true, data: { id: 1, name: "Ana" } }
 ```
 
-**`decodeObject(encoded: string, secret: string): object`** — Reverses `encodeObject` using the same secret.
+**`decodeObject(encoded: string, secret: string): SalesParkContract<object>`** — Reverses `encodeObject` using the same secret.
 
 ### ✅ Validation Utilities
 
@@ -993,5 +1009,5 @@ MIT © [SalesPark](https://salespark.io)
 
 ---
 
-_Document version: 13_  
-_Last update: 09-01-2026_
+_Document version: 14_  
+_Last update: 06-02-2026_

package/dist/index.cjs

@@ -506,6 +506,17 @@ var isNilOrEmpty = (value) => {
     return true;
   }
 };
+var isNilEmptyOrEmptyObject = (value) => {
+  try {
+    if (isNilOrEmpty(value)) return true;
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0) {
+      return true;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+};
 var hasNilOrEmpty = (array) => {
   try {
     if (!Array.isArray(array)) return true;
@@ -1824,57 +1835,116 @@ var binaryToUtf8 = (binary) => {
 var toBase64 = (value) => base64EncodeBinary(utf8ToBinary(value));
 var fromBase64 = (value) => binaryToUtf8(base64DecodeToBinary(value));
 var scrambleString = (value, secret) => {
-  if (typeof value !== "string") {
-    throw new TypeError("Value must be a string");
-  }
-  if (!secret || typeof secret !== "string") {
-    throw new TypeError("Secret must be a non-empty string");
-  }
-  let result = "";
-  for (let i = 0; i < value.length; i++) {
-    const charCode = value.charCodeAt(i) & 255;
-    const keyCode = secret.charCodeAt(i % secret.length) & 255;
-    result += String.fromCharCode(charCode ^ keyCode);
+  try {
+    if (typeof value !== "string") {
+      return { status: false, data: "Value must be a string" };
+    }
+    if (!secret || typeof secret !== "string") {
+      return { status: false, data: "Secret must be a non-empty string" };
+    }
+    let result = "";
+    for (let i = 0; i < value.length; i++) {
+      const charCode = value.charCodeAt(i) & 255;
+      const keyCode = secret.charCodeAt(i % secret.length) & 255;
+      result += String.fromCharCode(charCode ^ keyCode);
+    }
+    return { status: true, data: base64EncodeBinary(result) };
+  } catch (error) {
+    return { status: false, data: error };
   }
-  return base64EncodeBinary(result);
 };
 var descrambleString = (value, secret) => {
-  if (typeof value !== "string") {
-    throw new TypeError("Value must be a string");
-  }
-  if (!secret || typeof secret !== "string") {
-    throw new TypeError("Secret must be a non-empty string");
-  }
-  const decoded = base64DecodeToBinary(value);
-  let result = "";
-  for (let i = 0; i < decoded.length; i++) {
-    const charCode = decoded.charCodeAt(i) & 255;
-    const keyCode = secret.charCodeAt(i % secret.length) & 255;
-    result += String.fromCharCode(charCode ^ keyCode);
+  try {
+    if (typeof value !== "string") {
+      return { status: false, data: "Value must be a string" };
+    }
+    if (!secret || typeof secret !== "string") {
+      return { status: false, data: "Secret must be a non-empty string" };
+    }
+    const decoded = base64DecodeToBinary(value);
+    let result = "";
+    for (let i = 0; i < decoded.length; i++) {
+      const charCode = decoded.charCodeAt(i) & 255;
+      const keyCode = secret.charCodeAt(i % secret.length) & 255;
+      result += String.fromCharCode(charCode ^ keyCode);
+    }
+    return { status: true, data: result };
+  } catch (error) {
+    return { status: false, data: error };
   }
-  return result;
 };
 var encodeObject = (input, secret) => {
-  if (!input || typeof input !== "object") {
-    throw new TypeError("Input must be an object");
+  try {
+    if (!input || typeof input !== "object") {
+      return { status: false, data: "Input must be an object" };
+    }
+    if (!secret || typeof secret !== "string") {
+      return { status: false, data: "Secret must be a non-empty string" };
+    }
+    const jsonString = JSON.stringify(input);
+    const base64 = toBase64(jsonString);
+    const scrambledResponse = scrambleString(base64, secret);
+    if (!scrambledResponse.status) {
+      return { status: false, data: "Scrambling failed" };
+    }
+    return { status: true, data: scrambledResponse.data };
+  } catch (error) {
+    return { status: false, data: error };
   }
-  if (!secret || typeof secret !== "string") {
-    throw new TypeError("Secret must be a non-empty string");
+};
+var encodeString = (input, secret) => {
+  try {
+    if (typeof input !== "string") {
+      return { status: false, data: "Input must be a string" };
+    }
+    if (!secret || typeof secret !== "string") {
+      return { status: false, data: "Secret must be a non-empty string" };
+    }
+    const base64 = toBase64(input);
+    const scrambledResponse = scrambleString(base64, secret);
+    if (!scrambledResponse.status) {
+      return { status: false, data: "Scrambling failed" };
+    }
+    return { status: true, data: scrambledResponse.data };
+  } catch (error) {
+    return { status: false, data: error };
   }
-  const jsonString = JSON.stringify(input);
-  const base64 = toBase64(jsonString);
-  return scrambleString(base64, secret);
 };
 var decodeObject = (encoded, secret) => {
-  if (typeof encoded !== "string") {
-    throw new TypeError("Encoded value must be a string");
+  try {
+    if (typeof encoded !== "string") {
+      return { status: false, data: "Encoded value must be a string" };
+    }
+    if (!secret || typeof secret !== "string") {
+      return { status: false, data: "Secret must be a non-empty string" };
+    }
+    const descrambledResponse = descrambleString(encoded, secret);
+    if (!descrambledResponse.status) {
+      return { status: false, data: "Descrambling failed" };
+    }
+    const jsonString = fromBase64(descrambledResponse.data);
+    return { status: true, data: JSON.parse(jsonString) };
+  } catch (error) {
+    return { status: false, data: error };
   }
-  if (!secret || typeof secret !== "string") {
-    throw new TypeError("Secret must be a non-empty string");
+};
+var decodeString = (encoded, secret) => {
+  try {
+    if (typeof encoded !== "string") {
+      return { status: false, data: "Encoded value must be a string" };
+    }
+    if (!secret || typeof secret !== "string") {
+      return { status: false, data: "Secret must be a non-empty string" };
+    }
+    const descrambledResponse = descrambleString(encoded, secret);
+    if (!descrambledResponse.status) {
+      return { status: false, data: "Descrambling failed" };
+    }
+    const value = fromBase64(descrambledResponse.data);
+    return { status: true, data: value };
+  } catch (error) {
+    return { status: false, data: error };
   }
-  const descrambled = descrambleString(encoded, secret);
-  const jsonString = fromBase64(descrambled);
-  return JSON.parse(jsonString);
 };
 
 // src/utils/defer.ts
@@ -1982,14 +2052,15 @@ exports.currencyToSymbol = currencyToSymbol;
 exports.debounce = debounce;
 exports.deburr = deburr;
 exports.decodeObject = decodeObject;
+exports.decodeString = decodeString;
 exports.deferAfterResponse = deferAfterResponse;
 exports.deferAfterResponseNonCritical = deferAfterResponseNonCritical;
 exports.deferNonCritical = deferNonCritical;
 exports.deferPostReturn = deferPostReturn;
 exports.delay = delay;
-exports.descrambleString = descrambleString;
 exports.difference = difference;
 exports.encodeObject = encodeObject;
+exports.encodeString = encodeString;
 exports.fill = fill;
 exports.flatten = flatten;
 exports.flattenDepth = flattenDepth;
@@ -2007,6 +2078,7 @@ exports.intersection = intersection;
 exports.isBrowser = isBrowser;
 exports.isFlattenable = isFlattenable;
 exports.isNil = isNil;
+exports.isNilEmptyOrEmptyObject = isNilEmptyOrEmptyObject;
 exports.isNilEmptyOrZeroLen = isNilEmptyOrZeroLen;
 exports.isNilEmptyOrZeroLength = isNilEmptyOrZeroLength;
 exports.isNilOrEmpty = isNilOrEmpty;
@@ -2049,7 +2121,6 @@ exports.safeParseInt = safeParseInt;
 exports.safeSubtract = safeSubtract;
 exports.sanitize = sanitize;
 exports.sanitizeMarkdown = sanitizeMarkdown;
-exports.scrambleString = scrambleString;
 exports.sentenceCase = sentenceCase;
 exports.shuffle = shuffle;
 exports.slugify = slugify;