@epikodelabs/testify 1.0.16

package/esm-loader.mjs

@@ -0,0 +1,332 @@
+// ESM loader for running TS/JS specs with:
+// - ts-node/esm (TypeScript at runtime)
+// - tsconfig "paths" + "baseUrl" (tsconfig-paths)
+//
+// Works on Windows by converting absolute `C:\...` specifiers to `file://` URLs.
+//
+// Usage example:
+//   node --loader @epikodelabs/testify/esm-loader.mjs ./node_modules/@epikodelabs/testify/bin/jasmine --spec ./path/to/test.spec.ts
+//
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { createMatchPath } from 'tsconfig-paths';
+import { load as loadTs, resolve as resolveTs } from 'ts-node/esm';
+
+const require = createRequire(import.meta.url);
+
+const WINDOWS_ABS_PATH_RE = /^[A-Za-z]:[\\/]/;
+
+function isFileUrl(url) {
+  return typeof url === 'string' && url.startsWith('file:');
+}
+
+function isWindowsAbsPath(specifier) {
+  return typeof specifier === 'string' && WINDOWS_ABS_PATH_RE.test(specifier);
+}
+
+function cleanJsonLike(text) {
+  // Removes // and /* */ comments and trailing commas; good enough for typical tsconfig.json.
+  // This is intentionally lightweight to avoid extra deps in the published package.
+  let out = '';
+  let i = 0;
+  let inString = false;
+  let stringChar = null;
+  let escapeNext = false;
+
+  while (i < text.length) {
+    const ch = text[i];
+    const next = text[i + 1];
+
+    if (escapeNext) {
+      out += ch;
+      escapeNext = false;
+      i += 1;
+      continue;
+    }
+
+    if (inString && ch === '\\') {
+      out += ch;
+      escapeNext = true;
+      i += 1;
+      continue;
+    }
+
+    if ((ch === '"' || ch === "'") && !escapeNext) {
+      if (!inString) {
+        inString = true;
+        stringChar = ch;
+      } else if (ch === stringChar) {
+        inString = false;
+        stringChar = null;
+      }
+      out += ch;
+      i += 1;
+      continue;
+    }
+
+    if (!inString && ch === '/' && next === '/') {
+      i += 2;
+      while (i < text.length && text[i] !== '\n' && text[i] !== '\r') i += 1;
+      continue;
+    }
+
+    if (!inString && ch === '/' && next === '*') {
+      i += 2;
+      while (i < text.length - 1) {
+        if (text[i] === '*' && text[i + 1] === '/') {
+          i += 2;
+          break;
+        }
+        i += 1;
+      }
+      continue;
+    }
+
+    out += ch;
+    i += 1;
+  }
+
+  // Remove trailing commas (outside strings).
+  let out2 = '';
+  i = 0;
+  inString = false;
+  stringChar = null;
+  escapeNext = false;
+
+  while (i < out.length) {
+    const ch = out[i];
+
+    if (escapeNext) {
+      out2 += ch;
+      escapeNext = false;
+      i += 1;
+      continue;
+    }
+
+    if (inString && ch === '\\') {
+      out2 += ch;
+      escapeNext = true;
+      i += 1;
+      continue;
+    }
+
+    if ((ch === '"' || ch === "'") && !escapeNext) {
+      if (!inString) {
+        inString = true;
+        stringChar = ch;
+      } else if (ch === stringChar) {
+        inString = false;
+        stringChar = null;
+      }
+      out2 += ch;
+      i += 1;
+      continue;
+    }
+
+    if (!inString && ch === ',') {
+      let j = i + 1;
+      while (j < out.length && /\s/.test(out[j])) j += 1;
+      if (j < out.length && (out[j] === ']' || out[j] === '}')) {
+        i += 1;
+        continue;
+      }
+    }
+
+    out2 += ch;
+    i += 1;
+  }
+
+  return out2;
+}
+
+function readTsconfig(tsconfigPath, visited = new Set()) {
+  const resolved = path.resolve(tsconfigPath);
+  if (visited.has(resolved)) return {};
+  visited.add(resolved);
+
+  if (!fs.existsSync(resolved)) return {};
+
+  const raw = fs.readFileSync(resolved, 'utf8');
+  const parsed = JSON.parse(cleanJsonLike(raw));
+  const tsconfigDir = path.dirname(resolved);
+
+  let base = {};
+  const ext = parsed.extends;
+  if (typeof ext === 'string' && ext.length > 0) {
+    const tryResolve = (specifier) => {
+      // Relative / absolute
+      if (
+        specifier.startsWith('.') ||
+        specifier.startsWith('/') ||
+        isWindowsAbsPath(specifier)
+      ) {
+        const candidate = path.resolve(tsconfigDir, specifier);
+        if (fs.existsSync(candidate)) return candidate;
+        if (fs.existsSync(candidate + '.json')) return candidate + '.json';
+        return null;
+      }
+
+      // Package-based (e.g. "@tsconfig/node20/tsconfig.json")
+      try {
+        return require.resolve(specifier, { paths: [tsconfigDir] });
+      } catch {
+        try {
+          return require.resolve(specifier + '.json', { paths: [tsconfigDir] });
+        } catch {
+          return null;
+        }
+      }
+    };
+
+    const resolvedExt = tryResolve(ext);
+    if (resolvedExt) {
+      base = readTsconfig(resolvedExt, visited);
+    }
+  }
+
+  const merged = {
+    ...base,
+    ...parsed,
+    compilerOptions: {
+      ...(base.compilerOptions ?? {}),
+      ...(parsed.compilerOptions ?? {}),
+      paths: {
+        ...((base.compilerOptions ?? {}).paths ?? {}),
+        ...((parsed.compilerOptions ?? {}).paths ?? {}),
+      },
+    },
+  };
+
+  // Preserve tsconfig directory (used for baseUrl resolution).
+  merged.__tsconfigDir = tsconfigDir;
+  return merged;
+}
+
+function findUp(startDir, filename) {
+  let current = path.resolve(startDir);
+  while (true) {
+    const candidate = path.join(current, filename);
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function getTsconfigFor(startDir) {
+  const envProject = process.env.TS_NODE_PROJECT;
+  if (envProject) {
+    const fromCwd = path.resolve(process.cwd(), envProject);
+    if (fs.existsSync(fromCwd)) return fromCwd;
+  }
+  return findUp(startDir, 'tsconfig.json') ?? findUp(process.cwd(), 'tsconfig.json');
+}
+
+const matchPathCache = new Map();
+
+function getMatchPath(startDir) {
+  const tsconfigPath = getTsconfigFor(startDir);
+  if (!tsconfigPath) return null;
+
+  const key = tsconfigPath;
+  const cached = matchPathCache.get(key);
+  if (cached) return cached;
+
+  const tsconfig = readTsconfig(tsconfigPath);
+  const compilerOptions = tsconfig.compilerOptions ?? {};
+  const tsconfigDir = tsconfig.__tsconfigDir ?? path.dirname(tsconfigPath);
+
+  const baseUrl = compilerOptions.baseUrl
+    ? path.resolve(tsconfigDir, compilerOptions.baseUrl)
+    : tsconfigDir;
+  const pathsMap = compilerOptions.paths ?? {};
+
+  const matchPath = createMatchPath(baseUrl, pathsMap);
+  matchPathCache.set(key, matchPath);
+  return matchPath;
+}
+
+const EXTENSIONS = [
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+  '.json',
+];
+
+function tryResolveWithExtensions(absPath) {
+  for (const ext of EXTENSIONS) {
+    const candidate = absPath.endsWith(ext) ? absPath : absPath + ext;
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  for (const ext of EXTENSIONS) {
+    const idx = path.join(absPath, 'index' + ext);
+    if (fs.existsSync(idx)) return idx;
+  }
+  return null;
+}
+
+export async function resolve(specifier, context, defaultResolve) {
+  // Windows: absolute paths must be file:// URLs for ESM.
+  if (isWindowsAbsPath(specifier)) {
+    return resolveTs(pathToFileURL(specifier).href, context, defaultResolve);
+  }
+
+  const parentUrl = context?.parentURL;
+  const startDir =
+    isFileUrl(parentUrl) ? path.dirname(fileURLToPath(parentUrl)) : process.cwd();
+
+  // 1) Try tsconfig paths mapping.
+  const matchPath = getMatchPath(startDir);
+  if (matchPath) {
+    const resolved = matchPath(specifier, undefined, undefined, EXTENSIONS);
+    if (resolved) {
+      return resolveTs(pathToFileURL(resolved).href, context, defaultResolve);
+    }
+  }
+
+  // 2) Relative specifiers without extension.
+  if (
+    (specifier.startsWith('./') || specifier.startsWith('../')) &&
+    isFileUrl(parentUrl)
+  ) {
+    const parentFile = fileURLToPath(parentUrl);
+    const candidate = path.resolve(path.dirname(parentFile), specifier);
+    const withExt = tryResolveWithExtensions(candidate);
+    if (withExt) {
+      return resolveTs(pathToFileURL(withExt).href, context, defaultResolve);
+    }
+  }
+
+  // 3) Fallback to ts-node/esm resolver.
+  return resolveTs(specifier, context, defaultResolve);
+}
+
+export async function load(url, context, defaultLoad) {
+  // ts-node's loader returns `format: null` for extensionless files, which breaks running
+  // our (extensionless) bin entry under `--loader` on Windows.
+  if (typeof url === 'string' && url.startsWith('file:')) {
+    const filePath = fileURLToPath(url);
+    const base = path.basename(filePath);
+    const parent = path.basename(path.dirname(filePath));
+
+    if (
+      parent === 'bin' &&
+      (base === 'jasmine') &&
+      path.extname(filePath) === '' &&
+      fs.existsSync(filePath)
+    ) {
+      const raw = fs.readFileSync(filePath, 'utf8');
+      const source = raw.startsWith('#!') ? raw.replace(/^#!.*\r?\n/, '') : raw;
+      return { format: 'module', source, shortCircuit: true };
+    }
+  }
+
+  return loadTs(url, context, defaultLoad);
+}

package/lib/index.js

@@ -0,0 +1,231 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class JasmineConsoleReporter {
+  static {
+    __name(this, "JasmineConsoleReporter");
+  }
+  print = /* @__PURE__ */ __name((message) => process.stdout.write(message), "print");
+  showColors = true;
+  specCount = 0;
+  executableSpecCount = 0;
+  failureCount = 0;
+  failedSpecs = [];
+  pendingSpecs = [];
+  alwaysListPendingSpecs = true;
+  ansi = {
+    green: "\x1B[32m",
+    red: "\x1B[31m",
+    yellow: "\x1B[33m",
+    none: "\x1B[0m"
+  };
+  failedSuites = [];
+  stackFilter = /* @__PURE__ */ __name((stack) => stack, "stackFilter");
+  randomSeedReproductionCmd(seed) {
+    return "jasmine --random=true --seed=" + seed;
+  }
+  /**
+   * Configures the reporter.
+   */
+  setOptions(options) {
+    if (options.print) {
+      this.print = options.print;
+    }
+    this.showColors = options.showColors || false;
+    if (options.stackFilter) {
+      this.stackFilter = options.stackFilter;
+    }
+    if (options.randomSeedReproductionCmd) {
+      this.randomSeedReproductionCmd = options.randomSeedReproductionCmd;
+    }
+    if (options.alwaysListPendingSpecs !== void 0) {
+      this.alwaysListPendingSpecs = options.alwaysListPendingSpecs;
+    }
+  }
+  jasmineStarted(options) {
+    this.specCount = 0;
+    this.executableSpecCount = 0;
+    this.failureCount = 0;
+    if (options?.order?.random) {
+      this.print("Randomized with seed " + options.order.seed);
+      this.printNewline();
+    }
+    this.print("Started");
+    this.printNewline();
+  }
+  jasmineDone(result) {
+    if (result.failedExpectations) {
+      this.failureCount += result.failedExpectations.length;
+    }
+    this.printNewline();
+    this.printNewline();
+    if (this.failedSpecs.length > 0) {
+      this.print("Failures:");
+    }
+    for (let i = 0; i < this.failedSpecs.length; i++) {
+      this.specFailureDetails(this.failedSpecs[i], i + 1);
+    }
+    for (let i = 0; i < this.failedSuites.length; i++) {
+      this.suiteFailureDetails(this.failedSuites[i]);
+    }
+    if (result.failedExpectations?.length > 0) {
+      this.suiteFailureDetails({
+        fullName: "top suite",
+        failedExpectations: result.failedExpectations
+      });
+    }
+    if (this.alwaysListPendingSpecs || result.overallStatus === "passed") {
+      if (this.pendingSpecs.length > 0) {
+        this.print("Pending:");
+      }
+      for (let i = 0; i < this.pendingSpecs.length; i++) {
+        this.pendingSpecDetails(this.pendingSpecs[i], i + 1);
+      }
+    }
+    if (this.specCount > 0) {
+      this.printNewline();
+      if (this.executableSpecCount !== this.specCount) {
+        this.print(
+          "Ran " + this.executableSpecCount + " of " + this.specCount + this.plural(" spec", this.specCount)
+        );
+        this.printNewline();
+      }
+      let specCounts = this.executableSpecCount + " " + this.plural("spec", this.executableSpecCount) + ", " + this.failureCount + " " + this.plural("failure", this.failureCount);
+      if (this.pendingSpecs.length) {
+        specCounts += ", " + this.pendingSpecs.length + " pending " + this.plural("spec", this.pendingSpecs.length);
+      }
+      this.print(specCounts);
+    } else {
+      this.print("No specs found");
+    }
+    this.printNewline();
+    const seconds = result ? result.totalTime / 1e3 : 0;
+    this.print("Finished in " + seconds + " " + this.plural("second", seconds));
+    this.printNewline();
+    if (result && result.overallStatus === "incomplete") {
+      this.print("Incomplete: " + result.incompleteReason);
+      this.printNewline();
+    }
+    if (result.order?.random) {
+      this.print("Randomized with seed " + result.order.seed);
+      this.print(" (" + this.randomSeedReproductionCmd(result.order.seed) + ")");
+      this.printNewline();
+    }
+  }
+  specDone(result) {
+    this.specCount++;
+    if (result.status == "pending") {
+      this.pendingSpecs.push(result);
+      this.executableSpecCount++;
+      this.print(this.colored("yellow", "*"));
+      return;
+    }
+    if (result.status == "passed") {
+      this.executableSpecCount++;
+      this.print(this.colored("green", "."));
+      return;
+    }
+    if (result.status == "failed") {
+      this.failureCount++;
+      this.failedSpecs.push(result);
+      this.executableSpecCount++;
+      this.print(this.colored("red", "F"));
+    }
+  }
+  suiteDone(result) {
+    if (result.failedExpectations && result.failedExpectations.length > 0) {
+      this.failureCount++;
+      this.failedSuites.push(result);
+    }
+  }
+  reporterCapabilities = { parallel: true };
+  printNewline() {
+    this.print("\n");
+  }
+  colored(color, str) {
+    return this.showColors ? this.ansi[color] + str + this.ansi.none : str;
+  }
+  plural(str, count) {
+    return count == 1 ? str : str + "s";
+  }
+  repeat(thing, times) {
+    return Array.from({ length: times }, () => thing);
+  }
+  indent(str, spaces) {
+    const lines = (str || "").split("\n");
+    return lines.map((line) => this.repeat(" ", spaces).join("") + line).join("\n");
+  }
+  specFailureDetails(result, failedSpecNumber) {
+    this.printNewline();
+    this.print(failedSpecNumber + ") ");
+    this.print(result.fullName);
+    this.printFailedExpectations(result);
+    if (result.debugLogs?.length) {
+      this.printNewline();
+      this.print(this.indent("Debug logs:", 2));
+      this.printNewline();
+      for (const entry of result.debugLogs) {
+        this.print(this.indent(`${entry.timestamp}ms: ${entry.message}`, 4));
+        this.printNewline();
+      }
+    }
+  }
+  suiteFailureDetails(result) {
+    this.printNewline();
+    this.print("Suite error: " + result.fullName);
+    this.printFailedExpectations(result);
+  }
+  printFailedExpectations(result) {
+    for (let i = 0; i < result.failedExpectations.length; i++) {
+      const failedExpectation = result.failedExpectations[i];
+      this.printNewline();
+      this.print(this.indent("Message:", 2));
+      this.printNewline();
+      this.print(this.colored("red", this.indent(failedExpectation.message, 4)));
+      this.printNewline();
+      this.print(this.indent("Stack:", 2));
+      this.printNewline();
+      this.print(this.indent(this.stackFilter(failedExpectation.stack), 4));
+    }
+    if (result.failedExpectations.length === 0 && Array.isArray(result.passedExpectations) && result.passedExpectations.length === 0) {
+      this.printNewline();
+      this.print(this.indent("Message:", 2));
+      this.printNewline();
+      this.print(this.colored("red", this.indent("Spec has no expectations", 4)));
+    }
+    this.printNewline();
+  }
+  pendingSpecDetails(result, pendingSpecNumber) {
+    this.printNewline();
+    this.printNewline();
+    this.print(pendingSpecNumber + ") ");
+    this.print(result.fullName);
+    this.printNewline();
+    let pendingReason = "No reason given";
+    if (result.pendingReason && result.pendingReason !== "") {
+      pendingReason = result.pendingReason;
+    }
+    this.print(this.indent(this.colored("yellow", pendingReason), 2));
+    this.printNewline();
+  }
+}
+class AwaitableJasmineConsoleReporter extends JasmineConsoleReporter {
+  static {
+    __name(this, "AwaitableJasmineConsoleReporter");
+  }
+  resolveComplete;
+  complete;
+  constructor() {
+    super();
+    this.complete = new Promise((resolve) => {
+      this.resolveComplete = resolve;
+    });
+  }
+  jasmineDone(result) {
+    super.jasmineDone(result);
+    this.resolveComplete?.(result);
+  }
+}
+export {
+  AwaitableJasmineConsoleReporter,
+  JasmineConsoleReporter
+};

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@epikodelabs/testify",
+  "version": "1.0.16",
+  "description": "Serve and run your Jasmine specs in a browser",
+  "type": "module",
+  "bin": {
+    "jasmine": "bin/jasmine",
+    "testify": "bin/testify"
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "esm-loader.mjs",
+    "package.json",
+    "postinstall.mjs",
+    "assets/",
+    "bin/",
+    "lib/",
+    "node_modules/"
+  ],
+  "scripts": {
+    "postinstall": "node postinstall.mjs"
+  },
+  "keywords": [
+    "Jasmine",
+    "Testing",
+    "TDD",
+    "Browser",
+    "Node",
+    "Coverage",
+    "HMR"
+  ],
+  "author": "Oleksii Shepel",
+  "license": "MIT",
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "chromium-bidi": "^13.1.1",
+    "deasync": "^0.1.31",
+    "esbuild": "^0.25.11",
+    "fdir": "^6.5.0",
+    "glob": "^13.0.1",
+    "istanbul-api": "^3.0.0",
+    "istanbul-lib-coverage": "^3.2.2",
+    "istanbul-lib-instrument": "^6.0.3",
+    "istanbul-lib-report": "^3.0.1",
+    "istanbul-lib-source-maps": "^5.0.6",
+    "istanbul-reports": "^3.2.0",
+    "jasmine-core": "^6.0.1",
+    "module-alias": "^2.3.4",
+    "path-scurry": "^2.0.1",
+    "picomatch": "^4.0.3",
+    "playwright": "^1.58.2",
+    "rollup": "^4.57.1",
+    "tinyglobby": "^0.2.15",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "vite": "^7.3.1",
+    "word-wrap": "^1.2.5",
+    "ws": "^8.19.0"
+  },
+  "bundleDependencies": [
+    "chokidar",
+    "chromium-bidi",
+    "deasync",
+    "esbuild",
+    "fdir",
+    "glob",
+    "istanbul-api",
+    "istanbul-lib-coverage",
+    "istanbul-lib-instrument",
+    "istanbul-lib-report",
+    "istanbul-lib-source-maps",
+    "istanbul-reports",
+    "jasmine-core",
+    "module-alias",
+    "path-scurry",
+    "picomatch",
+    "playwright",
+    "rollup",
+    "tinyglobby",
+    "ts-node",
+    "tsconfig-paths",
+    "vite",
+    "word-wrap",
+    "ws"
+  ],
+  "peerDependencies": {},
+  "overrides": {}
+}