namirasoft-core 1.2.13 → 1.2.15

package/src/Country.ts

@@ -1,22 +1,22 @@
-export class Country
-{
-    continent: string = "";
-    name: string = "";
-    iso2: string = "";
-    iso3: string = "";
-    code: string = "";
-    european_union: boolean = false;
-    coeff: number;
-    other: string[] = [];
-    constructor(continent: string, name: string, iso2: string, iso3: string, code: string, european_union: boolean, coeff: number, other: string[] = [])
-    {
-        this.continent = continent;
-        this.name = name;
-        this.iso2 = iso2;
-        this.iso3 = iso3;
-        this.code = code;
-        this.european_union = european_union;
-        this.coeff = coeff;
-        this.other = other;
-    }
+export class Country
+{
+    continent: string = "";
+    name: string = "";
+    iso2: string = "";
+    iso3: string = "";
+    code: string = "";
+    european_union: boolean = false;
+    coeff: number;
+    other: string[] = [];
+    constructor(continent: string, name: string, iso2: string, iso3: string, code: string, european_union: boolean, coeff: number, other: string[] = [])
+    {
+        this.continent = continent;
+        this.name = name;
+        this.iso2 = iso2;
+        this.iso3 = iso3;
+        this.code = code;
+        this.european_union = european_union;
+        this.coeff = coeff;
+        this.other = other;
+    }
 }

package/src/CountryOperation.ts

@@ -1,99 +1,99 @@
-import { Country } from "./Country";
-import { Countries } from "./Countries";
-
-export class CountryOperation
-{
-    private static simplify(input: string): string
-    {
-        if (!input)
-            input = "";
-        let arr = [" ", ".", "/", "'", "\"", "?", "!", "-", "+", "_", '\$', "@", "%", " of ", " the ", " a ", " an "];
-        arr.map(pattern => input = input.split(pattern).join(""));
-        input = input.split("é").join("e");
-        return input.trim().toLowerCase();
-    }
-    static find(input: string): Country | null
-    {
-        if (!input)
-            input = "";
-        input = this.simplify(input);
-        if (input)
-            for (let country of Countries.getAll())
-            {
-                let values = [country.iso2, country.iso3, country.name];
-                if (input.startsWith(country.code))
-                    return country;
-                if (country.other)
-                    for (let i = 0; i < country.other.length; i++)
-                        values.push(country.other[i]);
-                for (let i = 0; i < values.length; i++)
-                    if (this.simplify(values[i]) === input)
-                        return country;
-            }
-        return null;
-    }
-    static findPhone(input: string): Country[]
-    {
-        if (!input)
-            input = "";
-        input = this.simplify(input);
-        let ans = [];
-        let max = 0;
-        if (input)
-            for (let country of Countries.getAll())
-                if (input.startsWith(country.code))
-                {
-                    ans.push(country);
-                    max = Math.max(country.code.length, max);
-                }
-        let res = [];
-        for (let i = 0; i < ans.length; i++)
-        {
-            if (ans[i].code.length == max)
-                res.push(ans[i]);
-        }
-        return res;
-    }
-    static isPhoneFromCountry(input: string, country: Country | string | null)
-    {
-        if (country instanceof String)
-            country = this.find(country as string);
-        let countries = this.findPhone(input);
-        if (country)
-            for (let i = 0; i < countries.length; i++)
-                if (this.areEqual([countries[i], country]))
-                    return true;
-        return false;
-    }
-    static areEqual(countries: (Country | string)[]): boolean
-    {
-        countries = countries.map(country =>
-        {
-            let c: Country | null = null;
-            if (country instanceof Country)
-                c = country;
-            else
-                c = this.find(country as string);
-            if (c)
-                return c.name;
-            throw new Error("Couldn't find country: " + country);
-        });
-        countries = countries.filter(v => v);
-        countries = countries.filter((v, i, a) => a.indexOf(v) === i);
-        return countries.length === 1;
-    }
-    static getCoeff(code: string, amount: number, times: number = 1): number
-    {
-        if (!times)
-            times = 1;
-        let country: Country | null = this.find(code);
-        let ans: number = country?.coeff ?? 0;
-        if (isNaN(ans))
-            ans = 0.1;
-        ans += Math.min(Math.max(1 - ans, 0), 1) * (times - 1) / times;
-        ans = Math.min(Math.max(ans, 0), 1);
-        if (amount)
-            ans = amount * ans;
-        return ans;
-    }
+import { Country } from "./Country";
+import { Countries } from "./Countries";
+
+export class CountryOperation
+{
+    private static simplify(input: string): string
+    {
+        if (!input)
+            input = "";
+        let arr = [" ", ".", "/", "'", "\"", "?", "!", "-", "+", "_", '\$', "@", "%", " of ", " the ", " a ", " an "];
+        arr.map(pattern => input = input.split(pattern).join(""));
+        input = input.split("é").join("e");
+        return input.trim().toLowerCase();
+    }
+    static find(input: string): Country | null
+    {
+        if (!input)
+            input = "";
+        input = this.simplify(input);
+        if (input)
+            for (let country of Countries.getAll())
+            {
+                let values = [country.iso2, country.iso3, country.name];
+                if (input.startsWith(country.code))
+                    return country;
+                if (country.other)
+                    for (let i = 0; i < country.other.length; i++)
+                        values.push(country.other[i]);
+                for (let i = 0; i < values.length; i++)
+                    if (this.simplify(values[i]) === input)
+                        return country;
+            }
+        return null;
+    }
+    static findPhone(input: string): Country[]
+    {
+        if (!input)
+            input = "";
+        input = this.simplify(input);
+        let ans = [];
+        let max = 0;
+        if (input)
+            for (let country of Countries.getAll())
+                if (input.startsWith(country.code))
+                {
+                    ans.push(country);
+                    max = Math.max(country.code.length, max);
+                }
+        let res = [];
+        for (let i = 0; i < ans.length; i++)
+        {
+            if (ans[i].code.length == max)
+                res.push(ans[i]);
+        }
+        return res;
+    }
+    static isPhoneFromCountry(input: string, country: Country | string | null)
+    {
+        if (country instanceof String)
+            country = this.find(country as string);
+        let countries = this.findPhone(input);
+        if (country)
+            for (let i = 0; i < countries.length; i++)
+                if (this.areEqual([countries[i], country]))
+                    return true;
+        return false;
+    }
+    static areEqual(countries: (Country | string)[]): boolean
+    {
+        countries = countries.map(country =>
+        {
+            let c: Country | null = null;
+            if (country instanceof Country)
+                c = country;
+            else
+                c = this.find(country as string);
+            if (c)
+                return c.name;
+            throw new Error("Couldn't find country: " + country);
+        });
+        countries = countries.filter(v => v);
+        countries = countries.filter((v, i, a) => a.indexOf(v) === i);
+        return countries.length === 1;
+    }
+    static getCoeff(code: string, amount: number, times: number = 1): number
+    {
+        if (!times)
+            times = 1;
+        let country: Country | null = this.find(code);
+        let ans: number = country?.coeff ?? 0;
+        if (isNaN(ans))
+            ans = 0.1;
+        ans += Math.min(Math.max(1 - ans, 0), 1) * (times - 1) / times;
+        ans = Math.min(Math.max(ans, 0), 1);
+        if (amount)
+            ans = amount * ans;
+        return ans;
+    }
 }

package/src/EncryptionOperation.ts

@@ -1,30 +1,41 @@
-import * as crypto from 'node:crypto';
-
-export class EncryptionOperation
-{
-    private static encrypt<T>(algorithm: string, secret: string, message: T): string
-    {
-        const iv = Buffer.alloc(16, 0);
-        const cipher = crypto.createCipheriv(algorithm, secret, iv);
-        return cipher.update(JSON.stringify(message), 'utf8', 'hex') + cipher.final('hex');
-    }
-    private static decrypt<T>(algorithm: string, secret: string, message: string): T
-    {
-        let encryptedText = Buffer.from(message, 'hex');
-
-        const iv = Buffer.alloc(16, 0);
-        const decipher = crypto.createDecipheriv(algorithm, secret, iv);
-
-        let decrypted = decipher.update(encryptedText);
-        decrypted = Buffer.concat([decrypted, decipher.final()]);
-        return JSON.parse(decrypted.toString());
-    }
-    static AES256CCMEncrypt<T>(secret: string, message: T): string
-    {
-        return EncryptionOperation.encrypt("aes-256-ccm", secret, message);
-    }
-    static AES256CCMDecrypt<T>(secret: string, message: string): T
-    {
-        return EncryptionOperation.decrypt("aes-256-ccm", secret, message);
-    }
+import * as crypto from 'node:crypto';
+
+export class EncryptionOperation
+{
+    private static encrypt<T>(algorithm: string, secret: string, message: T): string
+    {
+        if (secret.length != 32)
+            throw new Error("Secret length must be exactly 32");
+        const secretBytes = Buffer.from(secret);
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv(algorithm, secretBytes, iv);
+        const encrypted = Buffer.concat([cipher.update(JSON.stringify(message), 'utf8'), cipher.final()]);
+        const authTag = (cipher as any).getAuthTag();
+        const ivHex = iv.toString('hex');
+        const authTagHex = authTag.toString('hex');
+        const encryptedHex = encrypted.toString('hex');
+        return [ivHex, authTagHex, encryptedHex].join(";");
+    }
+    private static decrypt<T>(algorithm: string, secret: string, message: string): T
+    {
+        const [ivHex, authTagHex, encryptedHex] = message.split(';');
+        const iv = Buffer.from(ivHex, 'hex');
+        const authTag = Buffer.from(authTagHex, 'hex');
+        const encrypte = Buffer.from(encryptedHex, 'hex');
+
+        const decipher = crypto.createDecipheriv(algorithm, secret, iv);
+        (decipher as any).setAuthTag(authTag);
+
+        let decrypted = decipher.update(encrypte);
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        return JSON.parse(decrypted.toString());
+    }
+    static AES256GCMEncrypt<T>(secret: string, message: T): string
+    {
+        return EncryptionOperation.encrypt("aes-256-gcm", secret, message);
+    }
+    static AES256GCMDecrypt<T>(secret: string, message: string): T
+    {
+        return EncryptionOperation.decrypt("aes-256-gcm", secret, message);
+    }
 }

package/src/ErrorOperation.ts

@@ -1,14 +1,14 @@
-import { HTTPError } from "./HTTPError";
-import { StringOperation } from "./StringOperation";
-
-export class ErrorOperation
-{
-    static throwHTTP(code: number, message: string, ...args: string[])
-    {
-        throw this.getHTTP(code, message, ...args);
-    }
-    static getHTTP(code: number, message: string, ...args: string[])
-    {
-        return new HTTPError(code, StringOperation.format(message, ...args));
-    }
+import { HTTPError } from "./HTTPError";
+import { StringOperation } from "./StringOperation";
+
+export class ErrorOperation
+{
+    static throwHTTP(code: number, message: string, ...args: string[])
+    {
+        throw this.getHTTP(code, message, ...args);
+    }
+    static getHTTP(code: number, message: string, ...args: string[])
+    {
+        return new HTTPError(code, StringOperation.format(message, ...args));
+    }
 }

package/src/FileOperation.ts

@@ -1,51 +1,51 @@
-let fs: any;
-let path: any;
-if (typeof window === 'undefined')
-{
-    fs = require('fs');
-    path = require('path');
-}
-export class FileOperation
-{
-    static findUp(fileName: string): string[]
-    {
-        let currentDir: string = __dirname;
-        const rootDir: string = process.cwd();
-        const foundFilePaths: string[] = [];
-        function searchRecursively(dir: string)
-        {
-            const files: string[] = fs.readdirSync(dir);
-            if (files.includes(fileName))
-                foundFilePaths.push(path.join(dir, fileName));
-            if (rootDir === dir)
-                return;
-            searchRecursively(path.dirname(dir));
-        }
-        searchRecursively(currentDir);
-        return foundFilePaths;
-    }
-    static async foreachFolder(base: string, handler: (base: string, sub: string, full: string) => Promise<void>, folders: boolean = true, files: boolean = true)
-    {
-        async function recursive(base: string, sub: string)
-        {
-            let files_folders = fs.readdirSync(path.join(base, sub));
-            for (let folder of files_folders)
-            {
-                let s = path.join(sub, folder)
-                let p = path.join(base, s);
-                if (fs.statSync(p).isDirectory())
-                {
-                    if (folders)
-                        await handler(base, sub, folder);
-                    await recursive(base, s);
-                }
-                else
-                {
-                    if (files)
-                        await handler(base, sub, folder);
-                }
-            }
-        }
-        await recursive(base, "");
-    }
+let fs: any;
+let path: any;
+if (typeof window === 'undefined')
+{
+    fs = require('fs');
+    path = require('path');
+}
+export class FileOperation
+{
+    static findUp(fileName: string): string[]
+    {
+        let currentDir: string = __dirname;
+        const rootDir: string = process.cwd();
+        const foundFilePaths: string[] = [];
+        function searchRecursively(dir: string)
+        {
+            const files: string[] = fs.readdirSync(dir);
+            if (files.includes(fileName))
+                foundFilePaths.push(path.join(dir, fileName));
+            if (rootDir === dir)
+                return;
+            searchRecursively(path.dirname(dir));
+        }
+        searchRecursively(currentDir);
+        return foundFilePaths;
+    }
+    static async foreachFolder(base: string, handler: (base: string, sub: string, full: string) => Promise<void>, folders: boolean = true, files: boolean = true)
+    {
+        async function recursive(base: string, sub: string)
+        {
+            let files_folders = fs.readdirSync(path.join(base, sub));
+            for (let folder of files_folders)
+            {
+                let s = path.join(sub, folder)
+                let p = path.join(base, s);
+                if (fs.statSync(p).isDirectory())
+                {
+                    if (folders)
+                        await handler(base, sub, folder);
+                    await recursive(base, s);
+                }
+                else
+                {
+                    if (files)
+                        await handler(base, sub, folder);
+                }
+            }
+        }
+        await recursive(base, "");
+    }
 }

package/src/GeoOperation.ts

@@ -1,19 +1,19 @@
-export class GeoOperation
-{
-    static distance(lat1: number, lng1: number, lat2: number, lng2: number)
-    {
-        function degreeToRadian(degree: number)
-        {
-            return degree * Math.PI / 180;
-        }
-        let R = 6371; // km
-        let dLat = degreeToRadian(lat2 - lat1);
-        let dLng = degreeToRadian(lng2 - lng1);
-        lat1 = degreeToRadian(lat1);
-        lat2 = degreeToRadian(lat2);
-        let a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-            Math.sin(dLng / 2) * Math.sin(dLng / 2) * Math.cos(lat1) * Math.cos(lat2);
-        let c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-        return R * c;
-    }
+export class GeoOperation
+{
+    static distance(lat1: number, lng1: number, lat2: number, lng2: number)
+    {
+        function degreeToRadian(degree: number)
+        {
+            return degree * Math.PI / 180;
+        }
+        let R = 6371; // km
+        let dLat = degreeToRadian(lat2 - lat1);
+        let dLng = degreeToRadian(lng2 - lng1);
+        lat1 = degreeToRadian(lat1);
+        lat2 = degreeToRadian(lat2);
+        let a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+            Math.sin(dLng / 2) * Math.sin(dLng / 2) * Math.cos(lat1) * Math.cos(lat2);
+        let c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        return R * c;
+    }
 }

package/src/HTTPError.ts

@@ -1,9 +1,9 @@
-export class HTTPError extends Error
-{
-    code: number;
-    constructor(code: number, message: string)
-    {
-        super(message);
-        this.code = code;
-    }
+export class HTTPError extends Error
+{
+    code: number;
+    constructor(code: number, message: string)
+    {
+        super(message);
+        this.code = code;
+    }
 }

package/src/HTTPMethod.ts

@@ -1,7 +1,7 @@
-export enum HTTPMethod
-{
-    GET,
-    POST,
-    PUT,
-    DELETE
+export enum HTTPMethod
+{
+    GET,
+    POST,
+    PUT,
+    DELETE
 }

package/src/HashOperation.ts

@@ -1,25 +1,25 @@
-import * as crypto from 'node:crypto';
-
-export class HashOperation
-{
-    static SHA256<T>(message: T): string
-    {
-        const hash = crypto.createHash('sha256');
-        hash.update(JSON.stringify(message));
-        return hash.digest('hex');
-    }
-    static SHA256Secret<T>(secret: string, message: T): string
-    {
-        const hash = crypto.createHmac('sha256', secret);
-        hash.update(JSON.stringify(message));
-        return hash.digest('hex');
-    }
-    static isValidSHA256(values: any, signature: string)
-    {
-        return this.SHA256(values).toLowerCase() === signature.toLowerCase();
-    }
-    static isValidSHA256Secret(secret: string, values: any, signature: string)
-    {
-        return this.SHA256Secret(secret, values).toLowerCase() === signature.toLowerCase();
-    }
+import * as crypto from 'node:crypto';
+
+export class HashOperation
+{
+    static SHA256<T>(message: T): string
+    {
+        const hash = crypto.createHash('sha256');
+        hash.update(JSON.stringify(message));
+        return hash.digest('hex');
+    }
+    static SHA256Secret<T>(secret: string, message: T): string
+    {
+        const hash = crypto.createHmac('sha256', secret);
+        hash.update(JSON.stringify(message));
+        return hash.digest('hex');
+    }
+    static isValidSHA256(values: any, signature: string)
+    {
+        return this.SHA256(values).toLowerCase() === signature.toLowerCase();
+    }
+    static isValidSHA256Secret(secret: string, values: any, signature: string)
+    {
+        return this.SHA256Secret(secret, values).toLowerCase() === signature.toLowerCase();
+    }
 }

package/src/IStorage.ts

@@ -1,6 +1,6 @@
-export abstract class IStorage
-{
-    abstract get(name: string, defaultValue: string): string;
-    abstract set(name: string, value: string): void;
-    abstract del(name: string): void;
+export abstract class IStorage
+{
+    abstract get(name: string, defaultValue: string): string;
+    abstract set(name: string, value: string): void;
+    abstract del(name: string): void;
 }

package/src/IStorageLocal.ts

@@ -1,17 +1,17 @@
-import { IStorage } from "./IStorage.js";
-
-export class IStorageLocal extends IStorage
-{
-    override get(name: string, defaultValue: string)
-    {
-        return localStorage.getItem(name) ?? defaultValue;
-    }
-    override set(name: string, value: string)
-    {
-        localStorage.setItem(name, value);
-    }
-    override del(name: string)
-    {
-        localStorage.removeItem(name);
-    }
+import { IStorage } from "./IStorage.js";
+
+export class IStorageLocal extends IStorage
+{
+    override get(name: string, defaultValue: string)
+    {
+        return localStorage.getItem(name) ?? defaultValue;
+    }
+    override set(name: string, value: string)
+    {
+        localStorage.setItem(name, value);
+    }
+    override del(name: string)
+    {
+        localStorage.removeItem(name);
+    }
 }

package/src/IStorageMemory.ts

@@ -1,18 +1,18 @@
-import { IStorage } from "./IStorage";
-
-export class IStorageMemory extends IStorage
-{
-    static data: { [name: string]: string } = {};
-    override get(name: string, defaultValue: string)
-    {
-        return IStorageMemory.data[name] ?? defaultValue;
-    }
-    override set(name: string, value: string)
-    {
-        IStorageMemory.data[name] = value;
-    }
-    override del(name: string)
-    {
-        delete IStorageMemory.data[name];
-    }
+import { IStorage } from "./IStorage";
+
+export class IStorageMemory extends IStorage
+{
+    static data: { [name: string]: string } = {};
+    override get(name: string, defaultValue: string)
+    {
+        return IStorageMemory.data[name] ?? defaultValue;
+    }
+    override set(name: string, value: string)
+    {
+        IStorageMemory.data[name] = value;
+    }
+    override del(name: string)
+    {
+        delete IStorageMemory.data[name];
+    }
 }