@deot/dev-shared 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 deot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @deot/dev-shared
+
+公共方法
+
+## Logger
+
+| 方法                          | 说明                                             |
+| ---------------------------- | ----------------------------------------------- |
+| log                          | `console.log`                                   |
+| error                        | `console.error`                                 |
+
+## Shell
+
+| 方法                          | 说明                                             |
+| ---------------------------- | ----------------------------------------------- |
+| exec                         | `exec`                                          |
+| spawn                        | `spawn`                                         |
+
+## Utils
+
+| 方法                          | 说明                                             |
+| ---------------------------- | ----------------------------------------------- |
+| getHost                      | 获取当前ip                                       |
+| formatBytes                  | 字节转换                                         |
+| autoCatch                    | 捕获异常                                         |

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="node" />
+
+import * as childProcess from 'node:child_process';
+
+export declare interface AnyFunction<T = void> {
+    (...args: any[]): T;
+}
+
+declare const autoCatch: (impl: any, options?: Options) => Promise<any>;
+
+export declare type Customized<Origin = any, Extend = any> = Origin & Extend;
+
+declare const error: {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+};
+
+declare const exec: typeof childProcess.exec.__promisify__;
+
+declare const formatBytes: (size: number, suffix?: number) => string;
+
+declare const getHost: () => string;
+
+export declare type Hash<T> = Indexable<T>;
+
+export declare type Indexable<T = any> = {
+    [key: string]: T;
+};
+
+declare const info: {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+};
+
+declare const LOCAL_COMMAND_MAP: any;
+
+declare const log: {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+};
+
+declare namespace Logger {
+    export {
+        log,
+        error,
+        info
+    }
+}
+export { Logger }
+
+export declare type Nullable<T> = T | null;
+
+export declare type Options<T = {}> = Indexable & T;
+
+declare namespace Shell {
+    export {
+        LOCAL_COMMAND_MAP,
+        exec,
+        spawn
+    }
+}
+export { Shell }
+
+declare const spawn: (command: string, args?: string[]) => Promise<unknown>;
+
+export declare type TimeoutHandle = ReturnType<typeof global.setTimeout>;
+
+declare namespace Utils {
+    export {
+        getHost,
+        formatBytes,
+        autoCatch
+    }
+}
+export { Utils }
+
+export { }

package/dist/index.js

@@ -0,0 +1,107 @@
+import os from 'node:os';
+import path from 'node:path';
+import * as childProcess from 'node:child_process';
+import util from 'node:util';
+import fs from 'node:fs';
+
+const getHost = () => {
+    const ips = [];
+    const ntwk = os.networkInterfaces();
+    for (const k in ntwk) {
+        for (let i = 0; i < ntwk[k].length; i++) {
+            const _add = ntwk[k][i].address;
+            if (_add && _add.split('.').length == 4 && !ntwk[k][i].internal && ntwk[k][i].family == 'IPv4') {
+                ips.push(_add);
+            }
+        }
+    }
+    return ips[0];
+};
+const formatBytes = (size, suffix = 2) => {
+    if (!size)
+        return "0B";
+    const base = 1024;
+    const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    const index = Math.floor(Math.log(size) / Math.log(base));
+    const value = parseFloat((size / (base ** index)).toFixed(suffix));
+    return value + units[index];
+};
+const autoCatch = async (impl, options = {}) => {
+    const { onError = console.error } = options;
+    let target = impl;
+    typeof target === 'function' && (target = target());
+    try {
+        const e = await target;
+        return e;
+    }
+    catch (e) {
+        onError(e);
+    }
+};
+
+var utils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    autoCatch: autoCatch,
+    formatBytes: formatBytes,
+    getHost: getHost
+});
+
+const log = console.log;
+const error = console.error;
+const info = console.info;
+
+var logger = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    error: error,
+    info: info,
+    log: log
+});
+
+const SPACE = ' ';
+const binDirectory = path.resolve(process.cwd(), './node_modules/.bin');
+const LOCAL_COMMAND_MAP = fs.existsSync(binDirectory)
+    ? fs
+        .readdirSync(binDirectory)
+        .reduce((pre, file) => {
+        const fullpath = path.resolve(binDirectory, file);
+        const stat = fs.statSync(fullpath);
+        if (stat.isFile()) {
+            pre[file] = `./node_modules/.bin/${file}`;
+        }
+        return pre;
+    }, {})
+    : {};
+const exec = util.promisify(childProcess.exec);
+const spawn = (command, args = []) => {
+    const [command$, ...args$] = (command + SPACE + args.join(SPACE))
+        .replace(/\s+/g, SPACE)
+        .split(SPACE)
+        .filter(i => !!i)
+        .map(i => LOCAL_COMMAND_MAP[i] || i);
+    return new Promise((resolve, reject) => {
+        const emit = childProcess.spawn(command$, args$, {
+            stdio: 'inherit'
+        });
+        emit.on('close', (code) => {
+            if (code === 0) {
+                resolve(code);
+            }
+            else {
+                reject(code);
+            }
+        });
+        emit.on('error', (error) => {
+            !process.exitCode && (process.exitCode = 1);
+            reject(error);
+        });
+    });
+};
+
+var shell = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    LOCAL_COMMAND_MAP: LOCAL_COMMAND_MAP,
+    exec: exec,
+    spawn: spawn
+});
+
+export { logger as Logger, shell as Shell, utils as Utils };

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@deot/dev-shared",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "f960c31945e60a492e50e835cbf0c987a9fc3d5c"
+}