namirasoft-site-react 1.4.561 → 1.4.562

package/src/ColorOperation.ts

@@ -1,154 +1,154 @@
-export class ColorOperation
-{
-    private static readonly GOLDEN_ANGLE = 137.508;
-    private static readonly BASE_HUE = 210;
-    private static readonly SATURATION = 68;
-    private static readonly LIGHTNESS = 56;
-
-    private index: number;
-
-    constructor(startIndex: number = 0)
-    {
-        this.index = startIndex;
-    }
-
-    generate(): string
-    {
-        return ColorOperation.at(this.index++);
-    }
-
-    peek(): string
-    {
-        return ColorOperation.at(this.index);
-    }
-
-    reset(startIndex: number = 0): void
-    {
-        this.index = startIndex;
-    }
-
-    static at(index: number): string
-    {
-        let hue = ColorOperation.normalizeHue(ColorOperation.BASE_HUE + index * ColorOperation.GOLDEN_ANGLE);
-        return ColorOperation.hslToHex(hue, ColorOperation.SATURATION, ColorOperation.LIGHTNESS);
-    }
-
-    static generate(count: number): string[]
-    {
-        let colors: string[] = [];
-        for (let i = 0; i < count; i++)
-            colors.push(ColorOperation.at(i));
-        return colors;
-    }
-
-    static random(): string
-    {
-        return ColorOperation.hslToHex(Math.random() * 360, ColorOperation.SATURATION, ColorOperation.LIGHTNESS);
-    }
-
-    static randoms(count: number): string[]
-    {
-        let start = Math.random() * 360;
-        let colors: string[] = [];
-        for (let i = 0; i < count; i++)
-        {
-            let hue = ColorOperation.normalizeHue(start + i * ColorOperation.GOLDEN_ANGLE);
-            colors.push(ColorOperation.hslToHex(hue, ColorOperation.SATURATION, ColorOperation.LIGHTNESS));
-        }
-        return colors;
-    }
-
-    static next(color: string): string
-    {
-        let { h, s, l } = ColorOperation.toHsl(color);
-        return ColorOperation.hslToHex(ColorOperation.normalizeHue(h + ColorOperation.GOLDEN_ANGLE), s, l);
-    }
-
-    static prev(color: string): string
-    {
-        let { h, s, l } = ColorOperation.toHsl(color);
-        return ColorOperation.hslToHex(ColorOperation.normalizeHue(h - ColorOperation.GOLDEN_ANGLE), s, l);
-    }
-
-    static hslToHex(h: number, s: number, l: number): string
-    {
-        h = ColorOperation.normalizeHue(h);
-        s = Math.max(0, Math.min(100, s)) / 100;
-        l = Math.max(0, Math.min(100, l)) / 100;
-
-        let c = (1 - Math.abs(2 * l - 1)) * s;
-        let x = c * (1 - Math.abs(((h / 60) % 2) - 1));
-        let m = l - c / 2;
-
-        let r = 0, g = 0, b = 0;
-        if (h < 60) { r = c; g = x; b = 0; }
-        else if (h < 120) { r = x; g = c; b = 0; }
-        else if (h < 180) { r = 0; g = c; b = x; }
-        else if (h < 240) { r = 0; g = x; b = c; }
-        else if (h < 300) { r = x; g = 0; b = c; }
-        else { r = c; g = 0; b = x; }
-
-        return ColorOperation.rgbToHex((r + m) * 255, (g + m) * 255, (b + m) * 255);
-    }
-
-    static toHsl(color: string): { h: number, s: number, l: number }
-    {
-        let trimmed = color.trim().toLowerCase();
-        if (trimmed.startsWith("hsl"))
-        {
-            let parts = trimmed.replace(/hsla?\(|\)|%/g, "").split(/[\s,/]+/).filter(Boolean);
-            return {
-                h: ColorOperation.normalizeHue(parseFloat(parts[0]) || 0),
-                s: parseFloat(parts[1]) || 0,
-                l: parseFloat(parts[2]) || 0,
-            };
-        }
-        let { r, g, b } = ColorOperation.hexToRgb(trimmed);
-        return ColorOperation.rgbToHsl(r, g, b);
-    }
-
-    private static normalizeHue(hue: number): number
-    {
-        return ((hue % 360) + 360) % 360;
-    }
-
-    private static hexToRgb(hex: string): { r: number, g: number, b: number }
-    {
-        let value = hex.replace("#", "");
-        if (value.length === 3)
-            value = value.split("").map(ch => ch + ch).join("");
-        let num = parseInt(value, 16);
-        return {
-            r: (num >> 16) & 255,
-            g: (num >> 8) & 255,
-            b: num & 255,
-        };
-    }
-
-    private static rgbToHex(r: number, g: number, b: number): string
-    {
-        let toHex = (v: number) => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, "0");
-        return `#${toHex(r)}${toHex(g)}${toHex(b)}`.toUpperCase();
-    }
-
-    private static rgbToHsl(r: number, g: number, b: number): { h: number, s: number, l: number }
-    {
-        r /= 255; g /= 255; b /= 255;
-        let max = Math.max(r, g, b), min = Math.min(r, g, b);
-        let l = (max + min) / 2;
-        let d = max - min;
-        let h = 0, s = 0;
-        if (d !== 0)
-        {
-            s = d / (1 - Math.abs(2 * l - 1));
-            switch (max)
-            {
-                case r: h = ((g - b) / d) % 6; break;
-                case g: h = (b - r) / d + 2; break;
-                default: h = (r - g) / d + 4; break;
-            }
-            h *= 60;
-        }
-        return { h: ColorOperation.normalizeHue(h), s: s * 100, l: l * 100 };
-    }
+export class ColorOperation
+{
+    private static readonly GOLDEN_ANGLE = 137.508;
+    private static readonly BASE_HUE = 210;
+    private static readonly SATURATION = 68;
+    private static readonly LIGHTNESS = 56;
+
+    private index: number;
+
+    constructor(startIndex: number = 0)
+    {
+        this.index = startIndex;
+    }
+
+    generate(): string
+    {
+        return ColorOperation.at(this.index++);
+    }
+
+    peek(): string
+    {
+        return ColorOperation.at(this.index);
+    }
+
+    reset(startIndex: number = 0): void
+    {
+        this.index = startIndex;
+    }
+
+    static at(index: number): string
+    {
+        let hue = ColorOperation.normalizeHue(ColorOperation.BASE_HUE + index * ColorOperation.GOLDEN_ANGLE);
+        return ColorOperation.hslToHex(hue, ColorOperation.SATURATION, ColorOperation.LIGHTNESS);
+    }
+
+    static generate(count: number): string[]
+    {
+        let colors: string[] = [];
+        for (let i = 0; i < count; i++)
+            colors.push(ColorOperation.at(i));
+        return colors;
+    }
+
+    static random(): string
+    {
+        return ColorOperation.hslToHex(Math.random() * 360, ColorOperation.SATURATION, ColorOperation.LIGHTNESS);
+    }
+
+    static randoms(count: number): string[]
+    {
+        let start = Math.random() * 360;
+        let colors: string[] = [];
+        for (let i = 0; i < count; i++)
+        {
+            let hue = ColorOperation.normalizeHue(start + i * ColorOperation.GOLDEN_ANGLE);
+            colors.push(ColorOperation.hslToHex(hue, ColorOperation.SATURATION, ColorOperation.LIGHTNESS));
+        }
+        return colors;
+    }
+
+    static next(color: string): string
+    {
+        let { h, s, l } = ColorOperation.toHsl(color);
+        return ColorOperation.hslToHex(ColorOperation.normalizeHue(h + ColorOperation.GOLDEN_ANGLE), s, l);
+    }
+
+    static prev(color: string): string
+    {
+        let { h, s, l } = ColorOperation.toHsl(color);
+        return ColorOperation.hslToHex(ColorOperation.normalizeHue(h - ColorOperation.GOLDEN_ANGLE), s, l);
+    }
+
+    static hslToHex(h: number, s: number, l: number): string
+    {
+        h = ColorOperation.normalizeHue(h);
+        s = Math.max(0, Math.min(100, s)) / 100;
+        l = Math.max(0, Math.min(100, l)) / 100;
+
+        let c = (1 - Math.abs(2 * l - 1)) * s;
+        let x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+        let m = l - c / 2;
+
+        let r = 0, g = 0, b = 0;
+        if (h < 60) { r = c; g = x; b = 0; }
+        else if (h < 120) { r = x; g = c; b = 0; }
+        else if (h < 180) { r = 0; g = c; b = x; }
+        else if (h < 240) { r = 0; g = x; b = c; }
+        else if (h < 300) { r = x; g = 0; b = c; }
+        else { r = c; g = 0; b = x; }
+
+        return ColorOperation.rgbToHex((r + m) * 255, (g + m) * 255, (b + m) * 255);
+    }
+
+    static toHsl(color: string): { h: number, s: number, l: number }
+    {
+        let trimmed = color.trim().toLowerCase();
+        if (trimmed.startsWith("hsl"))
+        {
+            let parts = trimmed.replace(/hsla?\(|\)|%/g, "").split(/[\s,/]+/).filter(Boolean);
+            return {
+                h: ColorOperation.normalizeHue(parseFloat(parts[0]) || 0),
+                s: parseFloat(parts[1]) || 0,
+                l: parseFloat(parts[2]) || 0,
+            };
+        }
+        let { r, g, b } = ColorOperation.hexToRgb(trimmed);
+        return ColorOperation.rgbToHsl(r, g, b);
+    }
+
+    private static normalizeHue(hue: number): number
+    {
+        return ((hue % 360) + 360) % 360;
+    }
+
+    private static hexToRgb(hex: string): { r: number, g: number, b: number }
+    {
+        let value = hex.replace("#", "");
+        if (value.length === 3)
+            value = value.split("").map(ch => ch + ch).join("");
+        let num = parseInt(value, 16);
+        return {
+            r: (num >> 16) & 255,
+            g: (num >> 8) & 255,
+            b: num & 255,
+        };
+    }
+
+    private static rgbToHex(r: number, g: number, b: number): string
+    {
+        let toHex = (v: number) => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, "0");
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}`.toUpperCase();
+    }
+
+    private static rgbToHsl(r: number, g: number, b: number): { h: number, s: number, l: number }
+    {
+        r /= 255; g /= 255; b /= 255;
+        let max = Math.max(r, g, b), min = Math.min(r, g, b);
+        let l = (max + min) / 2;
+        let d = max - min;
+        let h = 0, s = 0;
+        if (d !== 0)
+        {
+            s = d / (1 - Math.abs(2 * l - 1));
+            switch (max)
+            {
+                case r: h = ((g - b) / d) % 6; break;
+                case g: h = (b - r) / d + 2; break;
+                default: h = (r - g) / d + 4; break;
+            }
+            h *= 60;
+        }
+        return { h: ColorOperation.normalizeHue(h), s: s * 100, l: l * 100 };
+    }
 }

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