@vitest/utils 0.27.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021-Present Anthony Fu <https://github.com/antfu>
+Copyright (c) 2021-Present Matias Capeletto <https://github.com/patak-dev>
+
+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/dist/diff.d.ts

@@ -0,0 +1,19 @@
+declare function formatLine(line: string, outputTruncateLength?: number): string;
+interface DiffOptions {
+    noColor?: boolean;
+    outputDiffMaxLines?: number;
+    outputTruncateLength?: number;
+    outputDiffLines?: number;
+    showLegend?: boolean;
+}
+/**
+* Returns unified diff between two strings with coloured ANSI output.
+*
+* @private
+* @param {String} actual
+* @param {String} expected
+* @return {string} The diff.
+*/
+declare function unifiedDiff(actual: string, expected: string, options?: DiffOptions): string;
+
+export { DiffOptions, formatLine, unifiedDiff };

package/dist/diff.js

@@ -0,0 +1,98 @@
+import c from 'picocolors';
+import * as diff from 'diff';
+import cliTruncate from 'cli-truncate';
+
+function formatLine(line, outputTruncateLength) {
+  var _a;
+  return cliTruncate(line, (outputTruncateLength ?? (((_a = process.stdout) == null ? void 0 : _a.columns) || 80)) - 4);
+}
+function unifiedDiff(actual, expected, options = {}) {
+  if (actual === expected)
+    return "";
+  const { outputTruncateLength, outputDiffLines, outputDiffMaxLines, noColor, showLegend = true } = options;
+  const indent = "  ";
+  const diffLimit = outputDiffLines || 15;
+  const diffMaxLines = outputDiffMaxLines || 50;
+  const counts = {
+    "+": 0,
+    "-": 0
+  };
+  let previousState = null;
+  let previousCount = 0;
+  const str = (str2) => str2;
+  const dim = noColor ? str : c.dim;
+  const green = noColor ? str : c.green;
+  const red = noColor ? str : c.red;
+  function preprocess(line) {
+    if (!line || line.match(/\\ No newline/))
+      return;
+    const char = line[0];
+    if ("-+".includes(char)) {
+      if (previousState !== char) {
+        previousState = char;
+        previousCount = 0;
+      }
+      previousCount++;
+      counts[char]++;
+      if (previousCount === diffLimit)
+        return dim(`${char} ...`);
+      else if (previousCount > diffLimit)
+        return;
+    }
+    return line;
+  }
+  const msg = diff.createPatch("string", expected, actual);
+  let lines = msg.split("\n").slice(5).map(preprocess).filter(Boolean);
+  let moreLines = 0;
+  const isCompact = counts["+"] === 1 && counts["-"] === 1 && lines.length === 2;
+  if (lines.length > diffMaxLines) {
+    const firstDiff = lines.findIndex((line) => line[0] === "-" || line[0] === "+");
+    const displayLines = lines.slice(firstDiff - 2, diffMaxLines);
+    const lastDisplayedIndex = firstDiff - 2 + diffMaxLines;
+    if (lastDisplayedIndex < lines.length)
+      moreLines = lines.length - lastDisplayedIndex;
+    lines = displayLines;
+  }
+  let formatted = lines.map((line) => {
+    line = line.replace(/\\"/g, '"');
+    if (line[0] === "-") {
+      line = formatLine(line.slice(1), outputTruncateLength);
+      if (isCompact)
+        return green(line);
+      return green(`- ${formatLine(line, outputTruncateLength)}`);
+    }
+    if (line[0] === "+") {
+      line = formatLine(line.slice(1), outputTruncateLength);
+      if (isCompact)
+        return red(line);
+      return red(`+ ${formatLine(line, outputTruncateLength)}`);
+    }
+    if (line.match(/@@/))
+      return "--";
+    return ` ${line}`;
+  });
+  if (moreLines)
+    formatted.push(dim(`... ${moreLines} more lines`));
+  if (showLegend) {
+    if (isCompact) {
+      formatted = [
+        `${green("- Expected")}   ${formatted[0]}`,
+        `${red("+ Received")}   ${formatted[1]}`
+      ];
+    } else {
+      if (formatted[0].includes('"'))
+        formatted[0] = formatted[0].replace('"', "");
+      const last = formatted.length - 1;
+      if (formatted[last].endsWith('"'))
+        formatted[last] = formatted[last].slice(0, formatted[last].length - 1);
+      formatted.unshift(
+        green(`- Expected  - ${counts["-"]}`),
+        red(`+ Received  + ${counts["+"]}`),
+        ""
+      );
+    }
+  }
+  return formatted.map((i) => i ? indent + i : i).join("\n");
+}
+
+export { formatLine, unifiedDiff };

package/dist/helpers.d.ts

@@ -0,0 +1,4 @@
+declare function assertTypes(value: unknown, name: string, types: string[]): void;
+declare function isObject(item: unknown): boolean;
+
+export { assertTypes, isObject };

package/dist/helpers.js

@@ -0,0 +1,11 @@
+function assertTypes(value, name, types) {
+  const receivedType = typeof value;
+  const pass = types.includes(receivedType);
+  if (!pass)
+    throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+}
+function isObject(item) {
+  return item != null && typeof item === "object" && !Array.isArray(item);
+}
+
+export { assertTypes, isObject };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { DiffOptions, formatLine, unifiedDiff } from './diff.js';
+export { assertTypes, isObject } from './helpers.js';
+export { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, MergeInsertions, MutableArray, Nullable } from './types.js';
+import { PrettyFormatOptions } from 'pretty-format';
+
+declare function stringify(object: unknown, maxDepth?: number, { maxLength, ...options }?: PrettyFormatOptions & {
+    maxLength?: number;
+}): string;
+
+export { stringify };

package/dist/index.js

@@ -0,0 +1,46 @@
+export { formatLine, unifiedDiff } from './diff.js';
+export { assertTypes, isObject } from './helpers.js';
+import { format, plugins } from 'pretty-format';
+import 'picocolors';
+import 'diff';
+import 'cli-truncate';
+
+const {
+  AsymmetricMatcher,
+  DOMCollection,
+  DOMElement,
+  Immutable,
+  ReactElement,
+  ReactTestComponent
+} = plugins;
+const PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  AsymmetricMatcher
+];
+function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
+  const MAX_LENGTH = maxLength ?? 1e4;
+  let result;
+  try {
+    result = format(object, {
+      maxDepth,
+      escapeString: false,
+      plugins: PLUGINS,
+      ...options
+    });
+  } catch {
+    result = format(object, {
+      callToJSON: false,
+      maxDepth,
+      escapeString: false,
+      plugins: PLUGINS,
+      ...options
+    });
+  }
+  return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(maxDepth / 2)) : result;
+}
+
+export { stringify };

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+type Awaitable<T> = T | PromiseLike<T>;
+type Nullable<T> = T | null | undefined;
+type Arrayable<T> = T | Array<T>;
+type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+type MergeInsertions<T> = T extends object ? {
+    [K in keyof T]: MergeInsertions<T[K]>;
+} : T;
+type DeepMerge<F, S> = MergeInsertions<{
+    [K in keyof F | keyof S]: K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never;
+}>;
+type MutableArray<T extends readonly any[]> = {
+    -readonly [k in keyof T]: T[k];
+};
+interface Constructable {
+    new (...args: any[]): any;
+}
+
+export { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, MergeInsertions, MutableArray, Nullable };

package/dist/types.js

@@ -0,0 +1 @@
+

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@vitest/utils",
+  "type": "module",
+  "version": "0.27.0",
+  "description": "Shared Vitest utility functions",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitest-dev/vitest.git",
+    "directory": "packages/utils"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./diff": {
+      "types": "./dist/diff.d.ts",
+      "import": "./dist/diff.js"
+    },
+    "./helpers": {
+      "types": "./dist/helpers.d.ts",
+      "import": "./dist/helpers.js"
+    },
+    "./*": "./*"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "cli-truncate": "^3.1.0",
+    "diff": "^5.1.0",
+    "picocolors": "^1.0.0",
+    "pretty-format": "^27.5.1"
+  },
+  "devDependencies": {
+    "@types/diff": "^5.0.2"
+  },
+  "scripts": {
+    "build": "rimraf dist && rollup -c",
+    "dev": "rollup -c --watch"
+  }
+}