namirasoft-site-react 1.5.26 → 1.5.28

package/src/BrowserDetector.ts

@@ -1,110 +1,110 @@
-export enum Browser
-{
-    Chrome = "Chrome",
-    Edge = "Edge",
-    Brave = "Brave",
-    Opera = "Opera",
-    Samsung = "Samsung",
-    Firefox = "Firefox",
-    Safari = "Safari",
-    Unknown = "Unknown",
-}
-
-interface UserAgentBrand
-{
-    brand: string;
-    version: string;
-}
-
-interface UserAgentData
-{
-    brands: UserAgentBrand[];
-    mobile: boolean;
-    platform: string;
-}
-
-export class BrowserDetector
-{
-    private static cached?: Browser;
-
-    private static get userAgentData(): UserAgentData | undefined
-    {
-        if (typeof navigator === "undefined")
-            return undefined;
-        return (navigator as any).userAgentData as UserAgentData | undefined;
-    }
-
-    private static getUserAgent(): string
-    {
-        if (typeof navigator === "undefined")
-            return "";
-        return navigator.userAgent;
-    }
-
-    private static isBrave(): boolean
-    {
-        return typeof navigator !== "undefined" && (navigator as any).brave !== undefined;
-    }
-
-    private static detectFromBrands(brands: UserAgentBrand[]): Browser | undefined
-    {
-        const names = brands.map(entry => entry.brand.toLowerCase());
-        const has = (value: string): boolean => names.some(name => name.includes(value));
-
-        if (BrowserDetector.isBrave())
-            return Browser.Brave;
-        if (has("microsoft edge"))
-            return Browser.Edge;
-        if (has("opera"))
-            return Browser.Opera;
-        if (has("samsung"))
-            return Browser.Samsung;
-        if (has("google chrome") || has("chromium"))
-            return Browser.Chrome;
-
-        return undefined;
-    }
-
-    private static detectFromUserAgent(): Browser
-    {
-        const ua = BrowserDetector.getUserAgent();
-
-        if (BrowserDetector.isBrave())
-            return Browser.Brave;
-        if (ua.includes("Edg/"))
-            return Browser.Edge;
-        if (ua.includes("OPR/") || ua.includes("Opera/"))
-            return Browser.Opera;
-        if (ua.includes("SamsungBrowser/"))
-            return Browser.Samsung;
-        if (ua.includes("Firefox/"))
-            return Browser.Firefox;
-        if (ua.includes("Chrome/"))
-            return Browser.Chrome;
-        if (ua.includes("Safari/"))
-            return Browser.Safari;
-
-        return Browser.Unknown;
-    }
-
-    static detect(): Browser
-    {
-        if (BrowserDetector.cached)
-            return BrowserDetector.cached;
-
-        const data = BrowserDetector.userAgentData;
-        const detected = data ? BrowserDetector.detectFromBrands(data.brands) : undefined;
-        BrowserDetector.cached = detected ?? BrowserDetector.detectFromUserAgent();
-        return BrowserDetector.cached;
-    }
-
-    static is(browser: Browser): boolean
-    {
-        return BrowserDetector.detect() === browser;
-    }
-
-    static reset(): void
-    {
-        BrowserDetector.cached = undefined;
-    }
+export enum Browser
+{
+    Chrome = "Chrome",
+    Edge = "Edge",
+    Brave = "Brave",
+    Opera = "Opera",
+    Samsung = "Samsung",
+    Firefox = "Firefox",
+    Safari = "Safari",
+    Unknown = "Unknown",
+}
+
+interface UserAgentBrand
+{
+    brand: string;
+    version: string;
+}
+
+interface UserAgentData
+{
+    brands: UserAgentBrand[];
+    mobile: boolean;
+    platform: string;
+}
+
+export class BrowserDetector
+{
+    private static cached?: Browser;
+
+    private static get userAgentData(): UserAgentData | undefined
+    {
+        if (typeof navigator === "undefined")
+            return undefined;
+        return (navigator as any).userAgentData as UserAgentData | undefined;
+    }
+
+    private static getUserAgent(): string
+    {
+        if (typeof navigator === "undefined")
+            return "";
+        return navigator.userAgent;
+    }
+
+    private static isBrave(): boolean
+    {
+        return typeof navigator !== "undefined" && (navigator as any).brave !== undefined;
+    }
+
+    private static detectFromBrands(brands: UserAgentBrand[]): Browser | undefined
+    {
+        const names = brands.map(entry => entry.brand.toLowerCase());
+        const has = (value: string): boolean => names.some(name => name.includes(value));
+
+        if (BrowserDetector.isBrave())
+            return Browser.Brave;
+        if (has("microsoft edge"))
+            return Browser.Edge;
+        if (has("opera"))
+            return Browser.Opera;
+        if (has("samsung"))
+            return Browser.Samsung;
+        if (has("google chrome") || has("chromium"))
+            return Browser.Chrome;
+
+        return undefined;
+    }
+
+    private static detectFromUserAgent(): Browser
+    {
+        const ua = BrowserDetector.getUserAgent();
+
+        if (BrowserDetector.isBrave())
+            return Browser.Brave;
+        if (ua.includes("Edg/"))
+            return Browser.Edge;
+        if (ua.includes("OPR/") || ua.includes("Opera/"))
+            return Browser.Opera;
+        if (ua.includes("SamsungBrowser/"))
+            return Browser.Samsung;
+        if (ua.includes("Firefox/"))
+            return Browser.Firefox;
+        if (ua.includes("Chrome/"))
+            return Browser.Chrome;
+        if (ua.includes("Safari/"))
+            return Browser.Safari;
+
+        return Browser.Unknown;
+    }
+
+    static detect(): Browser
+    {
+        if (BrowserDetector.cached)
+            return BrowserDetector.cached;
+
+        const data = BrowserDetector.userAgentData;
+        const detected = data ? BrowserDetector.detectFromBrands(data.brands) : undefined;
+        BrowserDetector.cached = detected ?? BrowserDetector.detectFromUserAgent();
+        return BrowserDetector.cached;
+    }
+
+    static is(browser: Browser): boolean
+    {
+        return BrowserDetector.detect() === browser;
+    }
+
+    static reset(): void
+    {
+        BrowserDetector.cached = undefined;
+    }
 }

package/src/Color.tsx

@@ -1,11 +1,11 @@
-export class Color
-{
-    static getColor(percentage: number): string
-    {
-        if (percentage >= 75) return '#368F01';
-        if (percentage >= 60) return ' #44B400';
-        if (percentage >= 50) return '#56E500';
-        if (percentage >= 25) return '#FAFF00';
-        return 'red';
-    }
+export class Color
+{
+    static getColor(percentage: number): string
+    {
+        if (percentage >= 75) return '#368F01';
+        if (percentage >= 60) return ' #44B400';
+        if (percentage >= 50) return '#56E500';
+        if (percentage >= 25) return '#FAFF00';
+        return 'red';
+    }
 }

package/src/CopyToClipboard.ts

@@ -1,7 +1,7 @@
-export class CopyToClipboard
-{
-    static copyToClipboard(value: string): void
-    {
-        navigator.clipboard.writeText(value);
-    }
+export class CopyToClipboard
+{
+    static copyToClipboard(value: string): void
+    {
+        navigator.clipboard.writeText(value);
+    }
 };

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);
+    }
 }