namirasoft-core 1.4.12 → 1.4.13

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/EncodingOperation.ts

@@ -1,13 +1,13 @@
-import { Buffer } from 'buffer';
-
-export class EncodingOperation
-{
-    static Base64Encode(message: string): string
-    {
-        return Buffer.from(message).toString("base64");
-    }
-    static Base64Decode(message: string): string
-    {
-        return atob(message);
-    }
+import { Buffer } from 'buffer';
+
+export class EncodingOperation
+{
+    static Base64Encode(message: string): string
+    {
+        return Buffer.from(message).toString("base64");
+    }
+    static Base64Decode(message: string): string
+    {
+        return atob(message);
+    }
 }

package/src/EncryptionOperation.ts

@@ -1,41 +1,41 @@
-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);
-    }
+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/EnvService.ts

@@ -1,23 +1,23 @@
-import { ConvertService } from "./ConvertService";
-
-export class EnvService extends ConvertService
-{
-    name: string;
-    constructor(name: string, mandatory: boolean = false)
-    {
-        super(mandatory);
-        this.name = name;
-    }
-    override getNullString()
-    {
-        let ans = process.env[this.name];
-        if (ans)
-            return ans;
-        return null;
-    }
-    protected override onMandatoryError(): void
-    {
-        if (!process.env.NAMIRASOFT_MUTE)
-            throw new Error(`Env value was not provided: ${this.name}`);
-    }
+import { ConvertService } from "./ConvertService";
+
+export class EnvService extends ConvertService
+{
+    name: string;
+    constructor(name: string, mandatory: boolean = false)
+    {
+        super(mandatory);
+        this.name = name;
+    }
+    override getNullString()
+    {
+        let ans = process.env[this.name];
+        if (ans)
+            return ans;
+        return null;
+    }
+    protected override onMandatoryError(): void
+    {
+        if (!process.env.NAMIRASOFT_MUTE)
+            throw new Error(`Env value was not provided: ${this.name}`);
+    }
 }

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,58 +1,58 @@
-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;
-            let new_dir = path.dirname(dir);
-            if (new_dir == dir)
-                return;
-            searchRecursively(new_dir);
-        }
-        searchRecursively(currentDir);
-        return foundFilePaths;
-    }
-    static async foreach(base: string, handler: (base: string, sub: string, name: string, full: string, isFolder: boolean) => Promise<boolean>, folders: boolean = true, files: boolean = true)
-    {
-        async function recursive(base: string, sub: string)
-        {
-            let names = fs.readdirSync(path.join(base, sub));
-            for (let name of names)
-            {
-                let newSub = path.join(sub, name)
-                let full = path.join(base, newSub);
-                if (fs.statSync(full).isDirectory())
-                {
-                    if (folders)
-                    {
-                        let moveon = await handler(base, sub, name, full, true);
-                        if (!moveon)
-                            continue;
-                    }
-                    await recursive(base, newSub);
-                }
-                else
-                {
-                    if (files)
-                        await handler(base, sub, name, full, false);
-                }
-            }
-        }
-        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;
+            let new_dir = path.dirname(dir);
+            if (new_dir == dir)
+                return;
+            searchRecursively(new_dir);
+        }
+        searchRecursively(currentDir);
+        return foundFilePaths;
+    }
+    static async foreach(base: string, handler: (base: string, sub: string, name: string, full: string, isFolder: boolean) => Promise<boolean>, folders: boolean = true, files: boolean = true)
+    {
+        async function recursive(base: string, sub: string)
+        {
+            let names = fs.readdirSync(path.join(base, sub));
+            for (let name of names)
+            {
+                let newSub = path.join(sub, name)
+                let full = path.join(base, newSub);
+                if (fs.statSync(full).isDirectory())
+                {
+                    if (folders)
+                    {
+                        let moveon = await handler(base, sub, name, full, true);
+                        if (!moveon)
+                            continue;
+                    }
+                    await recursive(base, newSub);
+                }
+                else
+                {
+                    if (files)
+                        await handler(base, sub, name, full, false);
+                }
+            }
+        }
+        await recursive(base, "");
+    }
 }