namirasoft-core 1.5.2 → 1.5.3

package/src/NamingConvention.ts

@@ -1,200 +1,200 @@
-export class NamingConvention
-{
-    public static abbreviations: string[] = [
-        "ID", "AWS", "NWS", "FTP", "SFTP", "SMTP", "API", "AI", "CPU", "DB", "DNS", "HTML", "CSS", "JSON", "HTTP", "HTTPS", "IP", "YAML", "YML", "NFS", "OS", "SQL", "TCP", "UDP", "SSL", "TLS", "UI", "UID",
-        "URL", "URI", "UTC", "XML", "CLI", "FIFO", "LIFO", "GPU", "GCP", "SMS",
-        "EBS", "EFS", "S3",
-        "KB", "MB", "GB", "TB", "PB",
-        "SSO", "OIDC",
-        "LLM", "SID", "ERP",
-        "GitHub", "GitLab",
-    ];
-    static combineSingleCharacters(words: string[])
-    {
-        let combined = [];
-        let single_found: boolean = false;
-        for (let i = 0; i < words.length; i++)
-        {
-            let word = words[i];
-            if (word)
-            {
-                if (word.length > 1)
-                {
-                    combined.push(word);
-                    single_found = false;
-                }
-                else
-                {
-                    if (i == 0 || !single_found)
-                    {
-                        combined.push(word);
-                        single_found = true;
-                    }
-                    else
-                    {
-                        combined[combined.length - 1] += word;
-                        if (this.abbreviations.includes(combined[combined.length - 1]))
-                            single_found = false;
-                    }
-                }
-            }
-        }
-        return combined;
-    }
-    public static formatter_lower = (word: string) =>
-    {
-        if (word)
-            return word.toString().toLowerCase();
-        return "";
-    };
-    public static formatter_upper = (word: string) =>
-    {
-        if (word)
-            return word.toString().toUpperCase();
-        return "";
-    };
-    public static formatter_pascal = (word: string) =>
-    {
-        if (word)
-            if (this.abbreviations.includes(word.toString().toUpperCase()))
-                return word.toString().toUpperCase();
-        if (word)
-            return word[0].toUpperCase() + word.substring(1).toLowerCase();
-        return "";
-    };
-    public static formatter_camel = (word: string, index: number) =>
-    {
-        if (word)
-            if (this.abbreviations.includes(word.toString().toUpperCase()))
-                return word.toString().toUpperCase();
-        if (index == 0)
-            return NamingConvention.formatter_lower(word);
-        return NamingConvention.formatter_pascal(word);
-    };
-    public static formatter_sentence = (word: string, index: number) =>
-    {
-        if (word)
-            if (this.abbreviations.includes(word.toString().toUpperCase()))
-                return word.toString().toUpperCase();
-        if (index != 0)
-            return NamingConvention.formatter_lower(word);
-        return NamingConvention.formatter_pascal(word);
-    };
-    public static splitter_multi = (name: string, ...splitters: ((name: string) => string[])[]) =>
-    {
-        let ans = [name];
-        for (let i = 0; i < splitters.length; i++)
-        {
-            const splitter = splitters[i];
-            let words = [];
-            for (let word of ans)
-                if (word)
-                    if (this.abbreviations.includes(word.toString().toUpperCase()))
-                        words.push(word);
-                    else
-                        words.push(...splitter(word));
-            ans = words;
-        }
-        return ans;
-    };
-    public static splitter_normal = (name: string, delimiter: string) =>
-    {
-        return name.split(delimiter);
-    };
-    public static splitter_pascal = (name: string, delimiter: string) =>
-    {
-        return NamingConvention.splitter_multi(name, NamingConvention.splitter_uppercase, (w) => NamingConvention.splitter_normal(w, delimiter));
-    };
-    public static splitter_uppercase = (name: string) =>
-    {
-        let ans = name.split(/(?=[A-Z])/);
-        ans = NamingConvention.combineSingleCharacters(ans);
-        return ans;
-    };
-    public static splitter_none = (name: string) =>
-    {
-        return [name];
-    };
-    public static splitter_all = (name: string) =>
-    {
-        return NamingConvention.splitter_multi(name,
-            (w) => NamingConvention.splitter_normal(w, ' '),
-            (w) => NamingConvention.splitter_normal(w, '/'),
-            (w) => NamingConvention.splitter_normal(w, '-'),
-            (w) => NamingConvention.splitter_normal(w, '_'),
-            (w) => NamingConvention.splitter_normal(w, '\\'),
-            (w) => NamingConvention.splitter_normal(w, '.'),
-            (w) => NamingConvention.splitter_normal(w, '.'),
-            NamingConvention.splitter_uppercase
-        );
-    };
-    public static auto: NamingConvention = new NamingConvention("auto", "", false, () => { throw new Error("NamingConvention.auto can not be used to format") }, NamingConvention.splitter_all);
-
-    public static lower_case: NamingConvention = new NamingConvention("lowercase", "", false, NamingConvention.formatter_lower, NamingConvention.splitter_none);
-    public static UPPER_CASE: NamingConvention = new NamingConvention("UPPERCASE", "", false, NamingConvention.formatter_upper, NamingConvention.splitter_none);
-    public static Pascal_Case: NamingConvention = new NamingConvention("PascalCase", "", true, NamingConvention.formatter_pascal, NamingConvention.splitter_uppercase);
-    public static camel_Case: NamingConvention = new NamingConvention("camelCase", "", true, NamingConvention.formatter_camel, NamingConvention.splitter_uppercase);
-    public static First_word_case: NamingConvention = new NamingConvention("Firstwordcase", "", false, NamingConvention.formatter_sentence, NamingConvention.splitter_none);
-
-    public static lower_case_underscore: NamingConvention = new NamingConvention("snake_case", "_", false, NamingConvention.formatter_lower, NamingConvention.splitter_normal);
-    public static UPPER_CASE_UNDERSCORE: NamingConvention = new NamingConvention("SNAKE_CASE", "_", false, NamingConvention.formatter_upper, NamingConvention.splitter_normal);
-    public static Pascal_Case_Underscore: NamingConvention = new NamingConvention("Pascal_CASE", "_", true, NamingConvention.formatter_pascal, NamingConvention.splitter_pascal);
-    public static camel_Case_Underscore: NamingConvention = new NamingConvention("camel_Case", "_", true, NamingConvention.formatter_camel, NamingConvention.splitter_normal);
-    public static First_word_case_underscore: NamingConvention = new NamingConvention("First_word_case", "_", false, NamingConvention.formatter_sentence, NamingConvention.splitter_normal);
-
-    public static lower_case_dash: NamingConvention = new NamingConvention("kebab-case", "-", false, NamingConvention.formatter_lower, NamingConvention.splitter_normal);
-    public static UPPER_CASE_DASH: NamingConvention = new NamingConvention("UPPER-CASE", "-", false, NamingConvention.formatter_upper, NamingConvention.splitter_normal);
-    public static Pascal_Case_Dash: NamingConvention = new NamingConvention("Pascal-Case", "-", true, NamingConvention.formatter_pascal, NamingConvention.splitter_pascal);
-    public static camel_Case_Dash: NamingConvention = new NamingConvention("camel-Case", "-", true, NamingConvention.formatter_camel, NamingConvention.splitter_normal);
-    public static First_word_case_dash: NamingConvention = new NamingConvention("First-word-case", "-", false, NamingConvention.formatter_sentence, NamingConvention.splitter_normal);
-
-    public static lower_case_dot: NamingConvention = new NamingConvention("domain.case", ".", false, NamingConvention.formatter_lower, NamingConvention.splitter_normal);
-    public static UPPER_CASE_DOT: NamingConvention = new NamingConvention("UPPER.CASE", ".", false, NamingConvention.formatter_upper, NamingConvention.splitter_normal);
-    public static Pascal_Case_Dot: NamingConvention = new NamingConvention("Pascal.Case", ".", true, NamingConvention.formatter_pascal, NamingConvention.splitter_pascal);
-    public static camel_Case_Dot: NamingConvention = new NamingConvention("camel.Case", ".", true, NamingConvention.formatter_camel, NamingConvention.splitter_normal);
-    public static First_word_case_dot: NamingConvention = new NamingConvention("First.word.case", ".", false, NamingConvention.formatter_sentence, NamingConvention.splitter_normal);
-
-    public static lower_case_space: NamingConvention = new NamingConvention("lower case", " ", false, NamingConvention.formatter_lower, NamingConvention.splitter_normal);
-    public static UPPER_CASE_SPACE: NamingConvention = new NamingConvention("UPPRE CASE", " ", false, NamingConvention.formatter_upper, NamingConvention.splitter_normal);
-    public static Pascal_Case_Space: NamingConvention = new NamingConvention("Title Case", " ", true, NamingConvention.formatter_pascal, NamingConvention.splitter_pascal);
-    public static camel_Case_Space: NamingConvention = new NamingConvention("camel Case", " ", true, NamingConvention.formatter_camel, NamingConvention.splitter_normal);
-    public static First_word_case_space: NamingConvention = new NamingConvention("Sentence case", " ", false, NamingConvention.formatter_sentence, NamingConvention.splitter_normal);
-
-    public static lower_case_slash: NamingConvention = new NamingConvention("path/case", "/", false, NamingConvention.formatter_lower, NamingConvention.splitter_normal);
-    public static UPPER_CASE_SLASH: NamingConvention = new NamingConvention("UPPER/CASE", "/", false, NamingConvention.formatter_upper, NamingConvention.splitter_normal);
-    public static Pascal_Case_Slash: NamingConvention = new NamingConvention("Pascal/Case", "/", true, NamingConvention.formatter_pascal, NamingConvention.splitter_pascal);
-    public static camel_Case_Slash: NamingConvention = new NamingConvention("camel/Case", "/", true, NamingConvention.formatter_camel, NamingConvention.splitter_normal);
-    public static First_word_case_slash: NamingConvention = new NamingConvention("First/word/case", "/", false, NamingConvention.formatter_sentence, NamingConvention.splitter_normal);
-    public name: string;
-    public delimiter: string;
-    public revertable: boolean;
-    formatter: (word: string, index: number) => string;
-    splitter: (name: string, delimiter: string) => string[];
-    constructor(name: string, delimiter: string, revertable: boolean, formatter: (word: string, index: number) => string, splitter: (name: string, delimiter: string) => string[])
-    {
-        this.name = name;
-        this.delimiter = delimiter;
-        this.revertable = revertable;
-        this.formatter = formatter;
-        this.splitter = splitter;
-    }
-    getWords(name: string)
-    {
-        let ans = this.splitter(name, this.delimiter);
-        ans = ans.filter(w => w);
-        return ans;
-    }
-    convertByWords(words: string[], revertable: boolean = true)
-    {
-        for (let i = 0; i < words.length; i++)
-            words[i] = this.formatter(words[i], i);
-        if (this.revertable || !revertable)
-            words = NamingConvention.combineSingleCharacters(words);
-        return words.join(this.delimiter);
-    }
-    convert(name: string, to: NamingConvention, revertable: boolean = true)
-    {
-        let words = this.getWords(name);
-        return to.convertByWords(words, revertable);
-    }
+export class NamingConvention
+{
+    public static abbreviations: string[] = [
+        "ID", "AWS", "NWS", "FTP", "SFTP", "SMTP", "API", "AI", "CPU", "DB", "DNS", "HTML", "CSS", "JSON", "HTTP", "HTTPS", "IP", "YAML", "YML", "NFS", "OS", "SQL", "TCP", "UDP", "SSL", "TLS", "UI", "UID",
+        "URL", "URI", "UTC", "XML", "CLI", "FIFO", "LIFO", "GPU", "GCP", "SMS",
+        "EBS", "EFS", "S3",
+        "KB", "MB", "GB", "TB", "PB",
+        "SSO", "OIDC",
+        "LLM", "SID", "ERP",
+        "GitHub", "GitLab",
+    ];
+    static combineSingleCharacters(words: string[])
+    {
+        let combined = [];
+        let single_found: boolean = false;
+        for (let i = 0; i < words.length; i++)
+        {
+            let word = words[i];
+            if (word)
+            {
+                if (word.length > 1)
+                {
+                    combined.push(word);
+                    single_found = false;
+                }
+                else
+                {
+                    if (i == 0 || !single_found)
+                    {
+                        combined.push(word);
+                        single_found = true;
+                    }
+                    else
+                    {
+                        combined[combined.length - 1] += word;
+                        if (this.abbreviations.includes(combined[combined.length - 1]))
+                            single_found = false;
+                    }
+                }
+            }
+        }
+        return combined;
+    }
+    public static formatter_lower = (word: string) =>
+    {
+        if (word)
+            return word.toString().toLowerCase();
+        return "";
+    };
+    public static formatter_upper = (word: string) =>
+    {
+        if (word)
+            return word.toString().toUpperCase();
+        return "";
+    };
+    public static formatter_pascal = (word: string) =>
+    {
+        if (word)
+            if (this.abbreviations.includes(word.toString().toUpperCase()))
+                return word.toString().toUpperCase();
+        if (word)
+            return word[0].toUpperCase() + word.substring(1).toLowerCase();
+        return "";
+    };
+    public static formatter_camel = (word: string, index: number) =>
+    {
+        if (word)
+            if (this.abbreviations.includes(word.toString().toUpperCase()))
+                return word.toString().toUpperCase();
+        if (index == 0)
+            return NamingConvention.formatter_lower(word);
+        return NamingConvention.formatter_pascal(word);
+    };
+    public static formatter_sentence = (word: string, index: number) =>
+    {
+        if (word)
+            if (this.abbreviations.includes(word.toString().toUpperCase()))
+                return word.toString().toUpperCase();
+        if (index != 0)
+            return NamingConvention.formatter_lower(word);
+        return NamingConvention.formatter_pascal(word);
+    };
+    public static splitter_multi = (name: string, ...splitters: ((name: string) => string[])[]) =>
+    {
+        let ans = [name];
+        for (let i = 0; i < splitters.length; i++)
+        {
+            const splitter = splitters[i];
+            let words = [];
+            for (let word of ans)
+                if (word)
+                    if (this.abbreviations.includes(word.toString().toUpperCase()))
+                        words.push(word);
+                    else
+                        words.push(...splitter(word));
+            ans = words;
+        }
+        return ans;
+    };
+    public static splitter_normal = (name: string, delimiter: string) =>
+    {
+        return name.split(delimiter);
+    };
+    public static splitter_pascal = (name: string, delimiter: string) =>
+    {
+        return NamingConvention.splitter_multi(name, NamingConvention.splitter_uppercase, (w) => NamingConvention.splitter_normal(w, delimiter));
+    };
+    public static splitter_uppercase = (name: string) =>
+    {
+        let ans = name.split(/(?=[A-Z])/);
+        ans = NamingConvention.combineSingleCharacters(ans);
+        return ans;
+    };
+    public static splitter_none = (name: string) =>
+    {
+        return [name];
+    };
+    public static splitter_all = (name: string) =>
+    {
+        return NamingConvention.splitter_multi(name,
+            (w) => NamingConvention.splitter_normal(w, ' '),
+            (w) => NamingConvention.splitter_normal(w, '/'),
+            (w) => NamingConvention.splitter_normal(w, '-'),
+            (w) => NamingConvention.splitter_normal(w, '_'),
+            (w) => NamingConvention.splitter_normal(w, '\\'),
+            (w) => NamingConvention.splitter_normal(w, '.'),
+            (w) => NamingConvention.splitter_normal(w, '.'),
+            NamingConvention.splitter_uppercase
+        );
+    };
+    public static auto: NamingConvention = new NamingConvention("auto", "", false, () => { throw new Error("NamingConvention.auto can not be used to format") }, NamingConvention.splitter_all);
+
+    public static lower_case: NamingConvention = new NamingConvention("lowercase", "", false, NamingConvention.formatter_lower, NamingConvention.splitter_none);
+    public static UPPER_CASE: NamingConvention = new NamingConvention("UPPERCASE", "", false, NamingConvention.formatter_upper, NamingConvention.splitter_none);
+    public static Pascal_Case: NamingConvention = new NamingConvention("PascalCase", "", true, NamingConvention.formatter_pascal, NamingConvention.splitter_uppercase);
+    public static camel_Case: NamingConvention = new NamingConvention("camelCase", "", true, NamingConvention.formatter_camel, NamingConvention.splitter_uppercase);
+    public static First_word_case: NamingConvention = new NamingConvention("Firstwordcase", "", false, NamingConvention.formatter_sentence, NamingConvention.splitter_none);
+
+    public static lower_case_underscore: NamingConvention = new NamingConvention("snake_case", "_", false, NamingConvention.formatter_lower, NamingConvention.splitter_normal);
+    public static UPPER_CASE_UNDERSCORE: NamingConvention = new NamingConvention("SNAKE_CASE", "_", false, NamingConvention.formatter_upper, NamingConvention.splitter_normal);
+    public static Pascal_Case_Underscore: NamingConvention = new NamingConvention("Pascal_CASE", "_", true, NamingConvention.formatter_pascal, NamingConvention.splitter_pascal);
+    public static camel_Case_Underscore: NamingConvention = new NamingConvention("camel_Case", "_", true, NamingConvention.formatter_camel, NamingConvention.splitter_normal);
+    public static First_word_case_underscore: NamingConvention = new NamingConvention("First_word_case", "_", false, NamingConvention.formatter_sentence, NamingConvention.splitter_normal);
+
+    public static lower_case_dash: NamingConvention = new NamingConvention("kebab-case", "-", false, NamingConvention.formatter_lower, NamingConvention.splitter_normal);
+    public static UPPER_CASE_DASH: NamingConvention = new NamingConvention("UPPER-CASE", "-", false, NamingConvention.formatter_upper, NamingConvention.splitter_normal);
+    public static Pascal_Case_Dash: NamingConvention = new NamingConvention("Pascal-Case", "-", true, NamingConvention.formatter_pascal, NamingConvention.splitter_pascal);
+    public static camel_Case_Dash: NamingConvention = new NamingConvention("camel-Case", "-", true, NamingConvention.formatter_camel, NamingConvention.splitter_normal);
+    public static First_word_case_dash: NamingConvention = new NamingConvention("First-word-case", "-", false, NamingConvention.formatter_sentence, NamingConvention.splitter_normal);
+
+    public static lower_case_dot: NamingConvention = new NamingConvention("domain.case", ".", false, NamingConvention.formatter_lower, NamingConvention.splitter_normal);
+    public static UPPER_CASE_DOT: NamingConvention = new NamingConvention("UPPER.CASE", ".", false, NamingConvention.formatter_upper, NamingConvention.splitter_normal);
+    public static Pascal_Case_Dot: NamingConvention = new NamingConvention("Pascal.Case", ".", true, NamingConvention.formatter_pascal, NamingConvention.splitter_pascal);
+    public static camel_Case_Dot: NamingConvention = new NamingConvention("camel.Case", ".", true, NamingConvention.formatter_camel, NamingConvention.splitter_normal);
+    public static First_word_case_dot: NamingConvention = new NamingConvention("First.word.case", ".", false, NamingConvention.formatter_sentence, NamingConvention.splitter_normal);
+
+    public static lower_case_space: NamingConvention = new NamingConvention("lower case", " ", false, NamingConvention.formatter_lower, NamingConvention.splitter_normal);
+    public static UPPER_CASE_SPACE: NamingConvention = new NamingConvention("UPPRE CASE", " ", false, NamingConvention.formatter_upper, NamingConvention.splitter_normal);
+    public static Pascal_Case_Space: NamingConvention = new NamingConvention("Title Case", " ", true, NamingConvention.formatter_pascal, NamingConvention.splitter_pascal);
+    public static camel_Case_Space: NamingConvention = new NamingConvention("camel Case", " ", true, NamingConvention.formatter_camel, NamingConvention.splitter_normal);
+    public static First_word_case_space: NamingConvention = new NamingConvention("Sentence case", " ", false, NamingConvention.formatter_sentence, NamingConvention.splitter_normal);
+
+    public static lower_case_slash: NamingConvention = new NamingConvention("path/case", "/", false, NamingConvention.formatter_lower, NamingConvention.splitter_normal);
+    public static UPPER_CASE_SLASH: NamingConvention = new NamingConvention("UPPER/CASE", "/", false, NamingConvention.formatter_upper, NamingConvention.splitter_normal);
+    public static Pascal_Case_Slash: NamingConvention = new NamingConvention("Pascal/Case", "/", true, NamingConvention.formatter_pascal, NamingConvention.splitter_pascal);
+    public static camel_Case_Slash: NamingConvention = new NamingConvention("camel/Case", "/", true, NamingConvention.formatter_camel, NamingConvention.splitter_normal);
+    public static First_word_case_slash: NamingConvention = new NamingConvention("First/word/case", "/", false, NamingConvention.formatter_sentence, NamingConvention.splitter_normal);
+    public name: string;
+    public delimiter: string;
+    public revertable: boolean;
+    formatter: (word: string, index: number) => string;
+    splitter: (name: string, delimiter: string) => string[];
+    constructor(name: string, delimiter: string, revertable: boolean, formatter: (word: string, index: number) => string, splitter: (name: string, delimiter: string) => string[])
+    {
+        this.name = name;
+        this.delimiter = delimiter;
+        this.revertable = revertable;
+        this.formatter = formatter;
+        this.splitter = splitter;
+    }
+    getWords(name: string)
+    {
+        let ans = this.splitter(name, this.delimiter);
+        ans = ans.filter(w => w);
+        return ans;
+    }
+    convertByWords(words: string[], revertable: boolean = true)
+    {
+        for (let i = 0; i < words.length; i++)
+            words[i] = this.formatter(words[i], i);
+        if (this.revertable || !revertable)
+            words = NamingConvention.combineSingleCharacters(words);
+        return words.join(this.delimiter);
+    }
+    convert(name: string, to: NamingConvention, revertable: boolean = true)
+    {
+        let words = this.getWords(name);
+        return to.convertByWords(words, revertable);
+    }
 }

package/src/ObjectService.ts

@@ -1,28 +1,28 @@
-import { ConvertService } from "./ConvertService";
-import { ParsedNameValue } from "./ParsedNameValue";
-
-export class ObjectService extends ConvertService
-{
-    static isClass(obj: any)
-    {
-        return typeof obj === 'function' && /^\s*class\s+/.test(obj.toString());
-    }
-    private object: ParsedNameValue;
-    constructor(object: ParsedNameValue, mandatory: boolean = false)
-    {
-        super(mandatory);
-        this.object = object;
-    }
-    override getNullString()
-    {
-        let ans: string | null = null;
-        if (Array.isArray(this.object))
-        {
-            if (this.object.length > 0)
-                ans = this.object.join(",");
-        }
-        else if (this.object != null && this.object != undefined)
-            ans = this.object + "";
-        return ans;
-    }
+import { ConvertService } from "./ConvertService";
+import { ParsedNameValue } from "./ParsedNameValue";
+
+export class ObjectService extends ConvertService
+{
+    static isClass(obj: any)
+    {
+        return typeof obj === 'function' && /^\s*class\s+/.test(obj.toString());
+    }
+    private object: ParsedNameValue;
+    constructor(object: ParsedNameValue, mandatory: boolean = false)
+    {
+        super(mandatory);
+        this.object = object;
+    }
+    override getNullString()
+    {
+        let ans: string | null = null;
+        if (Array.isArray(this.object))
+        {
+            if (this.object.length > 0)
+                ans = this.object.join(",");
+        }
+        else if (this.object != null && this.object != undefined)
+            ans = this.object + "";
+        return ans;
+    }
 }

package/src/PackageService.ts

@@ -1,77 +1,77 @@
-let fs: any;
-if (typeof window === 'undefined')
-    fs = require('fs');
-import { FileOperation } from "./FileOperation";
-
-export class PackageService
-{
-    static MainJson: any = null;
-    static ThisJson: any = null;
-    static get(path: string): PackageService 
-    {
-        if (path)
-        {
-            const json = JSON.parse(fs.readFileSync(path, 'utf8'));
-            if (json)
-                return new PackageService(path, json);
-        }
-        throw new Error("Coundn't find package");
-    }
-    static getMain(): PackageService 
-    {
-        if (PackageService.MainJson)
-            return new PackageService("", PackageService.MainJson);
-        const paths = FileOperation.findUp('package.json');
-        if (paths)
-            return this.get(paths[paths.length - 1]);
-        throw new Error("Coundn't find package");
-    }
-    static getThis(): PackageService 
-    {
-        if (PackageService.ThisJson)
-            return new PackageService("", PackageService.ThisJson);
-        const paths = FileOperation.findUp('package.json');
-        if (paths)
-            return this.get(paths[0]);
-        throw new Error("Coundn't find package");
-    }
-    private path: string;
-    private json: any;
-    constructor(path: string, json: any)
-    {
-        this.json = json;
-        this.path = path;
-    }
-    getPath(): string
-    {
-        return this.path;
-    }
-    getJson(): string
-    {
-        return this.json;
-    }
-    getName(): string
-    {
-        return this.json.name;
-    }
-    getTitle(): string
-    {
-        return this.json.title;
-    }
-    getDescription(): string
-    {
-        return this.json.description;
-    }
-    getIcon(): string
-    {
-        return this.json.icon;
-    }
-    getLogo(): string
-    {
-        return this.json.logo;
-    }
-    getVersion(): string
-    {
-        return this.json.version;
-    }
+let fs: any;
+if (typeof window === 'undefined')
+    fs = require('fs');
+import { FileOperation } from "./FileOperation";
+
+export class PackageService
+{
+    static MainJson: any = null;
+    static ThisJson: any = null;
+    static get(path: string): PackageService 
+    {
+        if (path)
+        {
+            const json = JSON.parse(fs.readFileSync(path, 'utf8'));
+            if (json)
+                return new PackageService(path, json);
+        }
+        throw new Error("Coundn't find package");
+    }
+    static getMain(): PackageService 
+    {
+        if (PackageService.MainJson)
+            return new PackageService("", PackageService.MainJson);
+        const paths = FileOperation.findUp('package.json');
+        if (paths)
+            return this.get(paths[paths.length - 1]);
+        throw new Error("Coundn't find package");
+    }
+    static getThis(): PackageService 
+    {
+        if (PackageService.ThisJson)
+            return new PackageService("", PackageService.ThisJson);
+        const paths = FileOperation.findUp('package.json');
+        if (paths)
+            return this.get(paths[0]);
+        throw new Error("Coundn't find package");
+    }
+    private path: string;
+    private json: any;
+    constructor(path: string, json: any)
+    {
+        this.json = json;
+        this.path = path;
+    }
+    getPath(): string
+    {
+        return this.path;
+    }
+    getJson(): string
+    {
+        return this.json;
+    }
+    getName(): string
+    {
+        return this.json.name;
+    }
+    getTitle(): string
+    {
+        return this.json.title;
+    }
+    getDescription(): string
+    {
+        return this.json.description;
+    }
+    getIcon(): string
+    {
+        return this.json.icon;
+    }
+    getLogo(): string
+    {
+        return this.json.logo;
+    }
+    getVersion(): string
+    {
+        return this.json.version;
+    }
 }

package/src/PasswordOperation.ts

@@ -1,13 +1,13 @@
-import crypto from "crypto";
-
-export class PasswordOperation
-{
-    static new(length: number): string
-    {
-        return crypto.randomBytes(length)
-            .toString('base64')
-            .slice(0, length)
-            .replace(/\+/g, '0')
-            .replace(/\//g, '0');
-    }
+import crypto from "crypto";
+
+export class PasswordOperation
+{
+    static new(length: number): string
+    {
+        return crypto.randomBytes(length)
+            .toString('base64')
+            .slice(0, length)
+            .replace(/\+/g, '0')
+            .replace(/\//g, '0');
+    }
 }