@rsdoctor/utils 0.0.0-next-20240620044732

package/dist/esm/error/error.js

@@ -0,0 +1,202 @@
+import { codeFrameColumns } from "@babel/code-frame";
+import { Err } from "@rsdoctor/types";
+import { Instance } from "chalk";
+import deepEql from "deep-eql";
+import { isNil } from "lodash";
+import stripAnsi from "strip-ansi";
+import { transform } from "./transform";
+import { insertSpace, toLevel } from "./utils";
+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 = controller.noColor ? new Instance({ level: 0 }) : new Instance({ level: 3 });
+    const mainColorPrint = this._level === Err.ErrorLevel.Error ? print.red : print.yellow;
+    const codeText = code ? `${mainColorPrint.blue(code)}:` : "";
+    msgs.push(
+      mainColorPrint.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.bold(` See: ${referenceUrl}`));
+    }
+    if (!controller.noStack && this.stack) {
+      msgs.push(print.red.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

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

package/dist/esm/error/transform.js

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,40 @@
+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

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

package/dist/esm/logger.js

@@ -0,0 +1,15 @@
+import chalk from "chalk";
+import { 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()}`);
+}
+export {
+  chalk,
+  debug,
+  logger
+};

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

@@ -0,0 +1,67 @@
+import { LinesAndColumns } from "lines-and-columns";
+import { isUndefined, isNumber } from "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

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

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

@@ -0,0 +1,17 @@
+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

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

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

@@ -0,0 +1,132 @@
+import { isObject } from "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

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