Issues and v2 work updates

package.json

@@ -52,7 +52,8 @@
         "build": "tsc && vite build",
         "format": "prettier --write .",
         "start": "vite build --watch",
-        "test": "[ -f ./dist/index.js ] || npm run build && vitest",
+        "test": "[ -f ./dist/index.js ] || npm run test:build",
+        "test:build": "npm run build && vitest",
         "test:coverage": "vitest run src.main.test.ts --coverage",
         "lint": "eslint ."
     },

src/base64/base64URL.ts

@@ -0,0 +1,20 @@
+import { _compress } from "../_compress";
+import { _decompress } from "../_decompress";
+import { getBaseValue } from "../getBaseValue";
+
+const keyStrBase64URL =  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+export function compressToBase64URL(input: string): string {
+    if (!input) {
+        return "";
+    }
+    return _compress(input, 6, (a) => keyStrBase64URL.charAt(a));
+}
+
+export function decompressFromBase64URL(input: string): string {
+    if (!input) {
+        return "";
+    }
+    const res = _decompress(input.length, 32, (index) => getBaseValue(keyStrBase64URL, input.charAt(index)));
+    return res || "";
+}

src/base64/betterBase64.ts

@@ -0,0 +1,33 @@
+import { _compress } from "../_compress";
+import keyStrBase64 from "./keyStrBase64";
+import { _decompress } from "../_decompress";
+import { getBaseValue } from "../getBaseValue";
+
+export function compressToBetterBase64(input: string): string {
+    if (!input) {
+        return "";
+    }
+    const res = _compress(input, 6, (a) => keyStrBase64.charAt(a));
+
+    // To produce valid Base64
+    switch (res.length % 3) {
+        case 0:
+            return res;
+        case 1:
+            return res + "==";
+        case 2:
+            return res + "=";
+        default: // When could this happen ?
+            console.warn("Something in compressToBetterBase64() is very very wrong.");
+            return "";
+    }
+
+}
+
+export function decompressFromBetterBase64(input: string): string {
+    if (!input) {
+        return "";
+    }
+    const res = _decompress(input.length, 32, (index) => getBaseValue(keyStrBase64, input.charAt(index)));
+    return res || "";
+}

src/base64/compressToBase64.ts

@@ -1,7 +1,9 @@
 import { _compress } from "../_compress";
 import keyStrBase64 from "./keyStrBase64";
+import { deprecated } from "../utils/misc";
 
 export function compressToBase64(input: string | null): string {
+    deprecated("compressToBase64()", "v2.0.0", { replacement: "compressToBetterBase64()"})
     if (input == null) {
         return "";
     }

src/base64/decompressFromBase64.ts

@@ -1,8 +1,10 @@
 import { _decompress } from "../_decompress";
 import { getBaseValue } from "../getBaseValue";
 import keyStrBase64 from "./keyStrBase64";
+import { deprecated } from "../utils/misc";
 
 export function decompressFromBase64(input: string | null) {
+    deprecated("decompressFromBase64()", "v2.0.0", { replacement: "decompressFromBetterBase64()"})
     if (input == null) return "";
     if (input == "") return null;
 

src/base64/index.ts

@@ -1,2 +1,4 @@
 export { compressToBase64 } from "./compressToBase64";
 export { decompressFromBase64 } from "./decompressFromBase64";
+export { compressToBetterBase64, decompressFromBetterBase64 } from "./betterBase64";
+export { compressToBase64URL, decompressFromBase64URL } from "./base64URL";

src/encodedURI/compressToEncodedURI.ts

@@ -1,7 +1,9 @@
 import { _compress } from "../_compress";
 import keyStrUriSafe from "./keyStrUriSafe";
+import { deprecated } from "../utils/misc";
 
 export function compressToEncodedURIComponent(input: string | null) {
+    deprecated("compressToEncodedURIComponent()", "v2.0.0", { replacement: "compressToBase64URL()"})
     if (input == null) return "";
 
     return _compress(input, 6, (a) => keyStrUriSafe.charAt(a));

src/encodedURI/decompressFromEncodedURI.ts

@@ -1,8 +1,10 @@
 import keyStrUriSafe from "./keyStrUriSafe";
 import { _decompress } from "../_decompress";
 import { getBaseValue } from "../getBaseValue";
+import { deprecated } from "../utils/misc";
 
 export function decompressFromEncodedURIComponent(input: string | null) {
+    deprecated("decompressFromEncodedURIComponent()", "v2.0.0", { replacement: "decompressFromBase64URL()"})
     if (input == null) return "";
     if (input == "") return null;
 

src/index.ts

@@ -10,7 +10,14 @@
 
 import { _compress } from "./_compress";
 import { _decompress } from "./_decompress";
-import { compressToBase64, decompressFromBase64 } from "./base64";
+import {
+    compressToBase64,
+    decompressFromBase64,
+    compressToBetterBase64,
+    decompressFromBetterBase64,
+    compressToBase64URL,
+    decompressFromBase64URL,
+} from "./base64";
 import { compressToEncodedURIComponent, decompressFromEncodedURIComponent } from "./encodedURI";
 import { compress, decompress } from "./stock";
 import { compressToUint8Array, decompressFromUint8Array } from "./Uint8Array";
@@ -25,6 +32,10 @@ export default {
 
     compressToBase64,
     decompressFromBase64,
+    compressToBetterBase64,
+    decompressFromBetterBase64,
+    compressToBase64URL,
+    decompressFromBase64URL,
 
     compressToEncodedURIComponent,
     decompressFromEncodedURIComponent,

src/utils/misc.ts

@@ -0,0 +1,13 @@
+type VERSIONS = "v2.0.0"
+
+export function deprecated(
+    thing: string,
+    version: VERSIONS,
+    opts?: { replacement?: string }
+): void {
+    let notice = `LZString | ${thing} is deprecated as of: ${version}`
+    if (opts?.replacement) {
+        notice += ` - Please use ${opts.replacement} instead`
+    }
+    console.error(notice)
+}

tests/suite/compressTattoo.ts

@@ -0,0 +1,7 @@
+import { expect, test } from "vitest";
+
+export function compressKnownString_test(compressFunc, data, compressedData) {
+    test(`expected compression result`, () => {
+        expect(compressFunc(data)).toEqual(compressedData);
+    });
+}

tests/suite/decompressTattoo.ts

@@ -0,0 +1,7 @@
+import { expect, test } from "vitest";
+
+export function decompressKnownString_test(decompressFunc, data, compressedData) {
+    test(`expected decompression result`, () => {
+        expect(decompressFunc(compressedData)).toEqual(data);
+    });
+}

tests/suite/emptyResponse.ts

@@ -0,0 +1,27 @@
+import { expect, test } from "vitest";
+
+export function emptyShouldBeEmptyResponse_test(compressFunc, decompressFunc, data) {
+    test(`"" (empty string)`, () => {
+        const compressedEmpty = compressFunc(data);
+
+        expect(compressedEmpty).toEqual(compressFunc(data));
+        expect(compressedEmpty).toEqual("");
+        compressedEmpty instanceof Uint8Array
+            ? expect(compressedEmpty.length).not.toBe(0)
+            : expect(typeof compressedEmpty).toBe("string");
+        expect(decompressFunc(compressedEmpty)).toEqual(data);
+    });
+}
+
+export function emptyShouldNotBeEmptyResponse_test(compressFunc, decompressFunc, data) {
+    test(`"" (empty string)`, () => {
+        const compressedEmpty = compressFunc(data);
+
+        expect(compressedEmpty).toEqual(compressFunc(data));
+        expect(compressedEmpty).not.toEqual("");
+        compressedEmpty instanceof Uint8Array
+            ? expect(compressedEmpty.length).not.toBe(0)
+            : expect(typeof compressedEmpty).toBe("string");
+        expect(decompressFunc(compressedEmpty)).toEqual(data);
+    });
+}

tests/suite/helloWorld.ts

@@ -0,0 +1,15 @@
+import { expect, test } from "vitest";
+
+export function helloWorld_test(compressFunc, decompressFunc, data) {
+    test(`"Hello World"`, () => {
+        const compressedHw = compressFunc(data);
+
+        expect(compressedHw).toEqual(compressFunc(data));
+        expect(compressedHw).not.toEqual(data);
+        expect(decompressFunc(compressedHw)).toEqual(data);
+    });
+}
+
+
+
+

tests/suite/inchangableChars.ts

@@ -0,0 +1,7 @@
+import { expect, test } from "vitest";
+
+export function interchangableChars_test(decompressFunc, data, compressedData) {
+    test(`+ and ' ' are interchangeable in decompression`, () => {
+        expect(data).toEqual(decompressFunc(compressedData));
+    });
+}

tests/suite/index.ts

@@ -0,0 +1,12 @@
+export * from "./helloWorld";
+export * from "./nullResponse";
+export * from "./emptyResponse";
+export * from "./undefinedResponse";
+export * from "./utf16Response";
+export * from "./repeatingString";
+export * from "./randomString";
+export * from "./longString";
+export * from "./urlSafe";
+export * from "./inchangableChars";
+export * from "./compressTattoo";
+export * from "./decompressTattoo";

tests/suite/longString.ts

@@ -0,0 +1,10 @@
+import { expect, test } from "vitest";
+
+export function longString_test(compressFunc, decompressFunc, data, compressedData) {
+    test(`Long String`, () => {
+        expect(compressedData).toEqual(compressFunc(data));
+        expect(compressedData).not.toEqual(data);
+        expect(compressedData.length).toBeLessThan(data.length);
+        expect(decompressFunc(compressedData)).toEqual(data);
+    });
+}

tests/suite/nullResponse.ts

@@ -0,0 +1,18 @@
+import { expect, test } from "vitest";
+
+export function nullShouldNotBeNullResponse_test(compressFunc, decompressFunc, data) {
+    test(`null`, () => {
+        const compressedNull = compressFunc(data);
+
+        compressedNull instanceof Uint8Array
+            ? expect(compressedNull.length).toBe(0)
+            : expect(compressedNull).toEqual("");
+    });
+}
+
+export function nullShouldBeNullResponse_test(compressFunc, decompressFunc, data) {
+    test(`null`, () => {
+        const compressedNull = compressFunc(data);
+        expect(compressedNull).toEqual(null);
+    });
+}

tests/suite/randomString.ts

@@ -0,0 +1,14 @@
+import { expect, test } from "vitest";
+import { test_randomString_fn } from "../testValues";
+
+export function randomString_test(compressFunc, decompressFunc) {
+// Note that this is designed to be uncompressible
+    test(`Random String`, () => {
+        const test_randomString = test_randomString_fn(); // Unique per test
+        const compressedRandomString = compressFunc(test_randomString);
+
+        expect(compressedRandomString).toEqual(compressFunc(test_randomString));
+        expect(compressedRandomString).not.toEqual(test_randomString);
+        expect(decompressFunc(compressedRandomString)).toEqual(test_randomString);
+    });
+}

tests/suite/repeatingString.ts

@@ -0,0 +1,12 @@
+import { expect, test } from "vitest";
+
+export function repeatingString_test(compressFunc, decompressFunc, data) {
+    test(`Repeating String`, () => {
+        const compressedRepeat = compressFunc(data);
+
+        expect(compressedRepeat).toEqual(compressFunc(data));
+        expect(compressedRepeat).not.toEqual(data);
+        expect(compressedRepeat.length).toBeLessThan(data.length);
+        expect(decompressFunc(compressedRepeat)).toEqual(data);
+    });
+}

tests/suite/undefinedResponse.ts

@@ -0,0 +1,11 @@
+import { expect, test } from "vitest";
+
+export function undefinedResponse_test(compressFunc, decompressFunc, data) {
+    test(`undefined`, () => {
+        const compressedUndefined = compressFunc(data);
+
+        compressedUndefined instanceof Uint8Array
+            ? expect(compressedUndefined.length).toBe(0)
+            : expect(compressedUndefined).toBe("");
+    });
+}

tests/suite/urlSafe.ts

@@ -0,0 +1,9 @@
+import { expect, test } from "vitest";
+
+export function allCharsUrlSafe_test(compressFunc, decompressFunc, data, compressedData) {
+    test(`All chars are URL safe`, () => {
+        expect(compressedData.indexOf("=")).toBe(-1);
+        expect(compressedData.indexOf("/")).toBe(-1);
+        expect(decompressFunc(compressedData)).toBe(data);
+    });
+}

tests/suite/utf16Response.ts

@@ -0,0 +1,11 @@
+import { expect, test } from "vitest";
+
+export function utf16Response_test(compressFunc, decompressFunc, data) {
+    test(`utf16`, () => {
+        const compressedUtf16 = compressFunc(data);
+
+        expect(compressedUtf16).toEqual(compressFunc(data));
+        expect(compressedUtf16).not.toEqual(data);
+        expect(decompressFunc(compressedUtf16)).toEqual(data);
+    });
+}