@crvy/rprtr 0.0.3

package/dist/chunk-IEYNAB6M.js

@@ -0,0 +1,263 @@
+// src/report-utils.ts
+function normalizeScreenshotsBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+function attachmentsToImages(attachments, screenshotsBaseUrl = "/screenshots/") {
+  const images = {};
+  const baseUrl = normalizeScreenshotsBaseUrl(screenshotsBaseUrl);
+  for (const attachment of attachments) {
+    if (attachment.contentType !== "image/png") continue;
+    const match = attachment.name.match(/^(.+?)-(actual|expected|diff)(?:\.png)?$/);
+    if (match === null) continue;
+    const baseName = match[1];
+    const role = match[2];
+    if (baseName === null || baseName === void 0 || role === null || role === void 0) continue;
+    images[baseName] ??= { actual: "" };
+    const url = `${baseUrl}${attachment.path}`;
+    const img = images[baseName];
+    if (img !== null && img !== void 0) {
+      if (role === "actual") img.actual = url;
+      else if (role === "expected") img.expect = url;
+      else if (role === "diff") img.diff = url;
+    }
+  }
+  for (const key of Object.keys(images)) {
+    const img = images[key];
+    if (img?.actual !== null && img?.actual !== void 0 && img?.expect !== null && img?.expect !== void 0 && img?.diff === void 0)
+      delete img.expect;
+  }
+  return images;
+}
+function mapStatus(status) {
+  switch (status) {
+    case "passed":
+      return "success";
+    case "failed":
+      return "failed";
+    case "skipped":
+      return "pending";
+    default:
+      return "unknown";
+  }
+}
+
+// src/report-state.ts
+function hasReviewablePassingImages(images) {
+  return Object.values(images).some(
+    (img) => img !== null && img !== void 0 && img.actual !== null && img.actual !== void 0 && img.diff === void 0
+  );
+}
+function preservePreviousPassingImages(test, status, images) {
+  if (status !== "passed" || Object.keys(images).length > 0) {
+    return images;
+  }
+  const previousImages = test.results?.[0]?.images ?? {};
+  return hasReviewablePassingImages(previousImages) ? previousImages : images;
+}
+function countDiffImages(images) {
+  return Object.values(images).filter((img) => img?.diff !== null && img?.diff !== void 0).length;
+}
+function createMutableReportState(screenshotDir = "./screenshots") {
+  return {
+    reportData: {
+      isRunning: false,
+      tests: {},
+      browsers: ["chromium"],
+      isUpdateMode: false,
+      screenshotDir
+    },
+    currentRunIds: /* @__PURE__ */ new Set()
+  };
+}
+function applyTestBeginEvent(state, data) {
+  const { id, title, titlePath, browser, location } = data;
+  state.currentRunIds.add(id);
+  state.reportData.tests[id] ??= {
+    id,
+    titlePath: titlePath ?? [],
+    browser: browser ?? "",
+    title: title ?? "",
+    location,
+    status: "running"
+  };
+  return state.reportData.tests[id];
+}
+function applyTestEndEvent(state, data, options = {}) {
+  const test = state.reportData.tests[data.id];
+  if (test === void 0) {
+    return null;
+  }
+  test.status = mapStatus(data.status);
+  const images = preservePreviousPassingImages(
+    test,
+    data.status,
+    attachmentsToImages(data.attachments, options.screenshotsBaseUrl)
+  );
+  const diffCount = countDiffImages(images);
+  const hasDiffs = diffCount > 0;
+  if (hasDiffs) {
+    test.approved = null;
+  }
+  test.results = [
+    {
+      status: data.status === "passed" ? "success" : "failed",
+      retries: 0,
+      images,
+      error: data.error,
+      duration: data.duration
+    }
+  ];
+  return {
+    test,
+    diffCount
+  };
+}
+function finalizeRunEvent(state) {
+  state.reportData.isRunning = false;
+  state.reportData.tests = Object.fromEntries(
+    Object.entries(state.reportData.tests).filter(([id]) => state.currentRunIds.has(id))
+  );
+  state.currentRunIds.clear();
+  const runTests = Object.values(state.reportData.tests).filter((test) => test !== void 0);
+  return {
+    passed: runTests.filter((test) => test.status === "success").length,
+    failed: runTests.filter((test) => test.status === "failed").length,
+    pending: runTests.filter((test) => test.status === "pending").length
+  };
+}
+
+// src/schemas.ts
+import { z } from "zod";
+var LocationSchema = z.object({
+  file: z.string(),
+  line: z.number()
+});
+var ImagesSchema = z.object({
+  actual: z.string(),
+  expect: z.string().optional(),
+  diff: z.string().optional(),
+  error: z.string().optional()
+});
+var AttachmentSchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  contentType: z.string()
+});
+var TestStatusSchema = z.enum(["unknown", "pending", "running", "failed", "approved", "success", "retrying"]);
+var TestResultSchema = z.object({
+  status: z.enum(["failed", "success"]),
+  retries: z.number(),
+  // eslint-disable-next-line typescript/no-unsafe-type-assertion
+  images: z.record(z.string(), ImagesSchema).optional(),
+  error: z.string().optional(),
+  duration: z.number().optional()
+});
+var TestDataSchema = z.object({
+  id: z.string(),
+  titlePath: z.array(z.string()),
+  browser: z.string(),
+  title: z.string(),
+  skip: z.union([z.boolean(), z.string()]).optional(),
+  retries: z.number().optional(),
+  status: TestStatusSchema.optional(),
+  results: z.array(TestResultSchema).optional(),
+  approved: z.record(z.string(), z.number()).nullable().optional(),
+  attachments: z.array(AttachmentSchema).optional(),
+  location: LocationSchema.optional()
+});
+var CrvyRprtrTestSchema = TestDataSchema.extend({
+  checked: z.boolean()
+});
+var CrvyRprtrSuiteSchema = z.lazy(
+  () => z.object({
+    path: z.array(z.string()),
+    skip: z.boolean(),
+    status: TestStatusSchema.optional(),
+    opened: z.boolean(),
+    checked: z.boolean(),
+    indeterminate: z.boolean(),
+    // eslint-disable-next-line typescript/no-unsafe-type-assertion
+    children: z.record(z.string(), z.union([CrvyRprtrSuiteSchema, CrvyRprtrTestSchema])).optional()
+  })
+);
+var WebSocketMessageSchema = z.object({
+  type: z.enum(["test-begin", "test-end", "run-end", "approve", "sync"]),
+  data: z.unknown()
+});
+var TestBeginDataSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  titlePath: z.array(z.string()),
+  browser: z.string(),
+  location: LocationSchema
+});
+var TestEndDataSchema = z.object({
+  id: z.string(),
+  status: z.enum(["passed", "failed", "skipped"]),
+  attachments: z.array(AttachmentSchema),
+  error: z.string().optional(),
+  duration: z.number().optional()
+});
+var ReportDataSchema = z.object({
+  isRunning: z.boolean(),
+  tests: z.record(z.string(), TestDataSchema),
+  browsers: z.array(z.string()),
+  isUpdateMode: z.boolean(),
+  screenshotDir: z.string()
+});
+var LoadedReportDataSchema = z.object({
+  tests: z.record(z.string(), TestDataSchema).optional(),
+  isUpdateMode: z.boolean().optional()
+});
+var OfflineEventSchema = z.object({
+  type: z.enum(["test-begin", "test-end", "run-end"]),
+  data: z.unknown(),
+  timestamp: z.number(),
+  workerIndex: z.number()
+});
+var OfflineReportSchema = z.object({
+  version: z.number(),
+  generatedAt: z.string(),
+  workers: z.number(),
+  events: z.array(OfflineEventSchema)
+});
+var ApproveRequestBodySchema = z.object({
+  id: z.string(),
+  retry: z.number(),
+  image: z.string()
+});
+var ReportApiResponseSchema = z.object({
+  tests: z.record(z.string(), TestDataSchema),
+  isUpdateMode: z.boolean().optional()
+});
+var ClientBootstrapDataSchema = z.object({
+  report: ReportApiResponseSchema.extend({
+    isUpdateMode: z.boolean()
+  }),
+  liveUpdates: z.boolean(),
+  approvalEnabled: z.boolean(),
+  approvalMessage: z.string().optional()
+});
+var ImagesViewModeSchema = z.enum(["side-by-side", "swap", "slide", "blend"]);
+function safeParse(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return result.data;
+  }
+  return null;
+}
+
+export {
+  createMutableReportState,
+  applyTestBeginEvent,
+  applyTestEndEvent,
+  finalizeRunEvent,
+  WebSocketMessageSchema,
+  TestBeginDataSchema,
+  TestEndDataSchema,
+  LoadedReportDataSchema,
+  OfflineReportSchema,
+  ApproveRequestBodySchema,
+  ClientBootstrapDataSchema,
+  safeParse
+};

package/dist/cli.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { type ServerOptions } from './server.ts';
+interface ResolvedCliOptions extends ServerOptions {
+    port: number;
+    screenshotDir: string;
+    reportPath: string;
+}
+export declare function resolveCliOptions(args: string[]): ResolvedCliOptions;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAKA,OAAO,EAAe,KAAK,aAAa,EAAE,MAAM,aAAa,CAAA;AAM7D,UAAU,kBAAmB,SAAQ,aAAa;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,kBAAkB,CA0BpE"}

package/dist/cli.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import {
+  startServer
+} from "./chunk-BRFA7JCQ.js";
+import "./chunk-IEYNAB6M.js";
+
+// src/cli.ts
+import { join } from "path";
+import { parseArgs } from "util";
+
+// src/is-direct-execution.ts
+import { realpathSync } from "fs";
+import { resolve } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+function resolveRealPath(pathValue) {
+  try {
+    return realpathSync.native(pathValue);
+  } catch {
+    return resolve(pathValue);
+  }
+}
+function isDirectExecution(moduleUrl) {
+  const entryPath = process.argv[1];
+  if (entryPath === void 0) {
+    return false;
+  }
+  return pathToFileURL(resolveRealPath(resolve(entryPath))).href === pathToFileURL(resolveRealPath(fileURLToPath(moduleUrl))).href;
+}
+
+// src/cli.ts
+var DEFAULT_PORT = 3e3;
+var DEFAULT_SCREENSHOT_DIR = "./screenshots";
+var DEFAULT_REPORT_PATH = "./report.json";
+function resolveCliOptions(args) {
+  const { values, positionals } = parseArgs({
+    args,
+    allowPositionals: true,
+    options: {
+      port: { type: "string", short: "p", default: `${DEFAULT_PORT}` },
+      "screenshot-dir": { type: "string", short: "s" },
+      "report-path": { type: "string", short: "r" }
+    }
+  });
+  if (positionals.length > 1) {
+    throw new TypeError(`Expected at most one artifact directory, received ${positionals.length}`);
+  }
+  const artifactDir = positionals[0];
+  const reportPath = values["report-path"] ?? (artifactDir === void 0 ? DEFAULT_REPORT_PATH : join(artifactDir, "report.json"));
+  const screenshotDir = values["screenshot-dir"] ?? (artifactDir === void 0 ? DEFAULT_SCREENSHOT_DIR : join(artifactDir, "screenshots"));
+  return {
+    port: parseInt(values.port ?? `${DEFAULT_PORT}`, 10),
+    screenshotDir,
+    reportPath
+  };
+}
+if (isDirectExecution(import.meta.url)) {
+  await startServer(resolveCliOptions(process.argv.slice(2)));
+}
+export {
+  resolveCliOptions
+};