@rsdoctor/utils 1.1.9 → 1.2.0-beta.0

package/dist/esm/common/manifest.mjs

@@ -0,0 +1,30 @@
+import { decompressText } from "./algorithm.mjs";
+import { isRemoteUrl } from "./url.mjs";
+function isShardingData(data) {
+    if (Array.isArray(data) && data.length > 0) {
+        if (data.every((e)=>isRemoteUrl(e))) return true;
+    }
+    return false;
+}
+async function fetchShardingData(shardingFiles, fetchImplement) {
+    const res = await Promise.all(shardingFiles.map((url)=>fetchImplement(url)));
+    const strings = 0 === res.length ? [] : res.reduce((t, e)=>t + e);
+    return 'object' == typeof strings ? strings : JSON.parse(decompressText(strings));
+}
+async function fetchShardingFiles(data, fetchImplement, filterKeys) {
+    const datas = await Promise.all(Object.keys(data).map(async (_key)=>{
+        const key = _key;
+        const val = data[key];
+        if ((null == filterKeys ? void 0 : filterKeys.length) && filterKeys.indexOf(key) < 0) return {
+            [key]: []
+        };
+        if (isShardingData(val)) return {
+            [key]: await fetchShardingData(val, fetchImplement)
+        };
+        return {
+            [key]: val
+        };
+    }));
+    return datas.reduce((t, c)=>Object.assign(t, c));
+}
+export { fetchShardingData, fetchShardingFiles, isShardingData };

package/dist/esm/common/package.mjs

@@ -0,0 +1,56 @@
+import { compact, isEmpty, last } from "./lodash.mjs";
+const PACKAGE_PREFIX = /(?:node_modules|~)(?:\/\.pnpm)?/;
+const PACKAGE_SLUG = /[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*/;
+const VERSION = /@[\w|\-|_|.]+/;
+const VERSION_NUMBER = '@([\\d.]+)';
+const MODULE_PATH_PACKAGES = new RegExp([
+    `(?:${PACKAGE_PREFIX.source}/)`,
+    '(?:',
+    `(?:@${PACKAGE_SLUG.source}[/|+])?`,
+    `(?:${PACKAGE_SLUG.source}\\+)*`,
+    `(?:${PACKAGE_SLUG.source})`,
+    `(?:${VERSION.source})?`,
+    ')',
+    '(?:_',
+    `(?:@${PACKAGE_SLUG.source}[/|+])?`,
+    `(?:${PACKAGE_SLUG.source})`,
+    `(?:@${PACKAGE_SLUG.source})?`,
+    ')*',
+    '/'
+].join(''), 'g');
+const PACKAGE_PATH_NAME = /(?:(?:node_modules|~)(?:\/\.pnpm)?\/)(?:((?:@[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*[/|+])?(?:(?:[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*\+)*)(?:[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*))(?:@[\w|\-|_|.]+)?)(?:_((?:@[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*[/|+])?(?:[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*))(?:@[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*))*\//gm;
+const uniqLast = (data)=>{
+    const res = [];
+    data.forEach((item, index)=>{
+        if (!data.slice(index + 1).includes(item)) res.push(item);
+    });
+    return res;
+};
+const getPackageMetaFromModulePath = (modulePath)=>{
+    var _path_match_flat_slice, _path_match;
+    const paths = modulePath.match(MODULE_PATH_PACKAGES);
+    if (!paths) return {
+        name: '',
+        version: ''
+    };
+    const names = uniqLast(paths.flatMap((packagePath)=>{
+        const found = packagePath.matchAll(PACKAGE_PATH_NAME);
+        if (!found) return [];
+        const paksArray = compact([
+            ...found
+        ].flat());
+        return paksArray.slice(1).filter(Boolean).map((name)=>name.replace(/\+/g, '/'));
+    }));
+    if (isEmpty(names)) return {
+        name: '',
+        version: ''
+    };
+    const name = last(names);
+    const pattern = new RegExp(`(.*)(${last(paths)}).*`);
+    const path = modulePath.replace(pattern, '$1$2').replace(/\/$/, '');
+    return {
+        name,
+        version: path && name ? (null == (_path_match = path.match(new RegExp(`${name}${VERSION_NUMBER}`))) ? void 0 : null == (_path_match_flat_slice = _path_match.flat().slice(1)) ? void 0 : _path_match_flat_slice[0]) || '' : ''
+    };
+};
+export { MODULE_PATH_PACKAGES, PACKAGE_PATH_NAME, getPackageMetaFromModulePath };

package/dist/esm/common/plugin.mjs

@@ -0,0 +1,48 @@
+function getPluginHooks(plugin) {
+    return Object.keys(plugin);
+}
+function getPluginTapNames(plugin) {
+    const hooks = getPluginHooks(plugin);
+    const tapNames = new Set();
+    hooks.forEach((hook)=>{
+        plugin[hook].forEach((data)=>{
+            tapNames.add(data.tapName);
+        });
+    });
+    return [
+        ...tapNames
+    ];
+}
+function getPluginSummary(plugin) {
+    return {
+        hooks: getPluginHooks(plugin),
+        tapNames: getPluginTapNames(plugin)
+    };
+}
+function getPluginData(plugin, selectedHooks = [], selectedTapNames = []) {
+    const hooks = getPluginHooks(plugin).filter((hook)=>{
+        if (selectedHooks.length && -1 === selectedHooks.indexOf(hook)) return false;
+        return true;
+    });
+    if (!hooks.length) return [];
+    const tapNames = getPluginTapNames(plugin);
+    return tapNames.reduce((total, tapName)=>{
+        if (selectedTapNames.length && -1 === selectedTapNames.indexOf(tapName)) return total;
+        hooks.forEach((hook)=>{
+            const hookData = plugin[hook].filter((e)=>e.tapName === tapName);
+            if (0 === hookData.length) return;
+            total.push({
+                tapName,
+                hook,
+                data: hookData.map((e)=>({
+                        startAt: e.startAt,
+                        endAt: e.endAt,
+                        costs: e.costs,
+                        type: e.type
+                    }))
+            });
+        });
+        return total;
+    }, []);
+}
+export { getPluginData, getPluginHooks, getPluginSummary, getPluginTapNames };

package/dist/esm/common/resolver.mjs

@@ -0,0 +1,46 @@
+import { mergeIntervals } from "./algorithm.mjs";
+function isResolveSuccessData(data) {
+    return Boolean(data.result);
+}
+function isResolveFailData(data) {
+    return Boolean(data.error);
+}
+function getResolverCosts(resolver, resolvers) {
+    const blocked = resolvers.filter((e)=>e !== resolver && e.pid === resolver.pid && e.startAt >= resolver.startAt && e.endAt <= resolver.endAt);
+    let costs = resolver.endAt - resolver.startAt;
+    if (blocked.length) {
+        const intervals = blocked.map((e)=>[
+                Math.max(e.startAt, resolver.startAt),
+                Math.min(e.endAt, resolver.endAt)
+            ]);
+        mergeIntervals(intervals).forEach((e)=>{
+            const sub = e[1] - e[0];
+            costs -= sub;
+        });
+    }
+    return costs;
+}
+function getResolverFileTree(resolver) {
+    return resolver.map((e)=>({
+            issuerPath: e.issuerPath
+        }));
+}
+function getResolverFileDetails(filepath, resolvers, modules, moduleCodeMap) {
+    const module = modules.find((item)=>item.path === filepath);
+    const matchResolvers = resolvers.filter((e)=>e.issuerPath === filepath);
+    const before = module && moduleCodeMap && moduleCodeMap[module.id] ? moduleCodeMap[module.id].source : '';
+    const after = matchResolvers.reduce((t, c)=>{
+        if (c.request && isResolveSuccessData(c)) return t.replace(new RegExp(`["']${c.request}["']`), `"${c.result}"`);
+        return t;
+    }, before);
+    return {
+        filepath,
+        before,
+        after,
+        resolvers: matchResolvers.map((e)=>({
+                ...e,
+                costs: getResolverCosts(e, resolvers)
+            }))
+    };
+}
+export { getResolverCosts, getResolverFileDetails, getResolverFileTree, isResolveFailData, isResolveSuccessData };

package/dist/esm/common/rspack.mjs

@@ -0,0 +1,9 @@
+const RspackLoaderInternalPropertyName = '__l__';
+var rspack_RspackSummaryCostsDataName = /*#__PURE__*/ function(RspackSummaryCostsDataName) {
+    RspackSummaryCostsDataName["Bootstrap"] = "bootstrap->rspack:beforeCompile";
+    RspackSummaryCostsDataName["Compile"] = "rspack:beforeCompile->afterCompile";
+    RspackSummaryCostsDataName["Done"] = "rspack:afterCompile->done";
+    RspackSummaryCostsDataName["Minify"] = "rspack:minify(rspack:optimizeChunkAssets)";
+    return RspackSummaryCostsDataName;
+}({});
+export { RspackLoaderInternalPropertyName, rspack_RspackSummaryCostsDataName as RspackSummaryCostsDataName };

package/dist/esm/common/summary.mjs

@@ -0,0 +1,8 @@
+var summary_SummaryCostsDataName = /*#__PURE__*/ function(SummaryCostsDataName) {
+    SummaryCostsDataName["Bootstrap"] = "bootstrap->beforeCompile";
+    SummaryCostsDataName["Compile"] = "beforeCompile->afterCompile";
+    SummaryCostsDataName["Done"] = "afterCompile->done";
+    SummaryCostsDataName["Minify"] = "minify(processAssets)";
+    return SummaryCostsDataName;
+}({});
+export { summary_SummaryCostsDataName as SummaryCostsDataName };

package/dist/esm/common/time.mjs

@@ -0,0 +1,43 @@
+import { hrtime } from "process";
+function toFixedDigits(num, digits = 2) {
+    if (0 === digits) return Math.floor(num);
+    return +num.toFixed(digits);
+}
+function getUnit(num, type) {
+    let unit;
+    unit = 'm' === type ? num > 1 ? 'mins' : 'min' : num > 1 ? 'hours' : 'hour';
+    return unit;
+}
+function formatCosts(costs) {
+    costs = Number(costs);
+    if (costs >= 1000) {
+        const sec = costs / 1000;
+        if (sec >= 60) {
+            let mins = sec / 60;
+            if (mins >= 60) {
+                const hours = toFixedDigits(mins / 60, 0);
+                const restMins = toFixedDigits(mins % 60, 1);
+                const hUnit = getUnit(hours, 'h');
+                if (restMins > 0) return `${hours}${hUnit} ${restMins}${getUnit(restMins, 'm')}`;
+                return `${hours}${hUnit}`;
+            }
+            mins = toFixedDigits(mins, 0);
+            const mUnit = getUnit(mins, 'm');
+            const restSec = toFixedDigits(sec % 60, 0);
+            if (restSec > 0) return `${mins}${mUnit} ${restSec}s`;
+            return `${mins}${mUnit}`;
+        }
+        return `${toFixedDigits(sec, 1)}s`;
+    }
+    if (costs >= 10) return `${+toFixedDigits(costs, 0)}ms`;
+    if (costs >= 1) return `${+toFixedDigits(costs, 1)}ms`;
+    let r = +toFixedDigits(costs, 2);
+    if (0 === r) r = +toFixedDigits(costs, 3);
+    return `${r}ms`;
+}
+function getCurrentTimestamp(start, startHRTime) {
+    const endHRTime = hrtime(startHRTime);
+    const end = start + 1000 * endHRTime[0] + (process.env.RSTEST ? Math.round(endHRTime[1] / 1000000) : endHRTime[1] / 1000000);
+    return end;
+}
+export { formatCosts, getCurrentTimestamp, getUnit, toFixedDigits };

package/dist/esm/common/url.mjs

@@ -0,0 +1,14 @@
+import { isAbsolute } from "path";
+function isUrl(uri) {
+    return /^https?:\/\//.test(uri);
+}
+function isFilePath(uri) {
+    return isAbsolute(uri);
+}
+function isRemoteUrl(uri) {
+    if ('string' == typeof uri) {
+        if (isUrl(uri) || isFilePath(uri)) return true;
+    }
+    return false;
+}
+export { isFilePath, isRemoteUrl, isUrl };

package/dist/esm/error/error.mjs

@@ -0,0 +1,154 @@
+import { codeFrameColumns } from "@babel/code-frame";
+import { Err } from "@rsdoctor/types";
+import { createColors } from "picocolors";
+import deep_eql from "deep-eql";
+import strip_ansi from "strip-ansi";
+import { transform } from "./transform.mjs";
+import { insertSpace, toLevel } from "./utils.mjs";
+import { isNil } from "../common/lodash.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+let id = 1;
+class DevToolError extends Error {
+    static from(err, opt) {
+        if (err instanceof DevToolError) return err;
+        return transform(err, opt);
+    }
+    get level() {
+        return Err.ErrorLevel[this._level];
+    }
+    get path() {
+        var _this__codeFrame;
+        return null == (_this__codeFrame = this._codeFrame) ? void 0 : _this__codeFrame.filePath;
+    }
+    set path(file) {
+        if (!file) return;
+        if (this._codeFrame) {
+            this._codeFrame.filePath = file;
+            return;
+        }
+        this._codeFrame = {
+            filePath: file
+        };
+    }
+    get codeFrame() {
+        return this._codeFrame;
+    }
+    printCodeFrame(print) {
+        const msgs = [];
+        const { _codeFrame: codeFrameOpt, _controller: controller } = this;
+        if (!codeFrameOpt) return msgs;
+        if ('start' in codeFrameOpt && codeFrameOpt.start) {
+            const { filePath, start } = codeFrameOpt;
+            msgs.push(`\n ${print.red(print.bold('File: '))}${print.bold(filePath)}:${start.line}${start.column ? `:${start.column}` : ''}`);
+            if ('fileContent' in codeFrameOpt) {
+                const { end, fileContent } = codeFrameOpt;
+                msgs.push(codeFrameColumns(fileContent, {
+                    start,
+                    end
+                }, {
+                    highlightCode: !controller.noColor
+                }));
+            } else if ('lineText' in codeFrameOpt) {
+                const { length, lineText } = codeFrameOpt;
+                let lineCodeFrame = codeFrameColumns(lineText, {
+                    start: {
+                        line: 1,
+                        column: start.column
+                    },
+                    end: {
+                        line: 1,
+                        column: isNil(start.column) || isNil(length) ? void 0 : start.column + length
+                    }
+                }, {
+                    highlightCode: !controller.noColor
+                });
+                if (start.line > 1) {
+                    lineCodeFrame = lineCodeFrame.replace(' 1 |', ` ${start.line} |`);
+                    if (start.line >= 10) lineCodeFrame = insertSpace(lineCodeFrame, 2, String(start.line).length - 1);
+                }
+                msgs.push(lineCodeFrame);
+            }
+        } else msgs.push(`\n ${print.red(print.bold('File: '))}${print.bold(codeFrameOpt.filePath)}\n`);
+        return msgs;
+    }
+    toString() {
+        const msgs = [];
+        const { code, title, message, hint, referenceUrl, _controller: controller } = this;
+        const print = createColors(!controller.noColor);
+        const mainColorPrint = this._level === Err.ErrorLevel.Error ? print.red : print.yellow;
+        const codeText = code ? `${mainColorPrint(print.blue(code))}:` : '';
+        msgs.push(mainColorPrint(print.bold(`[${codeText}${this.level}:${title.toUpperCase()}] `) + message));
+        msgs.push(...this.printCodeFrame(print));
+        if (hint || referenceUrl) msgs.push('');
+        if (hint) msgs.push(` ${print.blue(`HINT: ${hint}`)}`);
+        if (referenceUrl) msgs.push(print.magenta(print.bold(` See: ${referenceUrl}`)));
+        if (!controller.noStack && this.stack) msgs.push(print.red(print.bold(` Error Stack:\n${this.stack}\n`)));
+        return msgs.join('\n');
+    }
+    toData() {
+        var _this_detail;
+        return {
+            ...this.detail,
+            id: this.id,
+            category: this.category,
+            description: strip_ansi((null == (_this_detail = this.detail) ? void 0 : _this_detail.description) ?? this.message),
+            title: this.title.toUpperCase(),
+            code: this.code,
+            level: this.level.toLowerCase()
+        };
+    }
+    toError() {
+        const error = new Error();
+        error.message = this.toString();
+        error.name = this.name;
+        error.stack = this.stack;
+        return error;
+    }
+    toJSON() {
+        return {
+            message: this.toString(),
+            name: this.name,
+            stack: this.stack
+        };
+    }
+    setControllerOption(opt) {
+        this._controller = {
+            noStack: opt.noStack ?? this._controller.noStack ?? true,
+            noColor: opt.noColor ?? this._controller.noColor ?? false
+        };
+    }
+    setCodeFrame(opt) {
+        this._codeFrame = opt;
+    }
+    isSame(error) {
+        return this.code === error.code && this.message === error.message && this.hint === error.hint && this.level === error.level && this.title === error.title && this.referenceUrl === error.referenceUrl && this.code === error.code && deep_eql(this.codeFrame, error.codeFrame);
+    }
+    constructor(title, message, opts){
+        super(message), _define_property(this, "id", void 0), _define_property(this, "code", void 0), _define_property(this, "category", void 0), _define_property(this, "title", void 0), _define_property(this, "detail", void 0), _define_property(this, "fixData", void 0), _define_property(this, "hint", void 0), _define_property(this, "referenceUrl", void 0), _define_property(this, "_codeFrame", void 0), _define_property(this, "_controller", {
+            noStack: true,
+            noColor: false
+        }), _define_property(this, "_level", void 0);
+        this.id = id++;
+        this.title = title;
+        this.code = null == opts ? void 0 : opts.code;
+        this.hint = null == opts ? void 0 : opts.hint;
+        this.stack = null == opts ? void 0 : opts.stack;
+        this.detail = null == opts ? void 0 : opts.detail;
+        this.fixData = null == opts ? void 0 : opts.fixData;
+        this.category = null == opts ? void 0 : opts.category;
+        this.referenceUrl = null == opts ? void 0 : opts.referenceUrl;
+        this._level = (null == opts ? void 0 : opts.level) ? toLevel(opts.level) : Err.ErrorLevel.Error;
+        this._codeFrame = null == opts ? void 0 : opts.codeFrame;
+        this.setControllerOption((null == opts ? void 0 : opts.controller) ?? {});
+    }
+}
+export { DevToolError };

package/dist/esm/error/index.mjs

@@ -0,0 +1,3 @@
+import { printErrors } from "./utils.mjs";
+export * from "./error.mjs";
+export { printErrors };

package/dist/esm/error/transform.mjs

@@ -0,0 +1,138 @@
+import strip_ansi from "strip-ansi";
+import { Linter } from "@rsdoctor/types";
+import { DevToolError } from "./error.mjs";
+function isEsbuildError(err) {
+    return 'pluginName' in err && 'text' in err && 'location' in err;
+}
+function isBabelError(err) {
+    return 'code' in err && 'reasonCode' in err;
+}
+function isDiagnosticError(err) {
+    return 'severity' in err && 'title' in err;
+}
+function parseBabelErrorMessage(input) {
+    var _lines_find;
+    const lines = strip_ansi(input).split('\n');
+    const filePath = lines[0].replace(/^([^:]+):.*/, '$1');
+    const message = lines[0].replace(/.*: (.*) \(\d+:\d+\)*/, '$1');
+    const lineText = (null == (_lines_find = lines.find((line)=>line.startsWith('> '))) ? void 0 : _lines_find.replace(/> \d+ \| /, '')) ?? '';
+    return {
+        message,
+        filePath,
+        lineText
+    };
+}
+function clearMessage(str) {
+    return strip_ansi(str).replace(/.*: (.*)\n\n[\s\S]*/g, '$1');
+}
+function clearStack(str) {
+    return str.slice(str.indexOf('  at')).replace(/\s*at(.*) \((.*)\)/g, '$1\n$2\n');
+}
+function transformEsbuildError(err, opt) {
+    if (isEsbuildError(err)) {
+        var _err_location;
+        const errorCode = (null == opt ? void 0 : opt.code) ?? 'ESBUILD_ERROR';
+        const speedyError = 'object' == typeof err.detail ? DevToolError.from(err.detail) : new DevToolError(errorCode, clearMessage(err.text), {
+            ...opt,
+            hint: null == (_err_location = err.location) ? void 0 : _err_location.suggestion,
+            codeFrame: {
+                filePath: err.text.split(':')[0]
+            }
+        });
+        if (err.location) speedyError.setCodeFrame({
+            filePath: err.location.file,
+            lineText: err.location.lineText,
+            length: err.location.length,
+            start: {
+                line: err.location.line,
+                column: err.location.column + 1
+            }
+        });
+        return speedyError;
+    }
+}
+function transformBabelError(err, opt) {
+    if (isBabelError(err)) {
+        const errorCode = (null == opt ? void 0 : opt.code) ?? err.code ?? 'BABEL';
+        const title = err.reasonCode;
+        const errorParsed = parseBabelErrorMessage(err.message);
+        const speedyError = new DevToolError(title, errorParsed.message, {
+            ...opt,
+            code: errorCode,
+            stack: err.stack && clearStack(err.stack)
+        });
+        if (err.loc) speedyError.setCodeFrame({
+            ...errorParsed,
+            start: {
+                line: err.loc.line,
+                column: err.loc.column + 1
+            }
+        });
+        return speedyError;
+    }
+}
+function transformNormalError(err, opt) {
+    if (err instanceof Error) {
+        var _stacks__getFileName, _stacks_;
+        const stacks = [];
+        const filePath = null == stacks ? void 0 : null == (_stacks_ = stacks[0]) ? void 0 : null == (_stacks__getFileName = _stacks_.getFileName) ? void 0 : _stacks__getFileName.call(_stacks_);
+        return new DevToolError(err.name, clearMessage(err.message), {
+            ...opt,
+            codeFrame: filePath ? {
+                filePath
+            } : void 0,
+            stack: err.stack && clearStack(err.stack)
+        });
+    }
+}
+function transformErrorLike(err, opt) {
+    const isErrorLike = err && 'object' == typeof err && err.message;
+    if (isErrorLike) {
+        var _stacks__getFileName, _stacks_;
+        const stacks = [];
+        const filePath = null == stacks ? void 0 : null == (_stacks_ = stacks[0]) ? void 0 : null == (_stacks__getFileName = _stacks_.getFileName) ? void 0 : _stacks__getFileName.call(_stacks_);
+        return new DevToolError(err.name || 'UNKNOWN_ERROR', clearMessage(err.message), {
+            ...opt,
+            codeFrame: filePath ? {
+                filePath
+            } : void 0,
+            stack: err.stack && clearStack(err.stack)
+        });
+    }
+}
+function transformDiagnostic(err, opt) {
+    if (isDiagnosticError(err)) {
+        var _err_suggestions, _err_suggestions1;
+        return new DevToolError(err.title, err.message, {
+            ...err,
+            ...opt,
+            hint: null == (_err_suggestions = err.suggestions) ? void 0 : _err_suggestions.description,
+            fixData: null == (_err_suggestions1 = err.suggestions) ? void 0 : _err_suggestions1.fixData,
+            codeFrame: err.document ? {
+                filePath: err.document.path,
+                fileContent: err.document.content,
+                start: err.document.range.start,
+                end: err.document.range.end
+            } : void 0,
+            level: Linter.Severity[err.severity]
+        });
+    }
+}
+function defaultError(err, opt) {
+    return new DevToolError('UNKNOWN_ERROR', JSON.stringify(err), opt);
+}
+function transform(err, opt) {
+    const transformers = [
+        transformEsbuildError,
+        transformBabelError,
+        transformDiagnostic,
+        transformNormalError,
+        transformErrorLike
+    ];
+    for (const fn of transformers){
+        const result = fn(err, opt);
+        if (result) return result;
+    }
+    return defaultError(err, opt);
+}
+export { transform };

package/dist/esm/error/utils.mjs

@@ -0,0 +1,22 @@
+import { Err } from "@rsdoctor/types";
+function toLevel(level) {
+    return Err.ErrorLevel[level];
+}
+function insertSpace(rawLines, line, width) {
+    const lines = rawLines.split('\n');
+    lines[line - 1] = Array(width).fill(' ').join('') + lines[line - 1];
+    return lines.join('\n');
+}
+function printErrors({ errors, warnings }, logLevel = 'Error') {
+    const onlyError = 'Error' === logLevel;
+    if ('Silent' === logLevel) return '';
+    if (onlyError && 0 === errors.length || !onlyError && 0 === errors.length && 0 === warnings.length) return '';
+    const msgs = [];
+    if (onlyError) msgs.push(`Build failed with ${errors.length} error:`, ...errors.map((item)=>item.toString()), '');
+    else {
+        const title = 0 === errors.length ? `Build succuss with ${warnings.length} warning:` : `Build failed with ${errors.length} error, ${warnings.length} warning:`;
+        msgs.push(title, ...errors.map((item)=>item.toString()), ...warnings.map((item)=>item.toString()), '');
+    }
+    return msgs.join('\n\n');
+}
+export { insertSpace, printErrors, toLevel };

package/dist/esm/index.mjs

@@ -0,0 +1,3 @@
+import * as __WEBPACK_EXTERNAL_MODULE__rule_utils_index_mjs_79331901__ from "./rule-utils/index.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__logger_mjs_dfc7ebda__ from "./logger.mjs";
+export { __WEBPACK_EXTERNAL_MODULE__logger_mjs_dfc7ebda__ as Logger, __WEBPACK_EXTERNAL_MODULE__rule_utils_index_mjs_79331901__ as RuleUtils };

package/dist/esm/logger.mjs

@@ -0,0 +1,49 @@
+import picocolors from "picocolors";
+import { logger } from "rslog";
+import { Constants } from "@rsdoctor/types";
+function debug(getMsg, prefix = '') {
+    if (!process.env.DEBUG) return;
+    logger.level = 'verbose';
+    logger.debug(`${prefix} ${getMsg()}`);
+}
+logger.override({
+    log: (message)=>{
+        console.log(`${picocolors.green('[RSDOCTOR LOG]')} ${message}`);
+    },
+    info: (message)=>{
+        console.log(`${picocolors.yellow('[RSDOCTOR INFO]')} ${message}`);
+    },
+    warn: (message)=>{
+        console.warn(`${picocolors.yellow('[RSDOCTOR WARN]')} ${message}`);
+    },
+    start: (message)=>{
+        console.log(`${picocolors.green('[RSDOCTOR START]')} ${message}`);
+    },
+    ready: (message)=>{
+        console.log(`${picocolors.green('[RSDOCTOR READY]')} ${message}`);
+    },
+    error: (message)=>{
+        console.error(`${picocolors.red('[RSDOCTOR ERROR]')} ${message}`);
+    },
+    success: (message)=>{
+        console.error(`${picocolors.green('[RSDOCTOR SUCCESS]')} ${message}`);
+    },
+    debug: (message)=>{
+        if (process.env.DEBUG) console.log(`${picocolors.blue('[RSDOCTOR DEBUG]')} ${message}`);
+    }
+});
+const _timers = new Map();
+function time(label) {
+    if (process.env.DEBUG !== Constants.RsdoctorProcessEnvDebugKey) return;
+    if (_timers.has(label)) return;
+    _timers.set(label, Date.now());
+}
+function timeEnd(label) {
+    if (process.env.DEBUG !== Constants.RsdoctorProcessEnvDebugKey) return;
+    const start = _timers.get(label);
+    if (null == start) return void logger.debug(`Timer '${label}' does not exist.`);
+    const duration = Date.now() - start;
+    logger.debug(`Timer '${label}' ended: ${duration}ms`);
+    _timers.delete(label);
+}
+export { picocolors as chalk, debug, logger, time, timeEnd };