namirasoft-site-react 1.5.19 → 1.5.20

package/src/EncryptionOperation.ts

@@ -1,99 +1,99 @@
-export class EncryptionOperation
-{
-    private static async encrypt<T>(algorithm: string, secret: string, message: T): Promise<string>
-    {
-        // if (secret.length != 32)
-        //     throw new Error("Secret length must be exactly 32");
-        const enc = new TextEncoder();
-
-        // Derive a key from the password using PBKDF2
-        const salt = crypto.getRandomValues(new Uint8Array(16));
-        const keyMaterial = await crypto.subtle.importKey(
-            "raw",
-            enc.encode(secret),
-            { name: "PBKDF2" },
-            false,
-            ["deriveKey"]
-        );
-
-        const key = await crypto.subtle.deriveKey(
-            {
-                name: "PBKDF2",
-                salt,
-                iterations: 100000,
-                hash: "SHA-256",
-            },
-            keyMaterial,
-            { name: algorithm, length: 256 },
-            true,
-            ["encrypt"]
-        );
-
-        // Generate random IV
-        const iv = crypto.getRandomValues(new Uint8Array(12));
-
-        const cipherText = await crypto.subtle.encrypt(
-            {
-                name: algorithm,
-                iv,
-            },
-            key,
-            enc.encode(JSON.stringify(message))
-        );
-
-        // Combine salt, iv, and cipherText for storage
-        const combined = new Uint8Array([...salt, ...iv, ...new Uint8Array(cipherText)]);
-        return btoa(String.fromCharCode(...combined));
-    }
-    private static async decrypt<T>(algorithm: string, secret: string, message: string): Promise<T>
-    {
-        const data = Uint8Array.from(atob(message), c => c.charCodeAt(0));
-
-        const salt = data.slice(0, 16);
-        const iv = data.slice(16, 28);
-        const cipherText = data.slice(28);
-
-        const enc = new TextEncoder();
-        const dec = new TextDecoder();
-
-        const keyMaterial = await crypto.subtle.importKey(
-            "raw",
-            enc.encode(secret),
-            { name: "PBKDF2" },
-            false,
-            ["deriveKey"]
-        );
-
-        const key = await crypto.subtle.deriveKey(
-            {
-                name: "PBKDF2",
-                salt,
-                iterations: 100000,
-                hash: "SHA-256",
-            },
-            keyMaterial,
-            { name: algorithm, length: 256 },
-            true,
-            ["decrypt"]
-        );
-
-        const decrypted = await crypto.subtle.decrypt(
-            {
-                name: algorithm,
-                iv,
-            },
-            key,
-            cipherText
-        );
-
-        return JSON.parse(dec.decode(decrypted));
-    }
-    static async AES256GCMEncrypt<T>(secret: string, message: T): Promise<string>
-    {
-        return EncryptionOperation.encrypt("AES-GCM", secret, message);
-    }
-    static async AES256GCMDecrypt<T>(secret: string, message: string): Promise<T>
-    {
-        return EncryptionOperation.decrypt("AES-GCM", secret, message);
-    }
+export class EncryptionOperation
+{
+    private static async encrypt<T>(algorithm: string, secret: string, message: T): Promise<string>
+    {
+        // if (secret.length != 32)
+        //     throw new Error("Secret length must be exactly 32");
+        const enc = new TextEncoder();
+
+        // Derive a key from the password using PBKDF2
+        const salt = crypto.getRandomValues(new Uint8Array(16));
+        const keyMaterial = await crypto.subtle.importKey(
+            "raw",
+            enc.encode(secret),
+            { name: "PBKDF2" },
+            false,
+            ["deriveKey"]
+        );
+
+        const key = await crypto.subtle.deriveKey(
+            {
+                name: "PBKDF2",
+                salt,
+                iterations: 100000,
+                hash: "SHA-256",
+            },
+            keyMaterial,
+            { name: algorithm, length: 256 },
+            true,
+            ["encrypt"]
+        );
+
+        // Generate random IV
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+
+        const cipherText = await crypto.subtle.encrypt(
+            {
+                name: algorithm,
+                iv,
+            },
+            key,
+            enc.encode(JSON.stringify(message))
+        );
+
+        // Combine salt, iv, and cipherText for storage
+        const combined = new Uint8Array([...salt, ...iv, ...new Uint8Array(cipherText)]);
+        return btoa(String.fromCharCode(...combined));
+    }
+    private static async decrypt<T>(algorithm: string, secret: string, message: string): Promise<T>
+    {
+        const data = Uint8Array.from(atob(message), c => c.charCodeAt(0));
+
+        const salt = data.slice(0, 16);
+        const iv = data.slice(16, 28);
+        const cipherText = data.slice(28);
+
+        const enc = new TextEncoder();
+        const dec = new TextDecoder();
+
+        const keyMaterial = await crypto.subtle.importKey(
+            "raw",
+            enc.encode(secret),
+            { name: "PBKDF2" },
+            false,
+            ["deriveKey"]
+        );
+
+        const key = await crypto.subtle.deriveKey(
+            {
+                name: "PBKDF2",
+                salt,
+                iterations: 100000,
+                hash: "SHA-256",
+            },
+            keyMaterial,
+            { name: algorithm, length: 256 },
+            true,
+            ["decrypt"]
+        );
+
+        const decrypted = await crypto.subtle.decrypt(
+            {
+                name: algorithm,
+                iv,
+            },
+            key,
+            cipherText
+        );
+
+        return JSON.parse(dec.decode(decrypted));
+    }
+    static async AES256GCMEncrypt<T>(secret: string, message: T): Promise<string>
+    {
+        return EncryptionOperation.encrypt("AES-GCM", secret, message);
+    }
+    static async AES256GCMDecrypt<T>(secret: string, message: string): Promise<T>
+    {
+        return EncryptionOperation.decrypt("AES-GCM", secret, message);
+    }
 }

package/src/KeyOperation.ts

@@ -1,110 +1,110 @@
-export class KeyOperation
-{
-    private static started: boolean = false;
-    private static readonly pressedCodes: Set<string> = new Set<string>();
-    private static readonly pressedKeys: Set<string> = new Set<string>();
-
-    private static readonly onKeyDown = (event: KeyboardEvent): void =>
-    {
-        KeyOperation.pressedCodes.add(event.code);
-        KeyOperation.pressedKeys.add(event.key.toLowerCase());
-    };
-
-    private static readonly onKeyUp = (event: KeyboardEvent): void =>
-    {
-        KeyOperation.pressedCodes.delete(event.code);
-        KeyOperation.pressedKeys.delete(event.key.toLowerCase());
-    };
-
-    private static readonly onBlur = (): void =>
-    {
-        KeyOperation.pressedCodes.clear();
-        KeyOperation.pressedKeys.clear();
-    };
-
-    static start(): void
-    {
-        if (KeyOperation.started)
-            return;
-        if (typeof window === "undefined")
-            return;
-        window.addEventListener("keydown", KeyOperation.onKeyDown);
-        window.addEventListener("keyup", KeyOperation.onKeyUp);
-        window.addEventListener("blur", KeyOperation.onBlur);
-        KeyOperation.started = true;
-    }
-
-    static stop(): void
-    {
-        if (!KeyOperation.started)
-            return;
-        if (typeof window === "undefined")
-            return;
-        window.removeEventListener("keydown", KeyOperation.onKeyDown);
-        window.removeEventListener("keyup", KeyOperation.onKeyUp);
-        window.removeEventListener("blur", KeyOperation.onBlur);
-        KeyOperation.pressedCodes.clear();
-        KeyOperation.pressedKeys.clear();
-        KeyOperation.started = false;
-    }
-
-    static isCodePressed(code: string): boolean
-    {
-        return KeyOperation.pressedCodes.has(code);
-    }
-
-    static isKeyPressed(key: string): boolean
-    {
-        return KeyOperation.pressedKeys.has(key.toLowerCase());
-    }
-
-    static isAnyCodePressed(...codes: string[]): boolean
-    {
-        return codes.some(code => KeyOperation.pressedCodes.has(code));
-    }
-
-    static areAllCodesPressed(...codes: string[]): boolean
-    {
-        return codes.every(code => KeyOperation.pressedCodes.has(code));
-    }
-
-    static isShiftPressed(): boolean
-    {
-        return KeyOperation.isAnyCodePressed("ShiftLeft", "ShiftRight");
-    }
-
-    static isControlPressed(): boolean
-    {
-        return KeyOperation.isAnyCodePressed("ControlLeft", "ControlRight");
-    }
-
-    static isAltPressed(): boolean
-    {
-        return KeyOperation.isAnyCodePressed("AltLeft", "AltRight");
-    }
-
-    static isMetaPressed(): boolean
-    {
-        return KeyOperation.isAnyCodePressed("MetaLeft", "MetaRight");
-    }
-
-    static isEnterPressed(): boolean
-    {
-        return KeyOperation.isAnyCodePressed("Enter", "NumpadEnter");
-    }
-
-    static isEscapePressed(): boolean
-    {
-        return KeyOperation.isCodePressed("Escape");
-    }
-
-    static isSpacePressed(): boolean
-    {
-        return KeyOperation.isCodePressed("Space");
-    }
-
-    static getPressedCodes(): string[]
-    {
-        return Array.from(KeyOperation.pressedCodes);
-    }
+export class KeyOperation
+{
+    private static started: boolean = false;
+    private static readonly pressedCodes: Set<string> = new Set<string>();
+    private static readonly pressedKeys: Set<string> = new Set<string>();
+
+    private static readonly onKeyDown = (event: KeyboardEvent): void =>
+    {
+        KeyOperation.pressedCodes.add(event.code);
+        KeyOperation.pressedKeys.add(event.key.toLowerCase());
+    };
+
+    private static readonly onKeyUp = (event: KeyboardEvent): void =>
+    {
+        KeyOperation.pressedCodes.delete(event.code);
+        KeyOperation.pressedKeys.delete(event.key.toLowerCase());
+    };
+
+    private static readonly onBlur = (): void =>
+    {
+        KeyOperation.pressedCodes.clear();
+        KeyOperation.pressedKeys.clear();
+    };
+
+    static start(): void
+    {
+        if (KeyOperation.started)
+            return;
+        if (typeof window === "undefined")
+            return;
+        window.addEventListener("keydown", KeyOperation.onKeyDown);
+        window.addEventListener("keyup", KeyOperation.onKeyUp);
+        window.addEventListener("blur", KeyOperation.onBlur);
+        KeyOperation.started = true;
+    }
+
+    static stop(): void
+    {
+        if (!KeyOperation.started)
+            return;
+        if (typeof window === "undefined")
+            return;
+        window.removeEventListener("keydown", KeyOperation.onKeyDown);
+        window.removeEventListener("keyup", KeyOperation.onKeyUp);
+        window.removeEventListener("blur", KeyOperation.onBlur);
+        KeyOperation.pressedCodes.clear();
+        KeyOperation.pressedKeys.clear();
+        KeyOperation.started = false;
+    }
+
+    static isCodePressed(code: string): boolean
+    {
+        return KeyOperation.pressedCodes.has(code);
+    }
+
+    static isKeyPressed(key: string): boolean
+    {
+        return KeyOperation.pressedKeys.has(key.toLowerCase());
+    }
+
+    static isAnyCodePressed(...codes: string[]): boolean
+    {
+        return codes.some(code => KeyOperation.pressedCodes.has(code));
+    }
+
+    static areAllCodesPressed(...codes: string[]): boolean
+    {
+        return codes.every(code => KeyOperation.pressedCodes.has(code));
+    }
+
+    static isShiftPressed(): boolean
+    {
+        return KeyOperation.isAnyCodePressed("ShiftLeft", "ShiftRight");
+    }
+
+    static isControlPressed(): boolean
+    {
+        return KeyOperation.isAnyCodePressed("ControlLeft", "ControlRight");
+    }
+
+    static isAltPressed(): boolean
+    {
+        return KeyOperation.isAnyCodePressed("AltLeft", "AltRight");
+    }
+
+    static isMetaPressed(): boolean
+    {
+        return KeyOperation.isAnyCodePressed("MetaLeft", "MetaRight");
+    }
+
+    static isEnterPressed(): boolean
+    {
+        return KeyOperation.isAnyCodePressed("Enter", "NumpadEnter");
+    }
+
+    static isEscapePressed(): boolean
+    {
+        return KeyOperation.isCodePressed("Escape");
+    }
+
+    static isSpacePressed(): boolean
+    {
+        return KeyOperation.isCodePressed("Space");
+    }
+
+    static getPressedCodes(): string[]
+    {
+        return Array.from(KeyOperation.pressedCodes);
+    }
 }

package/src/LinkOperation.ts

@@ -1,102 +1,102 @@
-import { NavigateFunction, NavigateOptions } from "react-router-dom";
-import { KeyOperation } from "./KeyOperation";
-
-export enum LinkTarget
-{
-    Self = "_self",
-    Blank = "_blank",
-    Window = "_window",
-}
-
-export class LinkOperation
-{
-    private static navigate?: NavigateFunction;
-
-    static setNavigate(navigate: NavigateFunction): void
-    {
-        LinkOperation.navigate = navigate;
-    }
-
-    private static resolveTarget(target?: LinkTarget): LinkTarget
-    {
-        if (target)
-            return target;
-        if (KeyOperation.isShiftPressed())
-            return LinkTarget.Window;
-        if (KeyOperation.isControlPressed() || KeyOperation.isMetaPressed())
-            return LinkTarget.Blank;
-        return LinkTarget.Self;
-    }
-
-    private static isExternal(url: string): boolean
-    {
-        return /^[a-z][a-z0-9+.-]*:/i.test(url) || url.startsWith("//");
-    }
-
-    static open(url: string, target?: LinkTarget, options?: NavigateOptions): void
-    {
-        const resolved = LinkOperation.resolveTarget(target);
-        if (resolved === LinkTarget.Blank)
-        {
-            LinkOperation.openBlank(url);
-            return;
-        }
-        if (resolved === LinkTarget.Window)
-        {
-            LinkOperation.openWindow(url);
-            return;
-        }
-        if (LinkOperation.isExternal(url) || !LinkOperation.navigate)
-        {
-            window.location.href = url;
-            return;
-        }
-        LinkOperation.navigate(url, options);
-    }
-
-    static openBlank(url: string): void
-    {
-        if (typeof window === "undefined")
-            return;
-        window.open(url, "_blank", "noopener,noreferrer");
-    }
-
-    static openWindow(url: string): void
-    {
-        if (typeof window === "undefined")
-            return;
-        window.open(url, "_blank", "noopener,noreferrer,popup");
-    }
-
-    static openSelf(url: string, options?: NavigateOptions): void
-    {
-        LinkOperation.open(url, LinkTarget.Self, options);
-    }
-
-    static replace(url: string, options?: NavigateOptions): void
-    {
-        LinkOperation.open(url, LinkTarget.Self, { ...options, replace: true });
-    }
-
-    static back(): void
-    {
-        if (LinkOperation.navigate)
-            LinkOperation.navigate(-1);
-        else if (typeof window !== "undefined")
-            window.history.back();
-    }
-
-    static forward(): void
-    {
-        if (LinkOperation.navigate)
-            LinkOperation.navigate(1);
-        else if (typeof window !== "undefined")
-            window.history.forward();
-    }
-
-    static reload(): void
-    {
-        if (typeof window !== "undefined")
-            window.location.reload();
-    }
+import { NavigateFunction, NavigateOptions } from "react-router-dom";
+import { KeyOperation } from "./KeyOperation";
+
+export enum LinkTarget
+{
+    Self = "_self",
+    Blank = "_blank",
+    Window = "_window",
+}
+
+export class LinkOperation
+{
+    private static navigate?: NavigateFunction;
+
+    static setNavigate(navigate: NavigateFunction): void
+    {
+        LinkOperation.navigate = navigate;
+    }
+
+    private static resolveTarget(target?: LinkTarget): LinkTarget
+    {
+        if (target)
+            return target;
+        if (KeyOperation.isShiftPressed())
+            return LinkTarget.Window;
+        if (KeyOperation.isControlPressed() || KeyOperation.isMetaPressed())
+            return LinkTarget.Blank;
+        return LinkTarget.Self;
+    }
+
+    private static isExternal(url: string): boolean
+    {
+        return /^[a-z][a-z0-9+.-]*:/i.test(url) || url.startsWith("//");
+    }
+
+    static open(url: string, target?: LinkTarget, options?: NavigateOptions): void
+    {
+        const resolved = LinkOperation.resolveTarget(target);
+        if (resolved === LinkTarget.Blank)
+        {
+            LinkOperation.openBlank(url);
+            return;
+        }
+        if (resolved === LinkTarget.Window)
+        {
+            LinkOperation.openWindow(url);
+            return;
+        }
+        if (LinkOperation.isExternal(url) || !LinkOperation.navigate)
+        {
+            window.location.href = url;
+            return;
+        }
+        LinkOperation.navigate(url, options);
+    }
+
+    static openBlank(url: string): void
+    {
+        if (typeof window === "undefined")
+            return;
+        window.open(url, "_blank", "noopener,noreferrer");
+    }
+
+    static openWindow(url: string): void
+    {
+        if (typeof window === "undefined")
+            return;
+        window.open(url, "_blank", "noopener,noreferrer,popup");
+    }
+
+    static openSelf(url: string, options?: NavigateOptions): void
+    {
+        LinkOperation.open(url, LinkTarget.Self, options);
+    }
+
+    static replace(url: string, options?: NavigateOptions): void
+    {
+        LinkOperation.open(url, LinkTarget.Self, { ...options, replace: true });
+    }
+
+    static back(): void
+    {
+        if (LinkOperation.navigate)
+            LinkOperation.navigate(-1);
+        else if (typeof window !== "undefined")
+            window.history.back();
+    }
+
+    static forward(): void
+    {
+        if (LinkOperation.navigate)
+            LinkOperation.navigate(1);
+        else if (typeof window !== "undefined")
+            window.history.forward();
+    }
+
+    static reload(): void
+    {
+        if (typeof window !== "undefined")
+            window.location.reload();
+    }
 }