@d-es-ign/stryker-js-util 9.6.0

package/src/noop-logger.ts

@@ -0,0 +1,38 @@
+export const noopLogger = {
+  isTraceEnabled(): boolean {
+    return false;
+  },
+  isDebugEnabled(): boolean {
+    return false;
+  },
+  isInfoEnabled(): boolean {
+    return false;
+  },
+  isWarnEnabled(): boolean {
+    return false;
+  },
+  isErrorEnabled(): boolean {
+    return false;
+  },
+  isFatalEnabled(): boolean {
+    return false;
+  },
+  trace(): void {
+    // noop
+  },
+  debug(): void {
+    // noop
+  },
+  info(): void {
+    // noop
+  },
+  warn(): void {
+    // noop
+  },
+  error(): void {
+    // noop
+  },
+  fatal(): void {
+    // noop
+  },
+};

package/src/not-empty.ts

@@ -0,0 +1,3 @@
+export function notEmpty<T>(item: T | null | undefined): item is T {
+  return item !== undefined && item !== null;
+}

package/src/platform.ts

@@ -0,0 +1,10 @@
+export const platform = {
+  /**
+   * Tells whether the filesystem is case sensitive.
+   *
+   * @returns false on Win32, true elsewhere
+   */
+  caseSensitiveFs(): boolean {
+    return process.platform != 'win32';
+  },
+};

package/src/primitive.ts

@@ -0,0 +1 @@
+export type Primitive = boolean | number | string | null | undefined;

package/src/require-resolve.ts

@@ -0,0 +1,19 @@
+import { createRequire } from 'module';
+
+/**
+ * Require a module from the current working directory (or a different base dir)
+ * @see https://nodejs.org/api/modules.html#modules_require_resolve_paths_request
+ */
+export function requireResolve(id: string, from = process.cwd()): unknown {
+  const require = createRequire(import.meta.url);
+  return require(resolveFromCwd(id, from));
+}
+
+/**
+ * Resolves a module from the current working directory (or a different base dir)
+ * @see https://nodejs.org/api/modules.html#modules_require_resolve_paths_request
+ */
+export function resolveFromCwd(id: string, cwd = process.cwd()): string {
+  const require = createRequire(import.meta.url);
+  return require.resolve(id, { paths: [cwd] });
+}

package/src/split.ts

@@ -0,0 +1,16 @@
+export function split<T>(
+  values: Iterable<T>,
+  predicate: (value: T, index: number) => boolean,
+): [T[], T[]] {
+  const left: T[] = [];
+  const right: T[] = [];
+  let index = 0;
+  for (const value of values) {
+    if (predicate(value, index++)) {
+      left.push(value);
+    } else {
+      right.push(value);
+    }
+  }
+  return [left, right];
+}

package/src/string-utils.ts

@@ -0,0 +1,76 @@
+import { KnownKeys } from './known-keys.js';
+import { Primitive } from './primitive.js';
+
+type OnlyObject<T> = Exclude<T, Primitive>;
+
+/**
+ * Consolidates multiple consecutive white spaces into a single space.
+ * @param str The string to be normalized
+ */
+export function normalizeWhitespaces(str: string): string {
+  return str.replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * Normalizes line endings as unix style.
+ */
+export function normalizeLineEndings(text: string): string {
+  return text.replace(/\r\n/g, '\n');
+}
+
+export interface PropertyPathOverloads<T> {
+  (key: KnownKeys<T>): string;
+  <TProp1 extends KnownKeys<T>>(
+    key: TProp1,
+    key2: KnownKeys<OnlyObject<T[TProp1]>>,
+  ): string;
+  <
+    TProp1 extends KnownKeys<T>,
+    TProp2 extends KnownKeys<OnlyObject<T[TProp1]>>,
+  >(
+    key: TProp1,
+    key2: TProp2,
+    key3: KnownKeys<OnlyObject<OnlyObject<T[TProp1]>[TProp2]>>,
+  ): string;
+}
+
+/**
+ * Given a base type, allows type safe access to the name of a property.
+ * @param prop The property name
+ */
+export function propertyPath<T>(): PropertyPathOverloads<T> {
+  const fn: PropertyPathOverloads<T> = ((...args: string[]) =>
+    args.join('.')) as unknown as PropertyPathOverloads<T>;
+  return fn;
+}
+
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
+ */
+export function escapeRegExpLiteral(input: string): string {
+  return input.replace(/[.*+\-?^${}()|[\]\\/]/g, '\\$&'); // $& means the whole matched string
+}
+
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
+ */
+export function escapeRegExp(input: string): string {
+  return input.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+
+/**
+ * Normalizes relative or absolute file names to be in posix format (forward slashes '/')
+ */
+export function normalizeFileName(fileName: string): string {
+  return fileName.replace(/\\/g, '/');
+}
+
+/**
+ * Creates a URL to the page where you can report a bug.
+ * @param titleSuggestion The title to be prefilled in.
+ */
+export function strykerReportBugUrl(titleSuggestion: string): string {
+  return `https://github.com/stryker-mutator/stryker-js/issues/new?assignees=&labels=%F0%9F%90%9B+Bug&template=bug_report.md&title=${encodeURIComponent(
+    titleSuggestion,
+  )}`;
+}

package/src/stryker-error.ts

@@ -0,0 +1,12 @@
+import { errorToString } from './errors.js';
+
+export class StrykerError extends Error {
+  constructor(
+    message: string,
+    public readonly innerError?: unknown,
+  ) {
+    super(
+      `${message}${innerError ? `. Inner error: ${errorToString(innerError)}` : ''}`,
+    );
+  }
+}

package/src/task.ts

@@ -0,0 +1,71 @@
+/**
+ * Wraps a promise in a Task api for convenience.
+ */
+export class Task<T = void> {
+  protected _promise: Promise<T>;
+  private resolveFn!: (value: PromiseLike<T> | T) => void;
+  private rejectFn!: (reason: any) => void;
+  private _isCompleted = false;
+
+  constructor() {
+    this._promise = new Promise<T>((resolve, reject) => {
+      this.resolveFn = resolve;
+      this.rejectFn = reject;
+    });
+  }
+
+  public get promise(): Promise<T> {
+    return this._promise;
+  }
+
+  public get isCompleted(): boolean {
+    return this._isCompleted;
+  }
+
+  public resolve = (result: PromiseLike<T> | T): void => {
+    this._isCompleted = true;
+    this.resolveFn(result);
+  };
+
+  public reject: (reason: any) => void = (reason: any): void => {
+    this._isCompleted = true;
+    this.rejectFn(reason);
+  };
+}
+
+/**
+ * A task that can expire after the given time.
+ */
+export class ExpirableTask<T = void> extends Task<
+  T | typeof ExpirableTask.TimeoutExpired
+> {
+  public static readonly TimeoutExpired: unique symbol =
+    Symbol('TimeoutExpired');
+
+  constructor(timeoutMS: number) {
+    super();
+    this._promise = ExpirableTask.timeout(this._promise, timeoutMS);
+  }
+
+  public static timeout<K>(
+    promise: Promise<K>,
+    ms: number,
+  ): Promise<K | typeof ExpirableTask.TimeoutExpired> {
+    const sleep = new Promise<K | typeof ExpirableTask.TimeoutExpired>(
+      (res, rej) => {
+        const timer = setTimeout(() => res(ExpirableTask.TimeoutExpired), ms);
+        promise
+          .then((result) => {
+            clearTimeout(timer);
+            res(result);
+          })
+          .catch((error: unknown) => {
+            clearTimeout(timer);
+            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+            rej(error);
+          });
+      },
+    );
+    return sleep;
+  }
+}

package/src/test-files-provided.ts

@@ -0,0 +1,5 @@
+export function testFilesProvided(options: {
+  testFiles?: readonly string[];
+}): boolean {
+  return !!options.testFiles && options.testFiles.length > 0;
+}