namirasoft-core 1.5.2 → 1.5.3

package/src/PhoneOperation.ts

@@ -1,9 +1,9 @@
-import * as Phone from 'phone';
-
-export class PhoneOperation
-{
-    static isValid(number: string): boolean
-    {
-        return Phone.phone(number).isValid;
-    }
+import * as Phone from 'phone';
+
+export class PhoneOperation
+{
+    static isValid(number: string): boolean
+    {
+        return Phone.phone(number).isValid;
+    }
 }

package/src/PriceOperation.ts

@@ -1,21 +1,21 @@
-export class PriceOperation
-{
-    static millicent_to_cent(millicent: number): number
-    {
-        return Math.round(millicent / 1000);
-    }
-    static millicent_to_fiat(millicent: number, decimal: number = 2): number
-    {
-        let thousand = Math.max(5 - decimal, 0);
-        let hundred = 5 - thousand;
-        return Math.round(millicent / Math.pow(10, thousand)) / Math.pow(10, hundred);
-    }
-    static cent_to_millicent(cent: number): number
-    {
-        return Math.floor(cent * 1000);
-    }
-    static fiat_to_millicent(fiat: number): number
-    {
-        return Math.floor(fiat * 100 * 1000);
-    }
+export class PriceOperation
+{
+    static millicent_to_cent(millicent: number): number
+    {
+        return Math.round(millicent / 1000);
+    }
+    static millicent_to_fiat(millicent: number, decimal: number = 2): number
+    {
+        let thousand = Math.max(5 - decimal, 0);
+        let hundred = 5 - thousand;
+        return Math.round(millicent / Math.pow(10, thousand)) / Math.pow(10, hundred);
+    }
+    static cent_to_millicent(cent: number): number
+    {
+        return Math.floor(cent * 1000);
+    }
+    static fiat_to_millicent(fiat: number): number
+    {
+        return Math.floor(fiat * 100 * 1000);
+    }
 }

package/src/SearchOperation.ts

@@ -1,32 +1,32 @@
-export class SearchOperation
-{
-    static getTokens(search: string): string[]
-    {
-        return search.split(' ').filter(x => x.trim()).map(x => x.toLowerCase());
-    }
-    static match(value: string | null, search: string, tokens: string[] = []): boolean
-    {
-        if (search)
-        {
-            if (!value)
-                return false;
-            if (tokens.length == 0)
-                tokens = search.split(' ').filter(x => x.trim()).map(x => x.toLowerCase());
-            let name = value.toLowerCase();
-            for (let i = 0; i < tokens.length; i++)
-                if (!name.toLowerCase().includes(tokens[i]))
-                    return false;
-        }
-        return true;
-    }
-    static filter<T>(array: T[], getValue: (item: T) => string, search: string): T[]
-    {
-        let ans = array;
-        if (search)
-        {
-            let tokens = this.getTokens(search);
-            ans = ans.filter((item) => SearchOperation.match(getValue(item), search, tokens));
-        }
-        return ans;
-    }
+export class SearchOperation
+{
+    static getTokens(search: string): string[]
+    {
+        return search.split(' ').filter(x => x.trim()).map(x => x.toLowerCase());
+    }
+    static match(value: string | null, search: string, tokens: string[] = []): boolean
+    {
+        if (search)
+        {
+            if (!value)
+                return false;
+            if (tokens.length == 0)
+                tokens = search.split(' ').filter(x => x.trim()).map(x => x.toLowerCase());
+            let name = value.toLowerCase();
+            for (let i = 0; i < tokens.length; i++)
+                if (!name.toLowerCase().includes(tokens[i]))
+                    return false;
+        }
+        return true;
+    }
+    static filter<T>(array: T[], getValue: (item: T) => string, search: string): T[]
+    {
+        let ans = array;
+        if (search)
+        {
+            let tokens = this.getTokens(search);
+            ans = ans.filter((item) => SearchOperation.match(getValue(item), search, tokens));
+        }
+        return ans;
+    }
 }

package/src/SetTimeouService.ts

@@ -1,33 +1,33 @@
-import { TimeOperation } from "./TimeOperation";
-
-export class SetTimeouService
-{
-    private last_date: Date = new Date();
-    private last_index: number = 0;
-    private onCalled(milliseconds: number)
-    {
-        this.last_index++;
-        let l = TimeOperation.millisecondsLater(milliseconds - 1, new Date());
-        if (this.last_date < l)
-            this.last_date = l;
-        return this.last_index;
-    }
-    setTimeoutIfNotCalledAgain(callback: () => void, milliseconds: number)
-    {
-        let index = this.onCalled(milliseconds);
-        setTimeout(() =>
-        {
-            if (index === this.last_index)
-                callback();
-        }, milliseconds);
-    }
-    setTimeoutIfFarArrival(callback: () => void, milliseconds: number)
-    {
-        this.onCalled(milliseconds);
-        setTimeout(() =>
-        {
-            if (this.last_date < new Date())
-                callback();
-        }, milliseconds);
-    }
+import { TimeOperation } from "./TimeOperation";
+
+export class SetTimeouService
+{
+    private last_date: Date = new Date();
+    private last_index: number = 0;
+    private onCalled(milliseconds: number)
+    {
+        this.last_index++;
+        let l = TimeOperation.millisecondsLater(milliseconds - 1, new Date());
+        if (this.last_date < l)
+            this.last_date = l;
+        return this.last_index;
+    }
+    setTimeoutIfNotCalledAgain(callback: () => void, milliseconds: number)
+    {
+        let index = this.onCalled(milliseconds);
+        setTimeout(() =>
+        {
+            if (index === this.last_index)
+                callback();
+        }, milliseconds);
+    }
+    setTimeoutIfFarArrival(callback: () => void, milliseconds: number)
+    {
+        this.onCalled(milliseconds);
+        setTimeout(() =>
+        {
+            if (this.last_date < new Date())
+                callback();
+        }, milliseconds);
+    }
 }

package/src/SortItem.ts

@@ -1,89 +1,89 @@
-import { BaseMetaColumn } from "./BaseMetaColumn";
-import { BaseMetaTable } from "./BaseMetaTable";
-import { EncodingOperation } from "./EncodingOperation";
-import { ErrorOperation } from "./ErrorOperation";
-
-export class SortItem
-{
-    public table: BaseMetaTable;
-    public column: BaseMetaColumn;
-    public ascending: boolean;
-    public static encode(sorts: SortItem[] | null): string
-    {
-        let value = this.stringify(sorts);
-        return EncodingOperation.Base64Encode(value);
-    }
-    public static decode(value: string): SortItem[] | null
-    {
-        let encoded = EncodingOperation.Base64Decode(value);
-        return this.parse(encoded);
-    }
-    public static stringify(sorts: SortItem[] | null): string
-    {
-        if (sorts)
-            return sorts.map(x => x.getCommand()).join(";");
-        return "";
-    }
-    public static parse(item: string | null): SortItem[]
-    {
-        let ans: SortItem[] = [];
-        if (item)
-        {
-            let index = 0;
-            let items = item.split(/(?<!\\);/);
-            let thereIsMore = (): boolean =>
-            {
-                return index < items.length;
-            };
-            let next = (name: string): string =>
-            {
-                if (thereIsMore())
-                    return items[index++];
-                throw ErrorOperation.getHTTP(400, `Next value is required for '${name}'. Must be separated by ;`);
-            };
-            while (thereIsMore())
-            {
-                let value_table = next("Table");
-                let table = new BaseMetaTable(null, value_table, value_table);
-
-                let value_column = next("Column");
-                let column = new BaseMetaColumn(table, value_column, value_column, "", false)
-
-                let value_asc = next("Asending").toLowerCase();
-                let asc = value_asc === "asc"
-                if (value_asc != "asc" && value_asc != "desc")
-                    ErrorOperation.throwHTTP(400, `Invalid value '${value_asc}' for SortItem.Asending, Only 'Asc' and 'Desc' are allowed.`);
-
-                ans.push(new SortItem(table, column, asc));
-            }
-        }
-        return ans;
-    }
-    constructor(table: BaseMetaTable, column: BaseMetaColumn, ascending: boolean)
-    {
-        this.table = table;
-        this.column = column;
-        this.ascending = ascending;
-    }
-    getCommand()
-    {
-        return [this.table.name, this.column.name, this.ascending ? "asc" : "desc"].join(";");
-    }
-    toString()
-    {
-        let ans = [];
-        if (this.table.text)
-            ans.push(this.table.text);
-        else
-            ans.push(this.table.name);
-        if (this.column.text)
-            ans.push(this.column.text);
-        else
-            ans.push(this.column.name);
-        if (this.ascending)
-            ans.push("Ascending");
-        else
-            ans.push("Descending");
-        return ans.filter(x => x).join(" ");
-    }
+import { BaseMetaColumn } from "./BaseMetaColumn";
+import { BaseMetaTable } from "./BaseMetaTable";
+import { EncodingOperation } from "./EncodingOperation";
+import { ErrorOperation } from "./ErrorOperation";
+
+export class SortItem
+{
+    public table: BaseMetaTable;
+    public column: BaseMetaColumn;
+    public ascending: boolean;
+    public static encode(sorts: SortItem[] | null): string
+    {
+        let value = this.stringify(sorts);
+        return EncodingOperation.Base64Encode(value);
+    }
+    public static decode(value: string): SortItem[] | null
+    {
+        let encoded = EncodingOperation.Base64Decode(value);
+        return this.parse(encoded);
+    }
+    public static stringify(sorts: SortItem[] | null): string
+    {
+        if (sorts)
+            return sorts.map(x => x.getCommand()).join(";");
+        return "";
+    }
+    public static parse(item: string | null): SortItem[]
+    {
+        let ans: SortItem[] = [];
+        if (item)
+        {
+            let index = 0;
+            let items = item.split(/(?<!\\);/);
+            let thereIsMore = (): boolean =>
+            {
+                return index < items.length;
+            };
+            let next = (name: string): string =>
+            {
+                if (thereIsMore())
+                    return items[index++];
+                throw ErrorOperation.getHTTP(400, `Next value is required for '${name}'. Must be separated by ;`);
+            };
+            while (thereIsMore())
+            {
+                let value_table = next("Table");
+                let table = new BaseMetaTable(null, value_table, value_table);
+
+                let value_column = next("Column");
+                let column = new BaseMetaColumn(table, value_column, value_column, "", false)
+
+                let value_asc = next("Asending").toLowerCase();
+                let asc = value_asc === "asc"
+                if (value_asc != "asc" && value_asc != "desc")
+                    ErrorOperation.throwHTTP(400, `Invalid value '${value_asc}' for SortItem.Asending, Only 'Asc' and 'Desc' are allowed.`);
+
+                ans.push(new SortItem(table, column, asc));
+            }
+        }
+        return ans;
+    }
+    constructor(table: BaseMetaTable, column: BaseMetaColumn, ascending: boolean)
+    {
+        this.table = table;
+        this.column = column;
+        this.ascending = ascending;
+    }
+    getCommand()
+    {
+        return [this.table.name, this.column.name, this.ascending ? "asc" : "desc"].join(";");
+    }
+    toString()
+    {
+        let ans = [];
+        if (this.table.text)
+            ans.push(this.table.text);
+        else
+            ans.push(this.table.name);
+        if (this.column.text)
+            ans.push(this.column.text);
+        else
+            ans.push(this.column.name);
+        if (this.ascending)
+            ans.push("Ascending");
+        else
+            ans.push("Descending");
+        return ans.filter(x => x).join(" ");
+    }
 }

package/src/StringOperation.ts

@@ -1,23 +1,23 @@
-export class StringOperation
-{
-    static split(text: string): string[]
-    {
-        return text.split(/[\s;,|]+/).filter(x => x);
-    }
-    static format(string: string, ...args: string[]): string
-    {
-        return string.replace(/{(\d+)}/g, (match, index) =>
-        {
-            const arg = args[index];
-            return typeof arg !== 'undefined' ? arg : match;
-        });
-    }
-    static repair(value: string): string
-    {
-        if (value == null)
-            value = '';
-        value = value.replace(/\s\s+/gm, ' ');
-        value = value.trim();
-        return value;
-    }
+export class StringOperation
+{
+    static split(text: string): string[]
+    {
+        return text.split(/[\s;,|]+/).filter(x => x);
+    }
+    static format(string: string, ...args: string[]): string
+    {
+        return string.replace(/{(\d+)}/g, (match, index) =>
+        {
+            const arg = args[index];
+            return typeof arg !== 'undefined' ? arg : match;
+        });
+    }
+    static repair(value: string): string
+    {
+        if (value == null)
+            value = '';
+        value = value.replace(/\s\s+/gm, ' ');
+        value = value.trim();
+        return value;
+    }
 }