namirasoft-core 1.5.2 → 1.5.3

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

@@ -1,122 +1,122 @@
-export class CronOperation
-{
-    static splitPatterns(pattern: string): string[]
-    {
-        return pattern.split(',').map(p => p.trim()).filter(p => p);
-    }
-    static isValid(pattern: string): boolean
-    {
-        let patterns = CronOperation.splitPatterns(pattern);
-        if (patterns.length == 0)
-            return false;
-        if (patterns.length == 1)
-        {
-            let regexes = [/\*[/\d+]/gm, /\d+[/\d+]/gm, /\d+-\d+[/\d+]/gm]
-            for (let i = 0; i < regexes.length; i++)
-                if (regexes[i].test(patterns[0]))
-                    return true;
-            return false;
-        }
-        for (let i = 0; i < patterns.length; i++)
-            if (!CronOperation.isValid(patterns[i]))
-                return false;
-        return true;
-    }
-    static check(pattern: string): void
-    {
-        if (!CronOperation.isValid(pattern))
-            throw new Error("Invalid schedule/cron format. Use one of: *, */5, 8, 0-10, 2-10/3, or a comma-separated list (e.g. 0,4,5-10/2).");
-    }
-    static getNumbers(pattern: string, min: number, max: number): number[]
-    {
-        let patterns = CronOperation.splitPatterns(pattern);
-        let ans: number[] = [];
-        for (let i = 0; i < patterns.length; i++)
-        {
-            const element = patterns[i];
-            let ts = element.split('/').map(p => p.trim());
-            let step = ts.length == 1 ? 1 : parseInt(ts[1]);
-            if (element.includes("-"))
-            {
-                let ns = element.split('-').map(p => p.trim());
-                let from = parseInt(ns[0]);
-                let to = parseInt(ns[1]);
-                for (let p = from; p <= to; p += step)
-                    ans.push(p);
-            }
-            else if (element.includes("*"))
-                for (let p = min; p <= max; p += step)
-                    ans.push(p);
-            else
-                ans.push(parseInt(element));
-        }
-        ans = ans.sort();
-        ans.forEach(p =>
-        {
-            if (p < min)
-                throw new Error(`Number must be more than or equal to ${min}`);
-            if (p > max)
-                throw new Error(`Number must be less than or equal to ${max}`);
-        });
-        return ans;
-    }
-    static getNext(current: number, pattern: string, min: number, max?: number): { next: number, reset: boolean }
-    {
-        function getNextLoop(current: number, start: number, end: number | undefined, step: number)
-        {
-            if (current < start)
-                return start;
-            const offset = Math.ceil((current - start + 1) / step) * step;
-            const next = start + offset;
-            if (end == null)
-                return next;
-            return next > end ? start : next;
-        }
-        function forwardDistance(current: number, candidate: number, min: number, max?: number): number
-        {
-            if (max == null)
-                return candidate > current ? candidate - current : Infinity;
-            const ring = max - min + 1;
-            const curIdx = current - min;
-            const candIdx = candidate - min;
-            let dist = (candIdx - curIdx + ring) % ring;
-            if (dist === 0)
-                dist = ring;
-            return dist;
-        }
-
-        let patterns = CronOperation.splitPatterns(pattern);
-        let ans: number | null = null;
-        let bestDist = Infinity;
-        for (let i = 0; i < patterns.length; i++)
-        {
-            const element = patterns[i];
-            let ts = element.split('/').map(p => p.trim());
-            let step = ts.length == 1 ? 1 : parseInt(ts[1]);
-            let candidate: number;
-            if (element.includes("-"))
-            {
-                let ns = element.split('-').map(p => p.trim());
-                let start = Math.max(min, parseInt(ns[0]));
-                let end = Math.min(max ?? parseInt(ns[1]), parseInt(ns[1]));
-                candidate = getNextLoop(current, start, end, step);
-            }
-            else if (element.includes("*"))
-                candidate = getNextLoop(current, min, max, step);
-            else
-                candidate = parseInt(element);
-
-            const dist = forwardDistance(current, candidate, min, max);
-
-            if (dist < bestDist)
-            {
-                bestDist = dist;
-                ans = candidate;
-            }
-        }
-        let reset = false;
-        if (ans != null)
-            reset = ans <= current;
-        return { next: ans ?? current, reset };
-    }
+export class CronOperation
+{
+    static splitPatterns(pattern: string): string[]
+    {
+        return pattern.split(',').map(p => p.trim()).filter(p => p);
+    }
+    static isValid(pattern: string): boolean
+    {
+        let patterns = CronOperation.splitPatterns(pattern);
+        if (patterns.length == 0)
+            return false;
+        if (patterns.length == 1)
+        {
+            let regexes = [/\*[/\d+]/gm, /\d+[/\d+]/gm, /\d+-\d+[/\d+]/gm]
+            for (let i = 0; i < regexes.length; i++)
+                if (regexes[i].test(patterns[0]))
+                    return true;
+            return false;
+        }
+        for (let i = 0; i < patterns.length; i++)
+            if (!CronOperation.isValid(patterns[i]))
+                return false;
+        return true;
+    }
+    static check(pattern: string): void
+    {
+        if (!CronOperation.isValid(pattern))
+            throw new Error("Invalid schedule/cron format. Use one of: *, */5, 8, 0-10, 2-10/3, or a comma-separated list (e.g. 0,4,5-10/2).");
+    }
+    static getNumbers(pattern: string, min: number, max: number): number[]
+    {
+        let patterns = CronOperation.splitPatterns(pattern);
+        let ans: number[] = [];
+        for (let i = 0; i < patterns.length; i++)
+        {
+            const element = patterns[i];
+            let ts = element.split('/').map(p => p.trim());
+            let step = ts.length == 1 ? 1 : parseInt(ts[1]);
+            if (element.includes("-"))
+            {
+                let ns = element.split('-').map(p => p.trim());
+                let from = parseInt(ns[0]);
+                let to = parseInt(ns[1]);
+                for (let p = from; p <= to; p += step)
+                    ans.push(p);
+            }
+            else if (element.includes("*"))
+                for (let p = min; p <= max; p += step)
+                    ans.push(p);
+            else
+                ans.push(parseInt(element));
+        }
+        ans = ans.sort();
+        ans.forEach(p =>
+        {
+            if (p < min)
+                throw new Error(`Number must be more than or equal to ${min}`);
+            if (p > max)
+                throw new Error(`Number must be less than or equal to ${max}`);
+        });
+        return ans;
+    }
+    static getNext(current: number, pattern: string, min: number, max?: number): { next: number, reset: boolean }
+    {
+        function getNextLoop(current: number, start: number, end: number | undefined, step: number)
+        {
+            if (current < start)
+                return start;
+            const offset = Math.ceil((current - start + 1) / step) * step;
+            const next = start + offset;
+            if (end == null)
+                return next;
+            return next > end ? start : next;
+        }
+        function forwardDistance(current: number, candidate: number, min: number, max?: number): number
+        {
+            if (max == null)
+                return candidate > current ? candidate - current : Infinity;
+            const ring = max - min + 1;
+            const curIdx = current - min;
+            const candIdx = candidate - min;
+            let dist = (candIdx - curIdx + ring) % ring;
+            if (dist === 0)
+                dist = ring;
+            return dist;
+        }
+
+        let patterns = CronOperation.splitPatterns(pattern);
+        let ans: number | null = null;
+        let bestDist = Infinity;
+        for (let i = 0; i < patterns.length; i++)
+        {
+            const element = patterns[i];
+            let ts = element.split('/').map(p => p.trim());
+            let step = ts.length == 1 ? 1 : parseInt(ts[1]);
+            let candidate: number;
+            if (element.includes("-"))
+            {
+                let ns = element.split('-').map(p => p.trim());
+                let start = Math.max(min, parseInt(ns[0]));
+                let end = Math.min(max ?? parseInt(ns[1]), parseInt(ns[1]));
+                candidate = getNextLoop(current, start, end, step);
+            }
+            else if (element.includes("*"))
+                candidate = getNextLoop(current, min, max, step);
+            else
+                candidate = parseInt(element);
+
+            const dist = forwardDistance(current, candidate, min, max);
+
+            if (dist < bestDist)
+            {
+                bestDist = dist;
+                ans = candidate;
+            }
+        }
+        let reset = false;
+        if (ans != null)
+            reset = ans <= current;
+        return { next: ans ?? current, reset };
+    }
 }

package/src/EncodingOperation.ts

@@ -1,47 +1,47 @@
-export enum EncodingOperationPartType
-{
-    Text = "text",
-    Key = "key",
-}
-
-export type EncodingOperationPart =
-    | { type: EncodingOperationPartType.Text; text: string }
-    | { type: EncodingOperationPartType.Key; key: string; value: string };
-
-export class EncodingOperation
-{
-    static Base64Encode(message: string): string
-    {
-        const bytes = new TextEncoder().encode(message);
-        let binary = "";
-        bytes.forEach(b => binary += String.fromCharCode(b));
-        return btoa(binary);
-    }
-    static Base64Decode(message: string): string
-    {
-        const binary = atob(message);
-        const bytes = Uint8Array.from(binary, c => c.charCodeAt(0));
-        return new TextDecoder().decode(bytes);
-    }
-    static VariableToStringEncode(key: string, value: string): string
-    {
-        return `\${${key}:${value}}`;
-    }
-    static VariableToStringDecode(key: string, text: string): EncodingOperationPart[]
-    {
-        let parts: EncodingOperationPart[] = [];
-        let regex = new RegExp(`\\\$\\{${key}:([^}]+)\\}`, "g");
-        let last = 0;
-        let match: RegExpExecArray | null;
-        while ((match = regex.exec(text)) !== null)
-        {
-            if (match.index > last)
-                parts.push({ type: EncodingOperationPartType.Text, text: text.substring(last, match.index) });
-            parts.push({ type: EncodingOperationPartType.Key, key, value: match[1] });
-            last = match.index + match[0].length;
-        }
-        if (last < text.length)
-            parts.push({ type: EncodingOperationPartType.Text, text: text.substring(last) });
-        return parts;
-    }
+export enum EncodingOperationPartType
+{
+    Text = "text",
+    Key = "key",
+}
+
+export type EncodingOperationPart =
+    | { type: EncodingOperationPartType.Text; text: string }
+    | { type: EncodingOperationPartType.Key; key: string; value: string };
+
+export class EncodingOperation
+{
+    static Base64Encode(message: string): string
+    {
+        const bytes = new TextEncoder().encode(message);
+        let binary = "";
+        bytes.forEach(b => binary += String.fromCharCode(b));
+        return btoa(binary);
+    }
+    static Base64Decode(message: string): string
+    {
+        const binary = atob(message);
+        const bytes = Uint8Array.from(binary, c => c.charCodeAt(0));
+        return new TextDecoder().decode(bytes);
+    }
+    static VariableToStringEncode(key: string, value: string): string
+    {
+        return `\${${key}:${value}}`;
+    }
+    static VariableToStringDecode(key: string, text: string): EncodingOperationPart[]
+    {
+        let parts: EncodingOperationPart[] = [];
+        let regex = new RegExp(`\\\$\\{${key}:([^}]+)\\}`, "g");
+        let last = 0;
+        let match: RegExpExecArray | null;
+        while ((match = regex.exec(text)) !== null)
+        {
+            if (match.index > last)
+                parts.push({ type: EncodingOperationPartType.Text, text: text.substring(last, match.index) });
+            parts.push({ type: EncodingOperationPartType.Key, key, value: match[1] });
+            last = match.index + match[0].length;
+        }
+        if (last < text.length)
+            parts.push({ type: EncodingOperationPartType.Text, text: text.substring(last) });
+        return parts;
+    }
 }

package/src/EnvService.ts

@@ -1,29 +1,29 @@
-import { ConvertService } from "./ConvertService";
-
-export class EnvService extends ConvertService
-{
-    static isDebugMode()
-    {
-        let DEBUG = new EnvService("DEBUG", false).getBoolean(false);
-        let REACT_DEBUG = new EnvService("REACT_DEBUG", false).getBoolean(false);
-        return DEBUG || REACT_DEBUG;
-    }
-    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
+{
+    static isDebugMode()
+    {
+        let DEBUG = new EnvService("DEBUG", false).getBoolean(false);
+        let REACT_DEBUG = new EnvService("REACT_DEBUG", false).getBoolean(false);
+        return DEBUG || REACT_DEBUG;
+    }
+    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));
+    }
 }