@rsdoctor/utils 1.1.10 → 1.2.0-beta.0

package/dist/esm/error/error.js

@@ -1,202 +0,0 @@
-import { codeFrameColumns } from "@babel/code-frame";
-import { Err } from "@rsdoctor/types";
-import { createColors } from "picocolors";
-import deepEql from "deep-eql";
-import stripAnsi from "strip-ansi";
-import { transform } from "./transform";
-import { insertSpace, toLevel } from "./utils";
-import { isNil } from "../common/lodash";
-let id = 1;
-class DevToolError extends Error {
-  constructor(title, message, opts) {
-    super(message);
-    this._controller = {
-      noStack: true,
-      noColor: false
-    };
-    this.id = id++;
-    this.title = title;
-    this.code = opts?.code;
-    this.hint = opts?.hint;
-    this.stack = opts?.stack;
-    this.detail = opts?.detail;
-    this.fixData = opts?.fixData;
-    this.category = opts?.category;
-    this.referenceUrl = opts?.referenceUrl;
-    this._level = opts?.level ? toLevel(opts.level) : Err.ErrorLevel.Error;
-    this._codeFrame = opts?.codeFrame;
-    this.setControllerOption(opts?.controller ?? {});
-  }
-  static from(err, opt) {
-    if (err instanceof DevToolError) {
-      return err;
-    }
-    return transform(err, opt);
-  }
-  get level() {
-    return Err.ErrorLevel[this._level];
-  }
-  get path() {
-    return 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(
-        `
- ${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(
-        `
- ${print.red(print.bold("File: "))}${print.bold(
-          codeFrameOpt.filePath
-        )}
-`
-      );
-    }
-    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:
-${this.stack}
-`)));
-    }
-    return msgs.join("\n");
-  }
-  toData() {
-    return {
-      ...this.detail,
-      id: this.id,
-      category: this.category,
-      description: stripAnsi(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;
-  }
-  /**
-   * for json stringify
-   */
-  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 && deepEql(this.codeFrame, error.codeFrame);
-  }
-}
-export {
-  DevToolError
-};

package/dist/esm/error/index.js

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

package/dist/esm/error/transform.js

@@ -1,141 +0,0 @@
-import stripAnsi from "strip-ansi";
-import { Linter } from "@rsdoctor/types";
-import { DevToolError } from "./error";
-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) {
-  const lines = stripAnsi(input).split("\n");
-  const filePath = lines[0].replace(/^([^:]+):.*/, "$1");
-  const message = lines[0].replace(/.*: (.*) \(\d+:\d+\)*/, "$1");
-  const lineText = lines.find((line) => line.startsWith("> "))?.replace(/> \d+ \| /, "") ?? "";
-  return {
-    message,
-    filePath,
-    lineText
-  };
-}
-function clearMessage(str) {
-  return stripAnsi(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)) {
-    const errorCode = opt?.code ?? "ESBUILD_ERROR";
-    const speedyError = typeof err.detail === "object" ? DevToolError.from(err.detail) : new DevToolError(errorCode, clearMessage(err.text), {
-      ...opt,
-      hint: 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 = 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) {
-    const stacks = [];
-    const filePath = stacks?.[0]?.getFileName?.();
-    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 && typeof err === "object" && err.message;
-  if (isErrorLike) {
-    const stacks = [];
-    const filePath = stacks?.[0]?.getFileName?.();
-    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)) {
-    return new DevToolError(err.title, err.message, {
-      ...err,
-      ...opt,
-      hint: err.suggestions?.description,
-      fixData: err.suggestions?.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.js

@@ -1,40 +0,0 @@
-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 = logLevel === "Error";
-  if (logLevel === "Silent") {
-    return "";
-  }
-  if (onlyError && errors.length === 0 || !onlyError && errors.length === 0 && warnings.length === 0) {
-    return "";
-  }
-  const msgs = [];
-  if (onlyError) {
-    msgs.push(
-      `Build failed with ${errors.length} error:`,
-      ...errors.map((item) => item.toString()),
-      ""
-    );
-  } else {
-    const title = errors.length === 0 ? `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.js

@@ -1,6 +0,0 @@
-import * as RuleUtils from "./rule-utils";
-import * as Logger from "./logger";
-export {
-  Logger,
-  RuleUtils
-};

package/dist/esm/logger.js

@@ -1,44 +0,0 @@
-import c from "picocolors";
-import { createLogger, logger } from "rslog";
-import { Constants } from "@rsdoctor/types";
-function debug(getMsg, prefix = "") {
-  if (!process.env[Constants.RsdoctorProcessEnvDebugKey]) {
-    return;
-  }
-  logger.level = "verbose";
-  logger.debug(`${prefix} ${getMsg()}`);
-}
-const rsdoctorLogger = createLogger();
-rsdoctorLogger.override({
-  log: (message) => {
-    console.log(`${c.green("[RSDOCTOR LOG]")} ${message}`);
-  },
-  info: (message) => {
-    console.log(`${c.yellow("[RSDOCTOR INFO]")} ${message}`);
-  },
-  warn: (message) => {
-    console.warn(`${c.yellow("[RSDOCTOR WARN]")} ${message}`);
-  },
-  start: (message) => {
-    console.log(`${c.green("[RSDOCTOR START]")} ${message}`);
-  },
-  ready: (message) => {
-    console.log(`${c.green("[RSDOCTOR READY]")} ${message}`);
-  },
-  error: (message) => {
-    console.error(`${c.red("[RSDOCTOR ERROR]")} ${message}`);
-  },
-  success: (message) => {
-    console.error(`${c.green("[RSDOCTOR SUCCESS]")} ${message}`);
-  },
-  debug: (message) => {
-    if (process.env.DEBUG) {
-      console.log(`${c.blue("[RSDOCTOR DEBUG]")} ${message}`);
-    }
-  }
-});
-export {
-  c as chalk,
-  debug,
-  rsdoctorLogger as logger
-};

package/dist/esm/rule-utils/document/document.js

@@ -1,67 +0,0 @@
-import { LinesAndColumns } from "lines-and-columns";
-import { isNumber, isUndefined } from "../../common/lodash";
-class Document {
-  constructor(content) {
-    /** Actual document content. */
-    this._text = "";
-    this._text;
-    this._text = content;
-    this.createFinder();
-  }
-  /** Generate location search */
-  createFinder() {
-    const find = new LinesAndColumns(this._text);
-    this.positionAt = (offset) => {
-      if (offset >= this._text.length) {
-        offset = this._text.length - 1;
-      }
-      if (offset < 0) {
-        offset = 0;
-      }
-      const result = find.locationForIndex(offset);
-      if (!result) {
-        return;
-      }
-      return {
-        line: result.line + 1,
-        column: result.column
-      };
-    };
-    this.offsetAt = (position) => {
-      return find.indexForLocation({
-        line: position.line - 1,
-        column: position.column
-      }) ?? void 0;
-    };
-  }
-  getText(range) {
-    if (!range) {
-      return this._text;
-    }
-    const start = typeof range.start === "number" ? range.start : this.offsetAt(range.start);
-    const end = typeof range.end === "number" ? range.end : this.offsetAt(range.end);
-    if (isUndefined(start)) {
-      throw new Error(`Location ${JSON.stringify(start)} is illegal`);
-    }
-    if (isUndefined(end)) {
-      throw new Error(`Location ${JSON.stringify(end)} is illegal`);
-    }
-    return this._text.slice(start, end);
-  }
-  /** Edit document data */
-  edit(data) {
-    let { _text: content } = this;
-    const startOffset = isNumber(data.start) ? data.start : this.offsetAt(data.start);
-    const endOffset = isNumber(data.end) ? data.end : this.offsetAt(data.end);
-    if (isUndefined(startOffset) || isUndefined(endOffset)) {
-      return;
-    }
-    const startTxt = content.substring(0, startOffset);
-    const endTxt = content.substring(endOffset, content.length);
-    content = startTxt + data.newText + endTxt;
-    return content;
-  }
-}
-export {
-  Document
-};

package/dist/esm/rule-utils/document/index.js

@@ -1,3 +0,0 @@
-export * from "./document";
-export * from "./types";
-export * from "./server";

package/dist/esm/rule-utils/document/server.js

@@ -1,17 +0,0 @@
-import { Document } from "./document";
-const store = /* @__PURE__ */ new Map();
-function getDocument(content) {
-  if (store.has(content)) {
-    return store.get(content);
-  }
-  const doc = new Document(content);
-  store.set(content, doc);
-  return doc;
-}
-function clearDocument() {
-  store.clear();
-}
-export {
-  clearDocument,
-  getDocument
-};

package/dist/esm/rule-utils/index.js

@@ -1,2 +0,0 @@
-export * from "./document";
-export * from "./parser";

package/dist/esm/rule-utils/parser/asserts.js

@@ -1,132 +0,0 @@
-import { isObject } from "../../common/lodash";
-function isSyntaxNode(node) {
-  return isObject(node) && "type" in node;
-}
-function assertCreator(type) {
-  return (node) => {
-    return isSyntaxNode(node) && node.type === type;
-  };
-}
-const asserts = {
-  isProgram: assertCreator("Program"),
-  isEmptyStatement: assertCreator("EmptyStatement"),
-  isBlockStatement: assertCreator("BlockStatement"),
-  isStaticBlock: assertCreator("StaticBlock"),
-  isExpressionStatement: assertCreator(
-    "ExpressionStatement"
-  ),
-  isIfStatement: assertCreator("IfStatement"),
-  isLabeledStatement: assertCreator("LabeledStatement"),
-  isBreakStatement: assertCreator("BreakStatement"),
-  isContinueStatement: assertCreator("ContinueStatement"),
-  isWithStatement: assertCreator("WithStatement"),
-  isSwitchStatement: assertCreator("SwitchStatement"),
-  isReturnStatement: assertCreator("ReturnStatement"),
-  isThrowStatement: assertCreator("ThrowStatement"),
-  isTryStatement: assertCreator("TryStatement"),
-  isWhileStatement: assertCreator("WhileStatement"),
-  isDoWhileStatement: assertCreator("DoWhileStatement"),
-  isForStatement: assertCreator("ForStatement"),
-  isForInStatement: assertCreator("ForInStatement"),
-  isForOfStatement: assertCreator("ForOfStatement"),
-  isDebuggerStatement: assertCreator("DebuggerStatement"),
-  isFunctionDeclaration: assertCreator(
-    "FunctionDeclaration"
-  ),
-  isVariableDeclaration: assertCreator(
-    "VariableDeclaration"
-  ),
-  isVariableDeclarator: assertCreator("VariableDeclarator"),
-  isChainExpression: assertCreator("ChainExpression"),
-  isThisExpression: assertCreator("ThisExpression"),
-  isArrayExpression: assertCreator("ArrayExpression"),
-  isObjectExpression: assertCreator("ObjectExpression"),
-  isPrivateIdentifier: assertCreator("PrivateIdentifier"),
-  isProperty: assertCreator("Property"),
-  isPropertyDefinition: assertCreator("PropertyDefinition"),
-  isFunctionExpression: assertCreator("FunctionExpression"),
-  isSequenceExpression: assertCreator("SequenceExpression"),
-  isUnaryExpression: assertCreator("UnaryExpression"),
-  isBinaryExpression: assertCreator("BinaryExpression"),
-  isAssignmentExpression: assertCreator(
-    "AssignmentExpression"
-  ),
-  isUpdateExpression: assertCreator("UpdateExpression"),
-  isLogicalExpression: assertCreator("LogicalExpression"),
-  isConditionalExpression: assertCreator(
-    "ConditionalExpression"
-  ),
-  isNewExpression: assertCreator("NewExpression"),
-  isSwitchCase: assertCreator("SwitchCase"),
-  isCatchClause: assertCreator("CatchClause"),
-  isIdentifier: assertCreator("Identifier"),
-  isLiteral: assertCreator("Literal"),
-  isSuper: assertCreator("Super"),
-  isSpreadElement: assertCreator("SpreadElement"),
-  isArrowFunctionExpression: assertCreator(
-    "ArrowFunctionExpression"
-  ),
-  isYieldExpression: assertCreator("YieldExpression"),
-  isTemplateLiteral: assertCreator("TemplateLiteral"),
-  isTaggedTemplateExpression: assertCreator(
-    "TaggedTemplateExpression"
-  ),
-  isTemplateElement: assertCreator("TemplateElement"),
-  isObjectPattern: assertCreator("ObjectPattern"),
-  isArrayPattern: assertCreator("ArrayPattern"),
-  isRestElement: assertCreator("RestElement"),
-  isAssignmentPattern: assertCreator("AssignmentPattern"),
-  isClassBody: assertCreator("ClassBody"),
-  isClassDeclaration: assertCreator("ClassDeclaration"),
-  isClassExpression: assertCreator("ClassExpression"),
-  isMetaProperty: assertCreator("MetaProperty"),
-  isImportDeclaration: assertCreator("ImportDeclaration"),
-  isImportSpecifier: assertCreator("ImportSpecifier"),
-  isImportExpression: assertCreator("ImportExpression"),
-  isImportDefaultSpecifier: assertCreator(
-    "ImportDefaultSpecifier"
-  ),
-  isImportNamespaceSpecifier: assertCreator(
-    "ImportNamespaceSpecifier"
-  ),
-  isExportNamedDeclaration: assertCreator(
-    "ExportNamedDeclaration"
-  ),
-  isExportSpecifier: assertCreator("ExportSpecifier"),
-  isExportDefaultDeclaration: assertCreator(
-    "ExportDefaultDeclaration"
-  ),
-  isExportAllDeclaration: assertCreator(
-    "ExportAllDeclaration"
-  ),
-  isAwaitExpression: assertCreator("AwaitExpression"),
-  isMethodDefinition: assertCreator("MethodDefinition"),
-  isMemberExpression: assertCreator("MemberExpression"),
-  isComment(node) {
-    return isSyntaxNode(node) && (node.type === "Line" || node.type === "Block");
-  },
-  isDirective(node) {
-    return asserts.isExpressionStatement(node) && "directive" in node;
-  },
-  isSimpleCallExpression(node) {
-    return isSyntaxNode(node) && node.type === "CallExpression";
-  },
-  isAssignmentProperty(node) {
-    return asserts.isProperty(node) && node.kind === "init";
-  },
-  isSimpleLiteral(node) {
-    return asserts.isLiteral(node) && !asserts.isRegExpLiteral(node) && !asserts.isBigIntLiteral(node);
-  },
-  isRegExpLiteral(node) {
-    return asserts.isLiteral(node) && "regex" in node;
-  },
-  isBigIntLiteral(node) {
-    return asserts.isLiteral(node) && "bigint" in node;
-  },
-  isExportStatement(node) {
-    return asserts.isExportAllDeclaration(node) || asserts.isExportDefaultDeclaration(node) || asserts.isExportNamedDeclaration(node);
-  }
-};
-export {
-  asserts
-};

package/dist/esm/rule-utils/parser/index.js

@@ -1,4 +0,0 @@
-export * from "./asserts";
-export * from "./parser";
-export * from "./utils";
-export * from "./types";