@salespark/toolkit 2.1.15 → 2.1.16

package/README.md

@@ -836,29 +836,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).
+**`scrambleString(value: string, secret: string): SalesParkContract<object>`** — Scrambles a string using a repeating secret (XOR) and Base64. Reversible obfuscation only (not crypto).
 
 ```javascript
 const scrambled = scrambleString("Hello", "secret");
-// Result: "..." (base64)
+// Result: { status: true, data: "..." }
 
-const original = descrambleString(scrambled, "secret");
-// Result: "Hello"
+const original = descrambleString(scrambled.data, "secret");
+// Result: { status: true, data: "Hello" }
 ```
 
-**`descrambleString(value: string, secret: string): string`** — Reverses `scrambleString` using the same secret.
+**`descrambleString(value: string, secret: string): SalesParkContract<object>`** — Reverses `scrambleString` 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
 

package/dist/index.cjs

@@ -1824,57 +1824,80 @@ 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");
-  }
-  if (!secret || typeof secret !== "string") {
-    throw new TypeError("Secret must be a non-empty string");
+  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 };
   }
-  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");
-  }
-  if (!secret || typeof secret !== "string") {
-    throw new TypeError("Secret must be a non-empty 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 };
   }
-  const descrambled = descrambleString(encoded, secret);
-  const jsonString = fromBase64(descrambled);
-  return JSON.parse(jsonString);
 };
 
 // src/utils/defer.ts