@soratani-code/samtools 1.3.1

package/lib/color.d.ts

@@ -0,0 +1,8 @@
+export declare function rgbToHex(_color: string): string;
+export declare function rgbaToHex(_color: string): string;
+export declare function hexToRgb(_color: string): string;
+export declare function hex(_color: string): string;
+export declare function completionHex(color: string): string;
+export declare function color(str: string, num?: number, dark?: boolean): string;
+export declare function opacity(code: string, num?: number): string;
+export declare function complementaryColor(code: string): string;

package/lib/color.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.complementaryColor = exports.opacity = exports.color = exports.completionHex = exports.hex = exports.hexToRgb = exports.rgbaToHex = exports.rgbToHex = void 0;
+const type_1 = require("./type");
+function repeatWord(word, num) {
+    var result = '';
+    for (let i = 0; i < num; i++) {
+        result += word;
+    }
+    return result;
+}
+function repeatLetter(word, num) {
+    var result = '';
+    for (let letter of word) {
+        result += repeatWord(letter, num);
+    }
+    return result;
+}
+function rgbToHex(_color) {
+    let arr = _color.replace('rgb(', '').replace(')', '').split(',').map((i) => Number(i));
+    let r = +arr[0];
+    let g = +arr[1];
+    let b = +arr[2];
+    return `#${(r << 16 | g << 8 | b).toString(16).padStart(6, '0')}`;
+}
+exports.rgbToHex = rgbToHex;
+function rgbaToHex(_color) {
+    return _color.replace('rgba(', '').replace(')', '').split(',').reduce((a, chanel, i) => {
+        let hexNum = "";
+        if (i === 3) {
+            hexNum = Number(Math.round(Number(chanel) * 255)).toString(16);
+        }
+        else {
+            hexNum = Number(chanel).toString(16);
+        }
+        return `${a}${hexNum.length === 1 ? '0' + hexNum : hexNum}`;
+    }, '#');
+}
+exports.rgbaToHex = rgbaToHex;
+function hexToRgb(_color) {
+    try {
+        if (!_color.startsWith('#'))
+            return '';
+        let hex = _color.replace('#', '');
+        hex = hex.length < 6 ? repeatLetter(hex, 2) : hex;
+        hex = `0x${hex}`;
+        return `rgb(${hex >> 16},${hex >> 8 & 0xff},${hex & 0xff})`;
+    }
+    catch (error) {
+        return '';
+    }
+}
+exports.hexToRgb = hexToRgb;
+function hex(_color) {
+    if (!_color)
+        return '';
+    if (_color.startsWith('rgba('))
+        return rgbaToHex(_color);
+    if (_color.startsWith('rgb('))
+        return rgbToHex(_color);
+    return '';
+}
+exports.hex = hex;
+function completionHex(color) {
+    let _color = color;
+    _color = _color.startsWith('#') ? _color.replace(/\#/g, '') : _color;
+    if (_color.length > 3)
+        return `#${_color}`;
+    return _color.split('').reduce((a, b) => `${a}${b}${b}`, '#');
+}
+exports.completionHex = completionHex;
+function colorLight(hex, lum) {
+    hex = String(hex).replace(/[^0-9a-f]/gi, '');
+    if (hex.length < 6) {
+        hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+    }
+    lum = lum || 0;
+    var rgb = "#", c, i;
+    for (i = 0; i < 3; i++) {
+        c = parseInt(hex.substr(i * 2, 2), 16);
+        c = Math.round(Math.min(Math.max(0, c + (c * lum)), 255)).toString(16);
+        rgb += ("00" + c).substr(c.length);
+    }
+    return rgb;
+}
+function colorDark(hex, lum) {
+    let rgb = hexToRgb(hex).replace('rgb(', '').replace(')', '').split(',');
+    lum = lum || 0;
+    for (var i = 0; i < 3; i++)
+        rgb[i] = Math.floor(Number(rgb[i]) * (1 - lum));
+    return rgbToHex(`rgb(${rgb.join(',')})`);
+}
+function color(str, num, dark) {
+    let _color = str;
+    if (str.startsWith('rgba(') || str.startsWith('rgb(')) {
+        _color = hexToRgb(hex(str));
+    }
+    if ((0, type_1.isUndefined)(num))
+        return str;
+    return dark ? colorDark(_color, num) : colorLight(_color, num);
+}
+exports.color = color;
+function opacity(code, num) {
+    if (!(0, type_1.isNum)(num))
+        return code;
+    let _color = code.toLowerCase();
+    if (_color && /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/.test(_color)) {
+        if (_color.length === 4) {
+            var colorNew = '#';
+            for (var i = 1; i < 4; i += 1) {
+                colorNew += _color.slice(i, i + 1).concat(_color.slice(i, i + 1));
+            }
+            _color = colorNew;
+        }
+        var colorChange = [];
+        for (var j = 1; j < 7; j += 2) {
+            colorChange.push(parseInt('0x' + _color.slice(j, j + 2)));
+        }
+        return color(`rgba(${colorChange.join(',')},${num})`);
+    }
+    if (_color.startsWith('rgb(')) {
+        let numbers = _color.match(/(\d(\.\d+)?)+/g);
+        numbers = numbers.slice(0, 3).concat(num);
+        return color('rgba(' + numbers.join(',') + ')');
+    }
+    if (_color.startsWith('rgba(')) {
+        return opacity(rgbaToHex(_color), num);
+    }
+    return _color;
+}
+exports.opacity = opacity;
+function complementaryColor(code) {
+    const _color = color(code).slice(1);
+    const ind = parseInt(_color, 16);
+    let iter = ((1 << 4 * _color.length) - 1 - ind).toString(16);
+    if (iter.length >= _color.length)
+        return `#${iter}`;
+    iter = new Array(_color.length - 1).fill('0').reduce((a, b) => b + a, iter);
+    return '#' + iter;
+}
+exports.complementaryColor = complementaryColor;

package/lib/database.d.ts

@@ -0,0 +1,9 @@
+type PickKeys<T = any> = T[];
+type GetIndexedField<T, K> = K extends keyof T ? T[K] : K extends `${number}` ? 'length' extends keyof T ? number extends T['length'] ? number extends keyof T ? T[number] : undefined : undefined : undefined : undefined;
+type FieldWithPossiblyUndefined<T, Key> = GetFieldType<Exclude<T, undefined>, Key> | Extract<T, undefined>;
+type IndexedFieldWithPossiblyUndefined<T, Key> = GetIndexedField<Exclude<T, undefined>, Key> | Extract<T, undefined>;
+type GetFieldType<T, P> = P extends `${infer Left}.${infer Right}` ? Left extends keyof Exclude<T, undefined> ? FieldWithPossiblyUndefined<Exclude<T, undefined>[Left], Right> | Extract<T, undefined> : Left extends `${infer FieldKey}[${infer IndexKey}]` ? FieldKey extends keyof T ? FieldWithPossiblyUndefined<IndexedFieldWithPossiblyUndefined<T[FieldKey], IndexKey>, Right> : undefined : undefined : P extends keyof T ? T[P] : P extends `${infer FieldKey}[${infer IndexKey}]` ? FieldKey extends keyof T ? IndexedFieldWithPossiblyUndefined<T[FieldKey], IndexKey> : undefined : IndexedFieldWithPossiblyUndefined<T, P>;
+export declare function get<TObject, TPath extends string, TDefault = GetFieldType<TObject, TPath>>(data: TObject, id: TPath, defaultData?: TDefault): Exclude<GetFieldType<TObject, TPath>, null | undefined> | TDefault;
+export declare function pick<D extends object, T extends keyof D>(data: D, keys?: PickKeys<T>): Pick<D, T>;
+export declare function omit<D extends object, T extends keyof D>(data: D, keys?: PickKeys<T>): Omit<D, T>;
+export {};

package/lib/database.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omit = exports.pick = exports.get = void 0;
+const type_1 = require("./type");
+function get(data, id, defaultData) {
+    if (!id || !data)
+        return defaultData;
+    let keys = id.replace(/[{}\[\]()]/g, '.').split('.').filter(Boolean);
+    let node = data;
+    while (keys.length && !(0, type_1.isNull)(node) && !(0, type_1.isUndefined)(node)) {
+        const key = keys.shift();
+        node = node[key];
+    }
+    return (node || defaultData);
+}
+exports.get = get;
+function pick(data, keys = []) {
+    if (!data || !keys || !keys.length || !(0, type_1.isObject)(data))
+        return data;
+    return Object.entries(data).reduce((a, b) => {
+        const [key, value] = b;
+        if (keys.includes(key)) {
+            a[key] = value;
+        }
+        return a;
+    }, {});
+}
+exports.pick = pick;
+function omit(data, keys = []) {
+    if (!data || !keys || !keys.length || !(0, type_1.isObject)(data))
+        return data;
+    return Object.entries(data).reduce((a, b) => {
+        const [key, value] = b;
+        if (!keys.includes(key)) {
+            a[key] = value;
+        }
+        return a;
+    }, {});
+}
+exports.omit = omit;

package/lib/delay.d.ts

@@ -0,0 +1,5 @@
+interface Curry<T extends any[], R> {
+    (...args: T): R | Promise<R>;
+}
+export declare function delay<T extends any[], R>(fun: Curry<T, R>, timer?: number): Curry<T, R>;
+export {};

package/lib/delay.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+const type_1 = require("./type");
+function delay(fun, timer = 1000) {
+    return (...args) => {
+        const task = new Promise((resolve, reject) => {
+            let time = setTimeout(() => {
+                const data = fun(...args);
+                if ((0, type_1.isPromise)(data)) {
+                    data.then(resolve).catch(reject);
+                }
+                else {
+                    resolve(data);
+                }
+                clearTimeout(time);
+                time = undefined;
+            }, timer);
+        });
+        return task;
+    };
+}
+exports.delay = delay;

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./interface";
+export * from "./type";
+export * from "./delay";
+export * from "./database";
+export * from "./time";
+export * as platform from "./platform";
+export * as set from "./set";
+export * as log from "./log";
+export * as color from "./color";
+export * as query from "./query";
+export * as transform from "./transform";

package/lib/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = exports.query = exports.color = exports.log = exports.set = exports.platform = void 0;
+__exportStar(require("./interface"), exports);
+__exportStar(require("./type"), exports);
+__exportStar(require("./delay"), exports);
+__exportStar(require("./database"), exports);
+__exportStar(require("./time"), exports);
+exports.platform = __importStar(require("./platform"));
+exports.set = __importStar(require("./set"));
+exports.log = __importStar(require("./log"));
+exports.color = __importStar(require("./color"));
+exports.query = __importStar(require("./query"));
+exports.transform = __importStar(require("./transform"));

package/lib/interface.d.ts

@@ -0,0 +1,7 @@
+export type BaseType = "string" | "function" | "object" | "array" | "bigint" | "boolean" | "symbol" | "number" | "undefined" | "null";
+export type TreeChildren<P = any> = P & {
+    children: TreeChildren<P>[];
+};
+export type ListToTreeSchema = {
+    [key: string]: string;
+};

package/lib/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/link_node/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Link } from './link';
+export * from './node';

package/lib/link_node/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Link = void 0;
+var link_1 = require("./link");
+Object.defineProperty(exports, "Link", { enumerable: true, get: function () { return __importDefault(link_1).default; } });
+__exportStar(require("./node"), exports);

package/lib/link_node/link.d.ts

@@ -0,0 +1,9 @@
+import { LinkNode } from "./node";
+export default class Link<V = any> {
+    constructor(id: string | number, value: V);
+    head: LinkNode<V>;
+    insert(value: LinkNode, head?: boolean): LinkNode<V>;
+    nodeInsert(id: string | number, value: LinkNode, head?: boolean): LinkNode<V>;
+    remove(id: string | number): LinkNode<V>;
+    get(id: string | number): LinkNode<V>;
+}

package/lib/link_node/link.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_1 = require("./node");
+class Link {
+    constructor(id, value) {
+        this.head = new node_1.LinkNode(id, value);
+    }
+    insert(value, head = false) {
+        const node = value;
+        if (head) {
+            node.next = this.head;
+            this.head = node;
+            return this.head;
+        }
+        else {
+            let next = this.head.next;
+            if (!next) {
+                this.head.next = node;
+                return this.head;
+            }
+            while (next.next) {
+                next = next.next;
+            }
+            next.next = node;
+        }
+        return this.head;
+    }
+    nodeInsert(id, value, head = false) {
+        const node = value;
+        let headNode = this.head;
+        let current = headNode.next;
+        let status = headNode.id === id;
+        if (head) {
+            if (status) {
+                node.next = headNode;
+                this.head = node;
+                return this.head;
+            }
+            while (!status && current) {
+                status = current.id === id;
+                if (!status) {
+                    headNode = current;
+                    current = current.next;
+                }
+            }
+            if (status && current) {
+                node.next = current;
+                headNode.next = node;
+            }
+            return this.head;
+        }
+        else {
+            if (status) {
+                node.next = current;
+                headNode.next = node;
+                return this.head;
+            }
+            while (!status && current) {
+                status = current.id === id;
+                if (!status) {
+                    headNode = current;
+                    current = current.next;
+                }
+            }
+            if (status && current) {
+                headNode = current;
+                current = current.next;
+                headNode.next = node;
+                node.next = current;
+            }
+            return this.head;
+        }
+    }
+    remove(id) {
+        let head = this.head;
+        let current = head.next;
+        let status = head.id === id;
+        if (status) {
+            this.head = this.head.next;
+            return this.head;
+        }
+        while (!status && current) {
+            status = current.id === id;
+            if (!status) {
+                head = current;
+                current = current.next;
+            }
+        }
+        if (status && current) {
+            current = current.next;
+            head.next = current;
+        }
+        return this.head;
+    }
+    get(id) {
+        let node = this.head;
+        let status = false;
+        while (!status && node) {
+            status = node.id === id;
+            if (!status) {
+                node = node.next;
+            }
+        }
+        if (status && node) {
+            return node;
+        }
+        return null;
+    }
+}
+exports.default = Link;

package/lib/link_node/node.d.ts

@@ -0,0 +1,7 @@
+export declare class LinkNode<V = any> {
+    constructor(id: string | number, value: V);
+    id: any;
+    value: V;
+    next?: LinkNode;
+    pre?: LinkNode;
+}

package/lib/link_node/node.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkNode = void 0;
+class LinkNode {
+    constructor(id, value) {
+        this.value = value;
+        this.id = id;
+    }
+}
+exports.LinkNode = LinkNode;

package/lib/log.d.ts

@@ -0,0 +1,4 @@
+export declare function log(label: string, message: string): void;
+export declare function error(label: string, ...message: any): void;
+export declare function warn(label: string, ...message: any): void;
+export declare function info(label: string, ...message: any): void;

package/lib/log.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.info = exports.warn = exports.error = exports.log = void 0;
+const type_1 = require("./type");
+function log(label, message) {
+    return console.log(`%c ${label} %c ${message}`, 'background:#000;color:#fff;border-top-left-radius:4px;border-bottom-left-radius:4px;padding:4px', 'background:#ddd;border-top-right-radius:4px;border-bottom-right-radius:4px;padding:4px;color:#000');
+}
+exports.log = log;
+function error(label, ...message) {
+    if (message.length === 1 && (0, type_1.isString)(message[0])) {
+        return console.log(`%c ${label} %c ${message[0]}`, 'background:#eb1168;color:#fff;border-top-left-radius:4px;border-bottom-left-radius:4px;padding:4px', 'background:#ddd;border-top-right-radius:4px;border-bottom-right-radius:4px;padding:4px;color:#000');
+    }
+    console.groupCollapsed(`%c ERROR %c${label}`, 'background:#eb1168;color:#fff;border-top-left-radius:4px;border-bottom-left-radius:4px;padding:4px', 'background:#ddd;border-top-right-radius:4px;border-bottom-right-radius:4px;padding:4px;color:#000');
+    console.log(...message);
+    console.groupEnd();
+}
+exports.error = error;
+function warn(label, ...message) {
+    if (message.length === 1 && (0, type_1.isString)(message[0])) {
+        return console.log(`%c ${label} %c ${message[0]}`, 'background:#ffcc00;color:#fff;border-top-left-radius:4px;border-bottom-left-radius:4px;padding:4px', 'background:#ddd;border-top-right-radius:4px;border-bottom-right-radius:4px;padding:4px;color:#000');
+    }
+    console.groupCollapsed(`%c WARN %c${label}`, 'background:#ffcc00;color:#fff;border-top-left-radius:4px;border-bottom-left-radius:4px;padding:4px', 'background:#ddd;border-top-right-radius:4px;border-bottom-right-radius:4px;padding:4px;color:#000');
+    console.log(...message);
+    console.groupEnd();
+}
+exports.warn = warn;
+function info(label, ...message) {
+    if (message.length === 1 && (0, type_1.isString)(message[0])) {
+        return console.log(`%c ${label} %c ${message[0]}`, 'background:#028f55;color:#fff;border-top-left-radius:4px;border-bottom-left-radius:4px;padding:4px', 'background:#ddd;border-top-right-radius:4px;border-bottom-right-radius:4px;padding:4px;color:#000');
+    }
+    console.groupCollapsed(`%c INFO %c${label}`, 'background:#028f55;color:#fff;border-top-left-radius:4px;border-bottom-left-radius:4px;padding:4px', 'background:#ddd;border-top-right-radius:4px;border-bottom-right-radius:4px;padding:4px;color:#000');
+    console.log(...message);
+    console.groupEnd();
+}
+exports.info = info;

package/lib/platform.d.ts

@@ -0,0 +1,4 @@
+type System = 'windows' | 'mac' | 'linux' | 'android' | 'ios' | 'blackberry' | 'symbian' | 'webos' | 'unknown' | 'windows-phone';
+export declare function system(useragent?: string): System;
+export declare function version(useragent?: string): string;
+export {};

package/lib/platform.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = exports.system = void 0;
+const database_1 = require("./database");
+const system_map = {
+    'Windows': 'windows',
+    'Macintosh': 'mac',
+    'Linux': 'linux',
+    'Android': 'android',
+    'iPhone': 'ios',
+    'iPad': 'ios',
+    'BlackBerry': 'blackberry',
+    'BB10': 'blackberry',
+    'SymbianOS': 'symbian',
+    'Windows Phone': 'windows-phone',
+    'webOS': 'webos',
+};
+function macVersion(useragent = navigator.userAgent) {
+    const rule = /Mac OS X ([\d._]+)/;
+    const match = (0, database_1.get)(rule.exec(useragent), '1');
+    if (match) {
+        const version = match.replace(/_/g, '.').replace(/\./g, ',').split(',').join('.');
+        return version || 'unknown';
+    }
+    return 'unknown';
+}
+function windowsVersion(useragent = navigator.userAgent) {
+    const rule = /Windows NT(\d+\.\d+)/i;
+    const match = (0, database_1.get)(rule.exec(useragent), '1');
+    return match || 'unknown';
+}
+function windowsPhoneVersion(useragent = navigator.userAgent) {
+    const rule = /Windows Phone(\d+\.\d+)/i;
+    const match = (0, database_1.get)(rule.exec(useragent), '1');
+    return match || 'unknown';
+}
+function androidVersion(useragent = navigator.userAgent) {
+    const rule = /Android (\d+(\.\d+)+(\.\d+)?)/i;
+    const match = (0, database_1.get)(rule.exec(useragent), '1');
+    return match || 'unknown';
+}
+function iosVersion(useragent = navigator.userAgent) {
+    const rule = /CPU( iPhone)? OS (\d+)_(\d+)(?:_\d+)? like Mac OS X/i;
+    const match_major = (0, database_1.get)(rule.exec(useragent), '2');
+    const match_minor = (0, database_1.get)(rule.exec(useragent), '3');
+    if (match_major && match_minor) {
+        return `${parseInt(match_major)}.${parseInt(match_minor)}`;
+    }
+    return 'unknown';
+}
+function system(useragent = navigator.userAgent) {
+    const rule = /(Windows|Macintosh|Android|iPhone|iPad|iPod|BlackBerry|BB10|SymbianOS|Windows Phone|webOS)/i;
+    const match = (0, database_1.get)(rule.exec(useragent), '1');
+    if (match && system_map[match])
+        return system_map[match];
+    return 'unknown';
+}
+exports.system = system;
+function version(useragent = navigator.userAgent) {
+    const sys = system(useragent);
+    if (sys === 'windows')
+        return windowsVersion(useragent);
+    if (sys === 'windows-phone')
+        return windowsPhoneVersion(useragent);
+    if (sys === 'mac')
+        return macVersion(useragent);
+    if (sys === 'android')
+        return androidVersion(useragent);
+    if (sys === 'ios')
+        return iosVersion(useragent);
+    return 'unknown';
+}
+exports.version = version;

package/lib/query.d.ts

@@ -0,0 +1,4 @@
+export declare function make(obj: any): string;
+export declare function parseQuery(str?: string): any;
+export declare function parseUrl(url: string): string;
+export declare function mergeQueryToURL(url: string, obj?: any): string;

package/lib/query.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeQueryToURL = exports.parseUrl = exports.parseQuery = exports.make = void 0;
+const _1 = require(".");
+function make(obj) {
+    if (!(0, _1.isObject)(obj) || (0, _1.isEmpty)(obj))
+        return "";
+    return Object.entries(obj).reduce((a, b, idx) => {
+        const [key, value] = b;
+        if ((0, _1.isEmpty)(value))
+            return a;
+        if (!idx)
+            return `${a}?${key}=${encodeURIComponent(value)}`;
+        return `${a}&${key}=${value}`;
+    }, "");
+}
+exports.make = make;
+function parseQuery(str = '') {
+    if (!(0, _1.isString)(str) || (0, _1.isEmpty)(str))
+        return {};
+    const [, query] = str.split("?");
+    if ((0, _1.isEmpty)(query))
+        return {};
+    return query.split("&").filter(Boolean).reduce((a, b) => {
+        const [key, value] = b.split("=").filter(Boolean);
+        if ((0, _1.isEmpty)(value))
+            return a;
+        if ((0, _1.isNum)(Number(decodeURIComponent(value)))) {
+            a[key] = Number(decodeURIComponent(value));
+        }
+        else if (['true', 'false'].includes(decodeURIComponent(value))) {
+            a[key] = decodeURIComponent(value) === 'true';
+        }
+        else {
+            a[key] = decodeURIComponent(value);
+        }
+        return a;
+    }, {});
+}
+exports.parseQuery = parseQuery;
+function parseUrl(url) {
+    if (!(0, _1.isString)(url) || (0, _1.isEmpty)(url))
+        return '';
+    const [_url] = url.split("?");
+    return _url;
+}
+exports.parseUrl = parseUrl;
+function mergeQueryToURL(url, obj) {
+    const _url = parseUrl(url);
+    const _query = parseQuery(url);
+    const query = make(Object.assign(Object.assign({}, _query), obj));
+    return `${_url}${query}`;
+}
+exports.mergeQueryToURL = mergeQueryToURL;

package/lib/set.d.ts

@@ -0,0 +1,4 @@
+export declare function unrepetition<D = any>(array: D[], index?: string): D[];
+export declare function intersection<D = any>(array1: D[], array2: D[]): D[];
+export declare function union<D = any>(array1: D[], array2: D[]): D[];
+export declare function difference<D = any>(array1: D[], array2: D[]): D[];

package/lib/set.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.difference = exports.union = exports.intersection = exports.unrepetition = void 0;
+const type_1 = require("./type");
+function unrepetition(array, index) {
+    if ((0, type_1.isString)(index)) {
+        const maps = array.filter(item => (0, type_1.isObject)(item));
+        if (maps.length) {
+            const keys = unrepetition(maps.map(item => item[index]).filter(Boolean));
+            return keys.reduce((a, b, idx) => {
+                const item = maps.find(item => item[index] === b);
+                return a.concat([item]);
+            }, []);
+        }
+    }
+    return [...new Set(array)];
+}
+exports.unrepetition = unrepetition;
+function intersection(array1, array2) {
+    const temp = [...array1].filter((a) => array2.some((b) => b === a));
+    return [...new Set(temp)];
+}
+exports.intersection = intersection;
+function union(array1, array2) {
+    return [...new Set([...array1, ...array2])];
+}
+exports.union = union;
+function difference(array1, array2) {
+    const un = union(array1, array2);
+    const int = intersection(array1, array2);
+    return un.filter((u) => !int.some(i => i === u));
+}
+exports.difference = difference;

package/lib/time.d.ts

@@ -0,0 +1,17 @@
+type FormatType = "YYYY-MM-DD" | "YYYY/MM/DD" | "DD/MM/YYYY" | "YYYY-MM-DD HH:mm:ss" | "YYYY/MM/DD HH:mm:ss" | "DD/MM/YYYY HH:mm:ss" | "YYYY-MM-DD HH:mm" | "YYYY/MM/DD HH:mm" | "DD/MM/YYYY HH:mm" | "YYYY-MM-DD HH" | "YYYY/MM/DD HH" | "DD/MM/YYYY HH";
+export declare class Time {
+    private readonly time;
+    private static types;
+    static verification(time: string | number): number;
+    constructor(time: string | number);
+    private data;
+    private YYYY;
+    private MM;
+    private DD;
+    private HH;
+    private mm;
+    private ss;
+    private _format;
+    format(type: FormatType): string;
+}
+export {};

package/lib/time.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Time = void 0;
+class Time {
+    static verification(time) {
+        try {
+            return new Date(time).getTime();
+        }
+        catch (error) {
+            return Date.now();
+        }
+    }
+    constructor(time) {
+        this.time = time;
+        this.data = new Date(Time.verification(time));
+    }
+    YYYY() {
+        return this.data.getFullYear();
+    }
+    MM() {
+        const t = this.data.getMonth() + 1;
+        return String(t).padStart(2, "0");
+    }
+    DD() {
+        const t = this.data.getDate();
+        return String(t).padStart(2, "0");
+    }
+    HH() {
+        return this.data.getHours();
+    }
+    mm() {
+        return this.data.getMinutes();
+    }
+    ss() {
+        return this.data.getSeconds();
+    }
+    _format(type, sep = "/") {
+        if (!type)
+            return undefined;
+        return type
+            .split(sep)
+            .map((item) => {
+            return this[item]();
+        })
+            .join(sep);
+    }
+    format(type) {
+        let defaultTime = type;
+        if (!Time.types.includes(type)) {
+            defaultTime = "YYYY-MM-DD";
+        }
+        const [time1, time2] = defaultTime.split(" ");
+        return [time1, time2]
+            .map((i) => {
+            if (!i)
+                return undefined;
+            if (i.includes("-"))
+                return this._format(i, "-");
+            if (i.includes("/"))
+                return this._format(i, "/");
+            if (i.includes(":"))
+                return this._format(i, ":");
+            return undefined;
+        })
+            .filter(Boolean)
+            .join(" ");
+    }
+}
+exports.Time = Time;
+Time.types = [
+    "YYYY-MM-DD",
+    "YYYY/MM/DD",
+    "DD/MM/YYYY",
+    "YYYY-MM-DD HH:mm:ss",
+    "YYYY/MM/DD HH:mm:ss",
+    "DD/MM/YYYY HH:mm:ss",
+    "YYYY-MM-DD HH:mm",
+    "YYYY/MM/DD HH:mm",
+    "DD/MM/YYYY HH:mm",
+    "YYYY-MM-DD HH",
+    "YYYY/MM/DD HH",
+    "DD/MM/YYYY HH",
+];

package/lib/transform.d.ts

@@ -0,0 +1,7 @@
+import { ListToTreeSchema, TreeChildren } from '.';
+export declare function listToTree<P = any, I = "id", PI = "parentId">(list: P[], id: I, parentId: PI, value: any, schema?: ListToTreeSchema): TreeChildren<P>[];
+export declare function enumToList<K = number, V = string>(params: any): [K, V][];
+export declare function enumToOptions(params?: any): {
+    label: string;
+    value: any;
+}[];

package/lib/transform.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumToOptions = exports.enumToList = exports.listToTree = void 0;
+const type_1 = require("./type");
+function schemaToObj(obj, schema) {
+    if (!(0, type_1.isObject)(obj) || !schema || !(0, type_1.isObject)(schema) || (0, type_1.isEmpty)(schema))
+        return obj;
+    const keys = Object.entries(schema);
+    return Object.entries(obj).reduce((a, b) => {
+        const [key, value] = b;
+        const sch = keys.find((k) => k[0] === key);
+        if ((0, type_1.isArray)(sch) && !!sch && !!sch[1]) {
+            a[sch[1]] = value;
+        }
+        return a;
+    }, {});
+}
+function listToTree(list, id, parentId, value, schema) {
+    const root = list.filter((l) => l[parentId] == value);
+    const childrens = list.filter((l) => l[parentId] !== value);
+    return root.map((r) => {
+        return Object.assign(Object.assign({}, schemaToObj(r, schema)), { children: listToTree(childrens, id, parentId, r[id], schema) });
+    });
+}
+exports.listToTree = listToTree;
+function enumToList(params) {
+    if ((0, type_1.isEmpty)(params))
+        return [];
+    const list = [];
+    for (const key in params) {
+        if ((0, type_1.isNum)(params[key]))
+            list.push([params[key], key]);
+    }
+    return list;
+}
+exports.enumToList = enumToList;
+function enumToOptions(params = {}) {
+    return Object.entries(params).reduce((a, b) => {
+        return a.concat([{ label: b[0], value: b[1] }]);
+    }, []);
+}
+exports.enumToOptions = enumToOptions;

package/lib/type.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { BaseType } from "./interface";
+export declare function isFunc(func: any): func is Function;
+export declare function isArray(arr: any): arr is any[];
+export declare function isObject(obj: any): boolean;
+export declare function isString(str: any): str is string;
+export declare function isBigint(big: any): big is bigint;
+export declare function isBigInt64Array(big: any): big is bigint;
+export declare function isBigUint64Array(big: any): big is bigint;
+export declare function isBlob(data: any): data is Blob;
+export declare function isBuffer(data: any): data is Buffer;
+export declare function isFile(data: any): data is File;
+export declare function isBoolean(bol: any): bol is boolean;
+export declare function isSymbol(sbl: any): sbl is symbol;
+export declare function isNum(num: any): num is number;
+export declare function isDate(date: any): date is Date;
+export declare function isRegExp(reg: any): reg is RegExp;
+export declare function isUndefined(un?: any): un is undefined;
+export declare function isNull(un?: any): un is null;
+export declare function isPromise(obj?: any): obj is Promise<any>;
+export declare function type(value: any): BaseType;
+export declare function isEmpty(value: any): boolean;

package/lib/type.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = exports.type = exports.isPromise = exports.isNull = exports.isUndefined = exports.isRegExp = exports.isDate = exports.isNum = exports.isSymbol = exports.isBoolean = exports.isFile = exports.isBuffer = exports.isBlob = exports.isBigUint64Array = exports.isBigInt64Array = exports.isBigint = exports.isString = exports.isObject = exports.isArray = exports.isFunc = void 0;
+function isFunc(func) {
+    return Object.prototype.toString.call(func) === '[object Function]';
+}
+exports.isFunc = isFunc;
+function isArray(arr) {
+    return Object.prototype.toString.call(arr) === '[object Array]';
+}
+exports.isArray = isArray;
+function isObject(obj) {
+    return Object.prototype.toString.call(obj) === '[object Object]';
+}
+exports.isObject = isObject;
+function isString(str) {
+    return Object.prototype.toString.call(str) === '[object String]';
+}
+exports.isString = isString;
+function isBigint(big) {
+    return Object.prototype.toString.call(big) === '[object BigInt]';
+}
+exports.isBigint = isBigint;
+function isBigInt64Array(big) {
+    return Object.prototype.toString.call(big) === '[object BigInt64Array]';
+}
+exports.isBigInt64Array = isBigInt64Array;
+function isBigUint64Array(big) {
+    return Object.prototype.toString.call(big) === '[object BigUint64Array]';
+}
+exports.isBigUint64Array = isBigUint64Array;
+function isBlob(data) {
+    return Object.prototype.toString.call(data) === '[object Blob]';
+}
+exports.isBlob = isBlob;
+function isBuffer(data) {
+    return Object.prototype.toString.call(data) === '[object Buffer]';
+}
+exports.isBuffer = isBuffer;
+function isFile(data) {
+    return Object.prototype.toString.call(data) === '[object File]';
+}
+exports.isFile = isFile;
+function isBoolean(bol) {
+    return Object.prototype.toString.call(bol) === '[object Boolean]';
+}
+exports.isBoolean = isBoolean;
+function isSymbol(sbl) {
+    return Object.prototype.toString.call(sbl) === '[object Symbol]';
+}
+exports.isSymbol = isSymbol;
+function isNum(num) {
+    return Object.prototype.toString.call(num) === '[object Number]' && !isNaN(num);
+}
+exports.isNum = isNum;
+function isDate(date) {
+    return Object.prototype.toString.call(date) === '[object Date]';
+}
+exports.isDate = isDate;
+function isRegExp(reg) {
+    return Object.prototype.toString.call(reg) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+function isUndefined(un) {
+    return Object.prototype.toString.call(un) === '[object Undefined]';
+}
+exports.isUndefined = isUndefined;
+function isNull(un) {
+    return Object.prototype.toString.call(un) === '[object Null]';
+}
+exports.isNull = isNull;
+function isPromise(obj) {
+    return Object.prototype.toString.call(obj) === '[object Promise]';
+}
+exports.isPromise = isPromise;
+function type(value) {
+    if (isString(value))
+        return "string";
+    if (isNum(value))
+        return "number";
+    if (isArray(value))
+        return "array";
+    if (isObject(value))
+        return 'object';
+    if (isFunc(value))
+        return 'function';
+    if (isSymbol(value))
+        return 'symbol';
+    if (isUndefined(value))
+        return 'undefined';
+    if (isNull(value))
+        return "null";
+    if (isBigint(value))
+        return "bigint";
+    if (isBoolean(value))
+        return 'boolean';
+    return "undefined";
+}
+exports.type = type;
+function isEmpty(value) {
+    if (isUndefined(value) || isNull(value))
+        return true;
+    if (isArray(value))
+        return !value.length;
+    if (isObject(value))
+        return !Object.keys(value).length;
+    if (isString(value))
+        return !value;
+    return false;
+}
+exports.isEmpty = isEmpty;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@soratani-code/samtools",
+  "version": "1.3.1",
+  "description": "",
+  "typings": "lib/index.d.ts",
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest --verbose",
+    "build": "pnpm run build:lib && pnpm run build:dist",
+    "build:dist": "rollup --config rollup.config.js && rm -rf dist/lib",
+    "build:lib": "rm -rf lib && tsc -p ./tsconfig.json",
+    "changeset": "changeset",
+    "version": "changeset version && pnpm install"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/soratani/samtools.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/soratani/samtools/issues"
+  },
+  "homepage": "https://github.com/soratani/samtools#readme",
+  "devDependencies": {
+    "@changesets/cli": "^2.26.1",
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@types/enzyme": "^3.10.13",
+    "@types/jest": "^29.5.2",
+    "@types/node": "^20.2.5",
+    "@types/platform": "^1.3.3",
+    "enzyme": "^3.11.0",
+    "jest": "^29.5.0",
+    "jest-enzyme": "^7.1.2",
+    "rollup": "^4.14.2",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "tslib": "^2.6.2",
+    "typescript": "^4.8.3"
+  }
+}