umt 1.0.10 → 1.0.12

package/.markdownlint.json

@@ -1,3 +1,6 @@
 {
-    "MD033": false
+    "MD013": false,
+    "MD024": false,
+    "MD033": false,
+    "MD051": false
 }

package/README.md

@@ -1,9 +1,16 @@
-# UMT
+# UMT Main Package
 
 個人的に作った便利関数集
-
 個人用途なので破壊的変更がある可能性があります。
+Main Packageに依存関係はありません。
+JavaScriptからの呼び出しに対応しています。
+
+## Doc
+
+- [Doc](./doc/index.md)
 
-## doc
+## Install
 
-<https://umt.oshaburikitchin.com/>
+```bash
+yarn add umt
+```

package/module/Array/arraysJoin.d.ts

@@ -3,5 +3,4 @@
  * @param  {any[]} array
  * @param  {any[]} ...arrays
  */
-declare const arraysJoin: <A extends any[], B extends any[], C extends A | B>(array: A, ...arrays: B[]) => C;
-export default arraysJoin;
+export declare const arraysJoin: <A extends any[], B extends any[], C extends A & B>(array: A, ...arrays: B[]) => C;

package/module/Array/arraysJoin.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.arraysJoin = void 0;
 /**
  * 重複をしないで結合
  * @param  {any[]} array
@@ -11,4 +12,4 @@ const arraysJoin = (array, ...arrays) => {
     }
     return [...new Set(array)];
 };
-exports.default = arraysJoin;
+exports.arraysJoin = arraysJoin;

package/module/Array/getArraysCommon.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 共通の要素をとりだす
+ * @param  {any[]} array
+ * @param  {any[]} ...arrays
+ */
+export declare const getArraysCommon: (array: any[], ...arrays: any[]) => any[];

package/module/Array/getArraysCommon.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArraysCommon = void 0;
+/**
+ * 共通の要素をとりだす
+ * @param  {any[]} array
+ * @param  {any[]} ...arrays
+ */
+const getArraysCommon = (array, ...arrays) => {
+    const result = [];
+    for (const i of array) {
+        let flag = true;
+        for (const j of arrays) {
+            if (!j.includes(i)) {
+                flag = false;
+                break;
+            }
+        }
+        if (flag) {
+            result.push(i);
+        }
+    }
+    return result;
+};
+exports.getArraysCommon = getArraysCommon;

package/module/Array/getArraysDiff.d.ts

@@ -3,5 +3,4 @@
  * @param  {any[]} array
  * @param  {any[]} ...arrays
  */
-declare const getArraysDiff: <A extends any[], B extends any[], C extends A | B>(array: A, ...arrays: B[]) => C;
-export default getArraysDiff;
+export declare const getArraysDiff: (array: any[], ...arrays: any[]) => any[];

package/module/Array/getArraysDiff.js

@@ -1,17 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArraysDiff = void 0;
 /**
  * 共通しない要素をとりだす
  * @param  {any[]} array
  * @param  {any[]} ...arrays
  */
 const getArraysDiff = (array, ...arrays) => {
-    let hasArr = [];
-    for (const i of arrays) {
-        hasArr.push(...i);
+    const result = [];
+    for (const i of array) {
+        let flag = true;
+        for (const j of arrays) {
+            if (j.includes(i)) {
+                flag = false;
+                break;
+            }
+        }
+        if (flag) {
+            result.push(i);
+        }
     }
-    const arr01 = [...new Set(array)];
-    const arr02 = [...new Set(hasArr)];
-    return [...arr01, ...arr02].filter((value) => !arr01.includes(value) || !arr02.includes(value));
+    return result;
 };
-exports.default = getArraysDiff;
+exports.getArraysDiff = getArraysDiff;

package/module/Array/index.d.ts

@@ -1,5 +1,16 @@
-import arraysJoin from './arraysJoin';
-import getArraysDiff from './getArraysDiff';
-import getArraysIntersect from './getArraysIntersect';
-import quickSort from './quickSort';
-export { arraysJoin, getArraysDiff, getArraysIntersect, quickSort };
+import { arraysJoin } from './arraysJoin';
+import { getArraysCommon } from './getArraysCommon';
+import { getArraysDiff } from './getArraysDiff';
+import { quickSort } from './quickSort';
+import { sum } from './sum';
+export { arraysJoin, getArraysCommon, getArraysDiff, quickSort, sum };
+export declare class UMTArrayClass {
+    #private;
+    constructor();
+    get arraysJoin(): <A extends any[], B extends any[], C extends A & B>(array: A, ...arrays: B[]) => C;
+    get getArraysCommon(): (array: any[], ...arrays: any[]) => any[];
+    get getArraysDiff(): (array: any[], ...arrays: any[]) => any[];
+    get quickSort(): <A extends any[]>(array: A, startID?: number, endID?: number) => A;
+    get sum(): (x: number[]) => number;
+}
+export declare const UMT_Array: UMTArrayClass;

package/module/Array/index.js

@@ -1,14 +1,57 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _UMTArrayClass_LocalarraysJoin, _UMTArrayClass_LocalgetArraysCommon, _UMTArrayClass_LocalgetArraysDiff, _UMTArrayClass_LocalquickSort, _UMTArrayClass_Localsum;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.quickSort = exports.getArraysIntersect = exports.getArraysDiff = exports.arraysJoin = void 0;
-const arraysJoin_1 = __importDefault(require("./arraysJoin"));
-exports.arraysJoin = arraysJoin_1.default;
-const getArraysDiff_1 = __importDefault(require("./getArraysDiff"));
-exports.getArraysDiff = getArraysDiff_1.default;
-const getArraysIntersect_1 = __importDefault(require("./getArraysIntersect"));
-exports.getArraysIntersect = getArraysIntersect_1.default;
-const quickSort_1 = __importDefault(require("./quickSort"));
-exports.quickSort = quickSort_1.default;
+exports.UMT_Array = exports.UMTArrayClass = exports.sum = exports.quickSort = exports.getArraysDiff = exports.getArraysCommon = exports.arraysJoin = void 0;
+const arraysJoin_1 = require("./arraysJoin");
+Object.defineProperty(exports, "arraysJoin", { enumerable: true, get: function () { return arraysJoin_1.arraysJoin; } });
+const getArraysCommon_1 = require("./getArraysCommon");
+Object.defineProperty(exports, "getArraysCommon", { enumerable: true, get: function () { return getArraysCommon_1.getArraysCommon; } });
+const getArraysDiff_1 = require("./getArraysDiff");
+Object.defineProperty(exports, "getArraysDiff", { enumerable: true, get: function () { return getArraysDiff_1.getArraysDiff; } });
+const quickSort_1 = require("./quickSort");
+Object.defineProperty(exports, "quickSort", { enumerable: true, get: function () { return quickSort_1.quickSort; } });
+const sum_1 = require("./sum");
+Object.defineProperty(exports, "sum", { enumerable: true, get: function () { return sum_1.sum; } });
+class UMTArrayClass {
+    constructor() {
+        _UMTArrayClass_LocalarraysJoin.set(this, void 0);
+        _UMTArrayClass_LocalgetArraysCommon.set(this, void 0);
+        _UMTArrayClass_LocalgetArraysDiff.set(this, void 0);
+        _UMTArrayClass_LocalquickSort.set(this, void 0);
+        _UMTArrayClass_Localsum.set(this, void 0);
+        __classPrivateFieldSet(this, _UMTArrayClass_LocalarraysJoin, arraysJoin_1.arraysJoin, "f");
+        __classPrivateFieldSet(this, _UMTArrayClass_LocalgetArraysCommon, getArraysCommon_1.getArraysCommon, "f");
+        __classPrivateFieldSet(this, _UMTArrayClass_LocalgetArraysDiff, getArraysDiff_1.getArraysDiff, "f");
+        __classPrivateFieldSet(this, _UMTArrayClass_LocalquickSort, quickSort_1.quickSort, "f");
+        __classPrivateFieldSet(this, _UMTArrayClass_Localsum, sum_1.sum, "f");
+    }
+    get arraysJoin() {
+        return __classPrivateFieldGet(this, _UMTArrayClass_LocalarraysJoin, "f");
+    }
+    get getArraysCommon() {
+        return __classPrivateFieldGet(this, _UMTArrayClass_LocalgetArraysCommon, "f");
+    }
+    get getArraysDiff() {
+        return __classPrivateFieldGet(this, _UMTArrayClass_LocalgetArraysDiff, "f");
+    }
+    get quickSort() {
+        return __classPrivateFieldGet(this, _UMTArrayClass_LocalquickSort, "f");
+    }
+    get sum() {
+        return __classPrivateFieldGet(this, _UMTArrayClass_Localsum, "f");
+    }
+}
+exports.UMTArrayClass = UMTArrayClass;
+_UMTArrayClass_LocalarraysJoin = new WeakMap(), _UMTArrayClass_LocalgetArraysCommon = new WeakMap(), _UMTArrayClass_LocalgetArraysDiff = new WeakMap(), _UMTArrayClass_LocalquickSort = new WeakMap(), _UMTArrayClass_Localsum = new WeakMap();
+exports.UMT_Array = new UMTArrayClass();

package/module/Array/quickSort.d.ts

@@ -4,5 +4,4 @@
  * @param  {number} startID
  * @param  {number} endID
  */
-declare const quickSort: <A extends any[]>(array: A, startID?: number, endID?: number) => A;
-export default quickSort;
+export declare const quickSort: <A extends any[]>(array: A, startID?: number, endID?: number) => A;

package/module/Array/quickSort.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.quickSort = void 0;
 /**
  * 配列を高速にソート
  * @param  {any[]} array
@@ -27,11 +28,11 @@ const quickSort = (array, startID = 0, endID = array.length - 1) => {
         right--;
     }
     if (startID < left - 1) {
-        quickSort(array, startID, left - 1);
+        (0, exports.quickSort)(array, startID, left - 1);
     }
     if (right + 1 < endID) {
-        quickSort(array, right + 1, endID);
+        (0, exports.quickSort)(array, right + 1, endID);
     }
     return array;
 };
-exports.default = quickSort;
+exports.quickSort = quickSort;

package/module/Array/sum.d.ts

@@ -0,0 +1 @@
+export declare const sum: (x: number[]) => number;

package/module/Array/sum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sum = void 0;
+const addition_1 = require("../Math/addition");
+const sum = (x) => {
+    return x.reduce((a, b) => (0, addition_1.addition)(a, b));
+};
+exports.sum = sum;

package/module/Compiler/core.d.ts

@@ -0,0 +1,5 @@
+export declare const compilerCore: (code: string, tokenList: [string, RegExp, number | null][], UncategorizedTokenList: [string, RegExp, number | null][], process: (code: string, tokenList: [string, RegExp, number | null][], x: {
+    name: string;
+    value: string;
+    count: number;
+}) => string) => string;

package/module/Compiler/core.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilerCore = void 0;
+const token_1 = require("./token");
+const compilerCore = (code, tokenList, UncategorizedTokenList, process) => {
+    const tokenCodes = (0, token_1.compilerToken)(code, tokenList, UncategorizedTokenList);
+    console.log('====================================');
+    console.log(tokenCodes[0].token);
+    console.log('====================================');
+    let outCode = '';
+    for (const tokenCode of tokenCodes) {
+        for (const n of tokenCode.token) {
+            outCode += process(code, tokenList, n);
+        }
+        outCode += '\n';
+    }
+    return outCode;
+};
+exports.compilerCore = compilerCore;

package/module/Compiler/token.d.ts

@@ -0,0 +1,10 @@
+export declare const compilerToken: (code: string, tokenList: [string, RegExp, number | null][], UncategorizedTokenList: [string, RegExp, number | null][]) => {
+    code: string;
+    token: {
+        name: string;
+        value: string;
+        count: number;
+        index: number;
+    }[];
+    outCode: string;
+}[];

package/module/Compiler/token.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilerToken = void 0;
+const compilerToken = (code, tokenList, UncategorizedTokenList) => {
+    const tokenListMax = Math.max(...tokenList.map((n) => { var _a; return (_a = n[2]) !== null && _a !== void 0 ? _a : 0; }));
+    let list = [];
+    const tokenListName = tokenList.map((n) => n[0]);
+    let outCode = [
+        code.split('\n'),
+        code.split('\n'),
+    ];
+    console.log('====================================');
+    console.log(outCode);
+    console.log('====================================');
+    let count = {};
+    tokenList.forEach((token) => {
+        if (token[2] === null) {
+            return (token[2] = tokenListMax + 1);
+        }
+        else {
+            return token;
+        }
+    });
+    tokenList.sort((a, b) => {
+        if (a[2] === null) {
+            return 1;
+        }
+        else if (b[2] === null) {
+            return -1;
+        }
+        else {
+            return a[2] - b[2];
+        }
+    });
+    for (const token of tokenList) {
+        code.split('\n')
+            .filter((n) => n !== '')
+            .forEach((_, index) => {
+            count = {};
+            outCode[1][index] = outCode[1][index].replace(new RegExp(token[1], 'g'), (match) => {
+                try {
+                    count[token[0]].value += 1;
+                }
+                catch (_a) {
+                    count[token[0]] = {
+                        value: 0,
+                    };
+                }
+                try {
+                    list[index].push({
+                        name: token[0],
+                        value: match,
+                        count: count[token[0]].value,
+                        index: outCode[1][index].indexOf(match),
+                    });
+                }
+                catch (_b) {
+                    list[index] = [
+                        {
+                            name: token[0],
+                            value: match,
+                            count: 0,
+                            index: outCode[1][index].indexOf(match),
+                        },
+                    ];
+                }
+                outCode[1][index] = outCode[1][index].replace(match, ` ${token[0]} `);
+                return ` ${token[0]} `;
+            });
+        });
+    }
+    outCode[1].forEach((i, index) => {
+        for (const token of i
+            .split(' ')
+            .filter((n) => n !== '')
+            .filter((n) => tokenListName.indexOf(n) === -1)) {
+            UncategorizedTokenList.forEach((n) => {
+                token.replace(n[1], (match) => {
+                    try {
+                        count[n[0]].value += 1;
+                    }
+                    catch (_a) {
+                        count[n[0]] = {
+                            value: 0,
+                        };
+                    }
+                    try {
+                        list[index].push({
+                            name: n[0],
+                            value: match,
+                            count: count[n[0]].value,
+                            index: outCode[0][index].indexOf(match),
+                        });
+                    }
+                    catch (_b) {
+                        list[index] = [
+                            {
+                                name: n[0],
+                                value: match,
+                                count: 0,
+                                index: outCode[0][index].indexOf(match),
+                            },
+                        ];
+                    }
+                    outCode[0][index] = outCode[0][index].replace(match, ` ${n[0]} `);
+                    outCode[1][index] = outCode[1][index].replace(token, ` ${n[0]} `);
+                    return ` ${n[0]} `;
+                });
+            });
+        }
+    });
+    return code.split('\n').map((n, index) => {
+        return {
+            code: n,
+            token: list[index].sort((a, b) => a.index - b.index),
+            outCode: outCode[1][index],
+        };
+    });
+};
+exports.compilerToken = compilerToken;

package/module/Date/index.d.ts

@@ -1,2 +1,8 @@
-import now from './now';
+import { now } from './now';
 export { now };
+export declare class UMTDateClass {
+    #private;
+    constructor();
+    get now(): (timeDifference?: number) => Date;
+}
+export declare const UMT_Date: UMTDateClass;

package/module/Date/index.js

@@ -1,8 +1,29 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _UMTDateClass_Localnow;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.now = void 0;
-const now_1 = __importDefault(require("./now"));
-exports.now = now_1.default;
+exports.UMT_Date = exports.UMTDateClass = exports.now = void 0;
+const now_1 = require("./now");
+Object.defineProperty(exports, "now", { enumerable: true, get: function () { return now_1.now; } });
+class UMTDateClass {
+    constructor() {
+        _UMTDateClass_Localnow.set(this, void 0);
+        __classPrivateFieldSet(this, _UMTDateClass_Localnow, now_1.now, "f");
+    }
+    get now() {
+        return __classPrivateFieldGet(this, _UMTDateClass_Localnow, "f");
+    }
+}
+exports.UMTDateClass = UMTDateClass;
+_UMTDateClass_Localnow = new WeakMap();
+exports.UMT_Date = new UMTDateClass();

package/module/Date/now.d.ts

@@ -1,2 +1,5 @@
-declare const now: () => Date;
-export default now;
+/**
+ * @param {number} [timeDifference=9] 時差(時)
+ * @returns {Date} 現在時刻
+ */
+export declare const now: (timeDifference?: number) => Date;

package/module/Date/now.js

@@ -1,5 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const now = () => new Date(Date.now() +
-    (new Date().getTimezoneOffset() + 9 * 60) * 60 * 1000);
-exports.default = now;
+exports.now = void 0;
+/**
+ * @param {number} [timeDifference=9] 時差(時)
+ * @returns {Date} 現在時刻
+ */
+const now = (timeDifference = 9) => new Date(Date.now() +
+    (new Date().getTimezoneOffset() + timeDifference * 60) *
+        60 *
+        1000);
+exports.now = now;

package/module/Math/addition.d.ts

@@ -2,6 +2,6 @@
  * 誤差のない足し算
  * @param  {number} x
  * @param  {number} y
+ * @returns number
  */
-declare const addition: (x: number, y: number) => number;
-export default addition;
+export declare const addition: (x: number, y: number) => number;

package/module/Math/addition.js

@@ -1,18 +1,17 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const getDecimalLength_1 = __importDefault(require("./getDecimalLength"));
-const max_1 = __importDefault(require("./max"));
-const multiplication_1 = __importDefault(require("./multiplication"));
+exports.addition = void 0;
+const getDecimalLength_1 = require("./getDecimalLength");
+const max_1 = require("./max");
+const multiplication_1 = require("./multiplication");
 /**
  * 誤差のない足し算
  * @param  {number} x
  * @param  {number} y
+ * @returns number
  */
 const addition = (x, y) => {
-    const z = Math.pow(10, (0, max_1.default)([(0, getDecimalLength_1.default)(x), (0, getDecimalLength_1.default)(y)]));
-    return ((0, multiplication_1.default)(x, z) + (0, multiplication_1.default)(y, z)) / z;
+    const z = Math.pow(10, (0, max_1.max)((0, getDecimalLength_1.getDecimalLength)(x), (0, getDecimalLength_1.getDecimalLength)(y)));
+    return ((0, multiplication_1.multiplication)(x, z) + (0, multiplication_1.multiplication)(y, z)) / z;
 };
-exports.default = addition;
+exports.addition = addition;

package/module/Math/average.d.ts

@@ -1,6 +1,6 @@
 /**
  * 平均値
  * @param  {number[]} numbers
+ * @returns number
  */
-declare const average: (numbers: number[]) => number;
-export default average;
+export declare const average: (numbers: number[]) => number;

package/module/Math/average.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.average = void 0;
 /**
  * 平均値
  * @param  {number[]} numbers
+ * @returns number
  */
 const average = (numbers) => {
     const sum = numbers.reduce((a, b) => a + b, 0);
     const avg = sum / numbers.length;
     return avg;
 };
-exports.default = average;
+exports.average = average;

package/module/Math/calculator/core.d.ts

@@ -4,8 +4,4 @@
  * xなどの文字は未対応
  * @param  {string} x 計算式
  */
-interface Props {
-    $?: number;
-}
-declare const calculatorCore: (x: string, ex?: Props) => string;
-export default calculatorCore;
+export declare const calculatorCore: <T extends object>(x: string, ex?: T | undefined) => string;