namirasoft-core 1.4.12 → 1.4.13

package/src/FilterItem.ts

@@ -1,129 +1,129 @@
-import { BaseMetaColumn } from "./BaseMetaColumn";
-import { BaseMetaTable } from "./BaseMetaTable";
-import { EncodingOperation } from "./EncodingOperation";
-import { ErrorOperation } from "./ErrorOperation";
-import { FilterItemOperator } from "./FilterItemOperator";
-
-export class FilterItem
-{
-    public table: { name: string; text: string; };
-    public column: { name: string; text: string; };
-    public not: boolean;
-    public operator: FilterItemOperator;
-    public values: string[];
-    public static encode(filters: FilterItem[] | null): string
-    {
-        let value = this.stringify(filters);
-        return EncodingOperation.Base64Encode(value);
-    }
-    public static decode(value: string): FilterItem[] | null
-    {
-        let encoded = EncodingOperation.Base64Decode(value);
-        return this.parse(encoded);
-    }
-    public static stringify(filters: FilterItem[] | null): string
-    {
-        if (filters)
-            return filters.map(x => x.getCommand()).join(";");
-        return "";
-    }
-    public static parse(item: string | null): FilterItem[]
-    {
-        let ans: FilterItem[] = [];
-        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(value_table, value_table);
-
-                let value_column = next("Column");
-                let column = new BaseMetaColumn(value_column, value_column, "", false)
-
-                let value_not = next("Not");
-                let not = value_not != "0"
-                if (value_not != "0" && value_not != "1")
-                    ErrorOperation.throwHTTP(400, `Invalid value '${value_not}' for FilterItem.not, Only 0 and 1 are allowed.`);
-
-                let value_operator = next("Operator");
-                let operator = FilterItemOperator.getByName(value_operator);
-
-                let values: string[] = [];
-                for (let j = 0; j < operator.count; j++)
-                {
-                    let value_value = next("Value Number " + (j + 1));
-                    let value = value_value.replace(/\\;/gm, ";");
-                    values.push(value);
-                }
-
-                ans.push(new FilterItem(table, column, not, operator, ...values));
-            }
-        }
-        return ans;
-    }
-    public static test(filters: FilterItem[] | null, object: any): boolean
-    {
-        if (filters)
-        {
-            // todo
-            if (object)
-                return true;
-            return false;
-            // todo
-        }
-        return true;
-    }
-    constructor(table: { name: string; text: string; }, column: { name: string; text: string; }, not: boolean, operator: FilterItemOperator, ...values: string[])
-    {
-        this.table = table;
-        this.column = column;
-        this.not = not;
-        this.operator = operator;
-        this.values = values;
-        if (this.values.length != operator.count)
-            throw new Error(`Invalid count of values: ${this.values.length}.${operator.count} is required.`);
-    }
-    getCommand()
-    {
-        return [this.table.name, this.column.name, this.not ? "1" : "0", this.operator.name, ...this.values.map(x => (x ?? "").toString().replace(/;/gm, "\\;"))].join(";");
-    }
-    isAllColumns()
-    {
-        return this.column.name === "*";
-    }
-    toString()
-    {
-        let ans = [];
-        if (!this.isAllColumns())
-        {
-            let table;
-            let column;
-            if (this.table.text)
-                table = this.table.text;
-            else
-                table = this.table.name;
-            if (this.column.text)
-                column = this.column.text;
-            else
-                column = this.column.name;
-            ans.push([table, column].filter(x => x).join("."));
-        }
-        if (this.not)
-            ans.push("Not");
-        ans.push(this.operator.name);
-        ans.push(this.values.join(", "));
-        return ans.filter(x => x).join(" ");
-    }
+import { BaseMetaColumn } from "./BaseMetaColumn";
+import { BaseMetaTable } from "./BaseMetaTable";
+import { EncodingOperation } from "./EncodingOperation";
+import { ErrorOperation } from "./ErrorOperation";
+import { FilterItemOperator } from "./FilterItemOperator";
+
+export class FilterItem
+{
+    public table: { name: string; text: string; };
+    public column: { name: string; text: string; };
+    public not: boolean;
+    public operator: FilterItemOperator;
+    public values: string[];
+    public static encode(filters: FilterItem[] | null): string
+    {
+        let value = this.stringify(filters);
+        return EncodingOperation.Base64Encode(value);
+    }
+    public static decode(value: string): FilterItem[] | null
+    {
+        let encoded = EncodingOperation.Base64Decode(value);
+        return this.parse(encoded);
+    }
+    public static stringify(filters: FilterItem[] | null): string
+    {
+        if (filters)
+            return filters.map(x => x.getCommand()).join(";");
+        return "";
+    }
+    public static parse(item: string | null): FilterItem[]
+    {
+        let ans: FilterItem[] = [];
+        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(value_table, value_table);
+
+                let value_column = next("Column");
+                let column = new BaseMetaColumn(value_column, value_column, "", false)
+
+                let value_not = next("Not");
+                let not = value_not != "0"
+                if (value_not != "0" && value_not != "1")
+                    ErrorOperation.throwHTTP(400, `Invalid value '${value_not}' for FilterItem.not, Only 0 and 1 are allowed.`);
+
+                let value_operator = next("Operator");
+                let operator = FilterItemOperator.getByName(value_operator);
+
+                let values: string[] = [];
+                for (let j = 0; j < operator.count; j++)
+                {
+                    let value_value = next("Value Number " + (j + 1));
+                    let value = value_value.replace(/\\;/gm, ";");
+                    values.push(value);
+                }
+
+                ans.push(new FilterItem(table, column, not, operator, ...values));
+            }
+        }
+        return ans;
+    }
+    public static test(filters: FilterItem[] | null, object: any): boolean
+    {
+        if (filters)
+        {
+            // todo
+            if (object)
+                return true;
+            return false;
+            // todo
+        }
+        return true;
+    }
+    constructor(table: { name: string; text: string; }, column: { name: string; text: string; }, not: boolean, operator: FilterItemOperator, ...values: string[])
+    {
+        this.table = table;
+        this.column = column;
+        this.not = not;
+        this.operator = operator;
+        this.values = values;
+        if (this.values.length != operator.count)
+            throw new Error(`Invalid count of values: ${this.values.length}.${operator.count} is required.`);
+    }
+    getCommand()
+    {
+        return [this.table.name, this.column.name, this.not ? "1" : "0", this.operator.name, ...this.values.map(x => (x ?? "").toString().replace(/;/gm, "\\;"))].join(";");
+    }
+    isAllColumns()
+    {
+        return this.column.name === "*";
+    }
+    toString()
+    {
+        let ans = [];
+        if (!this.isAllColumns())
+        {
+            let table;
+            let column;
+            if (this.table.text)
+                table = this.table.text;
+            else
+                table = this.table.name;
+            if (this.column.text)
+                column = this.column.text;
+            else
+                column = this.column.name;
+            ans.push([table, column].filter(x => x).join("."));
+        }
+        if (this.not)
+            ans.push("Not");
+        ans.push(this.operator.name);
+        ans.push(this.values.join(", "));
+        return ans.filter(x => x).join(" ");
+    }
 }

package/src/FilterItemColumnType.ts

@@ -1,7 +1,7 @@
-export enum FilterItemColumnType 
-{
-    Any = "Any",
-    Boolean = "Boolean",
-    Number = "Number",
-    String = "String"
+export enum FilterItemColumnType 
+{
+    Any = "Any",
+    Boolean = "Boolean",
+    Number = "Number",
+    String = "String"
 };

package/src/FilterItemOperator.ts

@@ -1,52 +1,52 @@
-import { ErrorOperation } from "./ErrorOperation";
-import { FilterItemColumnType } from "./FilterItemColumnType";
-
-export class FilterItemOperator
-{
-    static all = {
-        equals: new FilterItemOperator("Equals", "=", 1, (_: FilterItemColumnType) => { return true; }),
-        contains: new FilterItemOperator("Contains", ":", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number || type == FilterItemColumnType.String; }),
-        regex: new FilterItemOperator("Regex", "*", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number || type == FilterItemColumnType.String; }),
-        empty: new FilterItemOperator("Empty", "?", 0, (type: FilterItemColumnType) => { return type != FilterItemColumnType.Any; }),
-        exists: new FilterItemOperator("Exists", "??", 0, (_: FilterItemColumnType, required: boolean) => { return !required; }),
-        startswith: new FilterItemOperator("Starts With", "(", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.String; }),
-        endswith: new FilterItemOperator("Ends With", ")", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.String; }),
-        lessthan: new FilterItemOperator("Less Than", "<", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number; }),
-        lessthanequal: new FilterItemOperator("Less Than Equal", "<=", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number; }),
-        morethan: new FilterItemOperator("More Than", ">", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number; }),
-        morethanequal: new FilterItemOperator("More Than Equal", ">=", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number; })
-    };
-    static getAll(): FilterItemOperator[]
-    {
-        return Object.keys(FilterItemOperator.all).map(name => (FilterItemOperator.all as any)[name]);
-    }
-    static getAllByType(type: FilterItemColumnType, required: boolean): FilterItemOperator[]
-    {
-        return FilterItemOperator.getAll().filter(f => f.accepts(type, required));
-    }
-    static getByName(name: string): FilterItemOperator
-    {
-        let found = (FilterItemOperator.all as any)[name.toLowerCase()];
-        if (!found)
-            ErrorOperation.throwHTTP(400, `Could not find operator by name: '${name}'. Valid values are ${this.getAll().map(x => x.name).join(",")}`);
-        return found;
-    }
-    static getBySign(sign: string): FilterItemOperator
-    {
-        let found = FilterItemOperator.getAll().filter(x => x.sign == sign);
-        if (found.length == 0)
-            ErrorOperation.throwHTTP(400, `Could not find operator by sign: '${sign}'. Valid values are ${this.getAll().map(x => x.sign).join(",")}`);
-        return found[0];
-    }
-    name: string;
-    sign: string;
-    count: number;
-    accepts: (type: FilterItemColumnType, required: boolean) => boolean;
-    constructor(name: string, sign: string, count: number, accepts: (type: FilterItemColumnType, required: boolean) => boolean)
-    {
-        this.name = name;
-        this.sign = sign;
-        this.count = count;
-        this.accepts = accepts;
-    }
+import { ErrorOperation } from "./ErrorOperation";
+import { FilterItemColumnType } from "./FilterItemColumnType";
+
+export class FilterItemOperator
+{
+    static all = {
+        equals: new FilterItemOperator("Equals", "=", 1, (_: FilterItemColumnType) => { return true; }),
+        contains: new FilterItemOperator("Contains", ":", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number || type == FilterItemColumnType.String; }),
+        regex: new FilterItemOperator("Regex", "*", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number || type == FilterItemColumnType.String; }),
+        empty: new FilterItemOperator("Empty", "?", 0, (type: FilterItemColumnType) => { return type != FilterItemColumnType.Any; }),
+        exists: new FilterItemOperator("Exists", "??", 0, (_: FilterItemColumnType, required: boolean) => { return !required; }),
+        startswith: new FilterItemOperator("Starts With", "(", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.String; }),
+        endswith: new FilterItemOperator("Ends With", ")", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.String; }),
+        lessthan: new FilterItemOperator("Less Than", "<", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number; }),
+        lessthanequal: new FilterItemOperator("Less Than Equal", "<=", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number; }),
+        morethan: new FilterItemOperator("More Than", ">", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number; }),
+        morethanequal: new FilterItemOperator("More Than Equal", ">=", 1, (type: FilterItemColumnType) => { return type == FilterItemColumnType.Number; })
+    };
+    static getAll(): FilterItemOperator[]
+    {
+        return Object.keys(FilterItemOperator.all).map(name => (FilterItemOperator.all as any)[name]);
+    }
+    static getAllByType(type: FilterItemColumnType, required: boolean): FilterItemOperator[]
+    {
+        return FilterItemOperator.getAll().filter(f => f.accepts(type, required));
+    }
+    static getByName(name: string): FilterItemOperator
+    {
+        let found = (FilterItemOperator.all as any)[name.toLowerCase()];
+        if (!found)
+            ErrorOperation.throwHTTP(400, `Could not find operator by name: '${name}'. Valid values are ${this.getAll().map(x => x.name).join(",")}`);
+        return found;
+    }
+    static getBySign(sign: string): FilterItemOperator
+    {
+        let found = FilterItemOperator.getAll().filter(x => x.sign == sign);
+        if (found.length == 0)
+            ErrorOperation.throwHTTP(400, `Could not find operator by sign: '${sign}'. Valid values are ${this.getAll().map(x => x.sign).join(",")}`);
+        return found[0];
+    }
+    name: string;
+    sign: string;
+    count: number;
+    accepts: (type: FilterItemColumnType, required: boolean) => boolean;
+    constructor(name: string, sign: string, count: number, accepts: (type: FilterItemColumnType, required: boolean) => boolean)
+    {
+        this.name = name;
+        this.sign = sign;
+        this.count = count;
+        this.accepts = accepts;
+    }
 }

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 = "GET",
-    POST = "POST",
-    PUT = "PUT",
-    DELETE = "DELETE"
+export enum HTTPMethod
+{
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "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/IStorageCookie.ts

@@ -1,53 +1,53 @@
-import { EncodingOperation } from "./EncodingOperation";
-import { IStorage } from "./IStorage";
-
-export class IStorageCookie extends IStorage
-{
-    private fixed: { [name: string]: string };
-    private cookies?: string;
-    constructor(fixed: { [name: string]: string }, cookies?: string)
-    {
-        super();
-        this.fixed = fixed;
-        this.cookies = cookies;
-    }
-    private getAll(): { [name: string]: string }
-    {
-        let ans: { [name: string]: string } = {};
-        let items = (this.cookies ?? document.cookie).split(";");
-        for (let i = 0; i < items.length; i++)
-        {
-            const ops = items[i].split("=");
-            ans[ops[0].trim()] = ops[1]?.trim().replace(/\%3D/gm, "=");
-        }
-        return ans;
-    }
-    override get(name: string, defaultValue: string)
-    {
-        try
-        {
-            let all = this.getAll();
-            return EncodingOperation.Base64Decode(all[name]) ?? defaultValue;
-        } catch (error)
-        {
-            return defaultValue;
-        }
-    }
-    override set(name: string, value: string)
-    {
-        try
-        {
-            let items = [];
-            for (let key of Object.keys(this.fixed))
-                items.push(`${key}=${this.fixed[key]}`);
-            items.push(`${name}=${EncodingOperation.Base64Encode(value)}`);
-            document.cookie = items.join(";");
-        } catch (error)
-        {
-        }
-    }
-    override del(name: string)
-    {
-        this.set(name, "");
-    }
+import { EncodingOperation } from "./EncodingOperation";
+import { IStorage } from "./IStorage";
+
+export class IStorageCookie extends IStorage
+{
+    private fixed: { [name: string]: string };
+    private cookies?: string;
+    constructor(fixed: { [name: string]: string }, cookies?: string)
+    {
+        super();
+        this.fixed = fixed;
+        this.cookies = cookies;
+    }
+    private getAll(): { [name: string]: string }
+    {
+        let ans: { [name: string]: string } = {};
+        let items = (this.cookies ?? document.cookie).split(";");
+        for (let i = 0; i < items.length; i++)
+        {
+            const ops = items[i].split("=");
+            ans[ops[0].trim()] = ops[1]?.trim().replace(/\%3D/gm, "=");
+        }
+        return ans;
+    }
+    override get(name: string, defaultValue: string)
+    {
+        try
+        {
+            let all = this.getAll();
+            return EncodingOperation.Base64Decode(all[name]) ?? defaultValue;
+        } catch (error)
+        {
+            return defaultValue;
+        }
+    }
+    override set(name: string, value: string)
+    {
+        try
+        {
+            let items = [];
+            for (let key of Object.keys(this.fixed))
+                items.push(`${key}=${this.fixed[key]}`);
+            items.push(`${name}=${EncodingOperation.Base64Encode(value)}`);
+            document.cookie = items.join(";");
+        } catch (error)
+        {
+        }
+    }
+    override del(name: string)
+    {
+        this.set(name, "");
+    }
 }