@rettangoli/vt 0.0.14 → 1.0.0-rc12

package/src/report/report-model.js

@@ -0,0 +1,76 @@
+import path from "path";
+
+export function extractParts(filePath) {
+  const dir = path.dirname(filePath);
+  const filename = path.basename(filePath, ".webp");
+  const lastHyphenIndex = filename.lastIndexOf("-");
+
+  if (lastHyphenIndex > -1) {
+    const suffix = filename.substring(lastHyphenIndex + 1);
+    if (/^\d+$/.test(suffix)) {
+      const number = parseInt(suffix, 10);
+      const name = path.join(dir, filename.substring(0, lastHyphenIndex));
+      return { name, number };
+    }
+  }
+
+  return { name: path.join(dir, filename), number: -1 };
+}
+
+export function sortPaths(a, b) {
+  const partsA = extractParts(a);
+  const partsB = extractParts(b);
+
+  if (partsA.name < partsB.name) return -1;
+  if (partsA.name > partsB.name) return 1;
+
+  return partsA.number - partsB.number;
+}
+
+export function buildAllRelativePaths(candidateRelativePaths, referenceRelativePaths) {
+  const allPaths = [
+    ...new Set([...candidateRelativePaths, ...referenceRelativePaths]),
+  ];
+  allPaths.sort(sortPaths);
+  return allPaths;
+}
+
+export function toMismatchingItems(results, siteOutputPath) {
+  return results
+    .filter(
+      (result) =>
+        !result.equal || result.onlyInCandidate || result.onlyInReference,
+    )
+    .map((result) => {
+      return {
+        candidatePath: result.candidatePath
+          ? path.relative(siteOutputPath, result.candidatePath)
+          : null,
+        referencePath: result.referencePath
+          ? path.relative(siteOutputPath, result.referencePath)
+          : null,
+        equal: result.equal,
+        similarity: result.similarity,
+        diffPixels: result.diffPixels,
+        onlyInCandidate: result.onlyInCandidate,
+        onlyInReference: result.onlyInReference,
+      };
+    });
+}
+
+export function buildJsonReport({ total, mismatchingItems, timestamp = new Date().toISOString() }) {
+  return {
+    timestamp,
+    total,
+    mismatched: mismatchingItems.length,
+    items: mismatchingItems.map((item) => ({
+      path: item.candidatePath || item.referencePath,
+      candidatePath: item.candidatePath,
+      referencePath: item.referencePath,
+      equal: item.equal,
+      similarity: item.similarity,
+      onlyInCandidate: item.onlyInCandidate,
+      onlyInReference: item.onlyInReference,
+    })),
+  };
+}

package/src/report/report-render.js

@@ -0,0 +1,22 @@
+import fs from "fs";
+import { Liquid } from "liquidjs";
+
+const engine = new Liquid();
+
+engine.registerFilter("slug", (value) => {
+  if (typeof value !== "string") return "";
+  return value.toLowerCase().replace(/\s+/g, "-");
+});
+
+export async function renderHtmlReport({ results, templatePath, outputPath }) {
+  try {
+    const templateContent = fs.readFileSync(templatePath, "utf8");
+    const renderedHtml = await engine.parseAndRender(templateContent, {
+      files: results,
+    });
+    fs.writeFileSync(outputPath, renderedHtml);
+    console.log(`Report generated successfully at ${outputPath}`);
+  } catch (error) {
+    throw new Error(`Failed to generate HTML report: ${error.message}`, { cause: error });
+  }
+}

package/src/section-page-key.js

@@ -0,0 +1,14 @@
+function normalizeString(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim();
+}
+
+export function deriveSectionPageKey(sectionLike) {
+  return normalizeString(sectionLike?.title)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}

package/src/selector-filter.js

@@ -0,0 +1,140 @@
+import path from "path";
+import { stripViewportSuffix } from "./viewport.js";
+import { deriveSectionPageKey } from "./section-page-key.js";
+
+function toList(value) {
+  if (value === undefined || value === null) return [];
+  if (Array.isArray(value)) return value;
+  return [value];
+}
+
+function normalizePathValue(value) {
+  return String(value)
+    .trim()
+    .replace(/\\/g, "/")
+    .replace(/^\.?\//, "")
+    .replace(/\/+$/, "");
+}
+
+function normalizeItemKey(value) {
+  const normalized = normalizePathValue(value);
+  return normalized.replace(/\.(html?|ya?ml|md)$/i, "");
+}
+
+export function normalizeSelectors(raw = {}) {
+  const folders = toList(raw.folder)
+    .map(normalizePathValue)
+    .filter((item) => item.length > 0);
+  const groups = toList(raw.group)
+    .map((item) => deriveSectionPageKey({ title: String(item) }))
+    .filter((item) => item.length > 0);
+  const items = toList(raw.item)
+    .map(normalizeItemKey)
+    .filter((item) => item.length > 0);
+
+  return {
+    folders: [...new Set(folders)],
+    groups: [...new Set(groups)],
+    items: [...new Set(items)],
+  };
+}
+
+export function hasSelectors(selectors) {
+  return (
+    selectors.folders.length > 0
+    || selectors.groups.length > 0
+    || selectors.items.length > 0
+  );
+}
+
+function matchesFolderPrefix(filePath, folderPrefix) {
+  return filePath === folderPrefix || filePath.startsWith(`${folderPrefix}/`);
+}
+
+function resolveGroupFolders(configSections = [], groupSelectors = []) {
+  if (groupSelectors.length === 0) {
+    return [];
+  }
+
+  const groupFolderMap = new Map();
+  for (const section of configSections) {
+    if (section.type === "groupLabel" && Array.isArray(section.items)) {
+      for (const item of section.items) {
+        groupFolderMap.set(deriveSectionPageKey(item), normalizePathValue(item.files));
+      }
+      continue;
+    }
+    if (section.files) {
+      groupFolderMap.set(deriveSectionPageKey(section), normalizePathValue(section.files));
+    }
+  }
+
+  const missing = [];
+  const folders = [];
+  for (const selector of groupSelectors) {
+    const folder = groupFolderMap.get(selector);
+    if (!folder) {
+      missing.push(selector);
+      continue;
+    }
+    folders.push(folder);
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `Unknown group selector(s): ${missing.join(", ")}.`,
+    );
+  }
+  return [...new Set(folders)];
+}
+
+function toGeneratedFileItemKey(filePath) {
+  const normalized = normalizePathValue(filePath);
+  const ext = path.extname(normalized);
+  return normalized.slice(0, normalized.length - ext.length);
+}
+
+export function filterGeneratedFilesBySelectors(generatedFiles, selectors, configSections = []) {
+  if (!hasSelectors(selectors)) {
+    return generatedFiles;
+  }
+
+  const folderSelectors = [
+    ...selectors.folders,
+    ...resolveGroupFolders(configSections, selectors.groups),
+  ];
+
+  return generatedFiles.filter((file) => {
+    const normalizedPath = normalizePathValue(file.path);
+    const itemKey = toGeneratedFileItemKey(normalizedPath);
+
+    if (selectors.items.includes(itemKey)) {
+      return true;
+    }
+    return folderSelectors.some((folder) => matchesFolderPrefix(normalizedPath, folder));
+  });
+}
+
+function toScreenshotItemKey(relativeScreenshotPath) {
+  const normalized = normalizePathValue(relativeScreenshotPath).replace(/\.webp$/i, "");
+  const withoutOrdinal = normalized.replace(/-\d{1,3}$/i, "");
+  return stripViewportSuffix(withoutOrdinal);
+}
+
+export function filterRelativeScreenshotPathsBySelectors(relativePaths, selectors, configSections = []) {
+  if (!hasSelectors(selectors)) {
+    return relativePaths;
+  }
+
+  const folderSelectors = [
+    ...selectors.folders,
+    ...resolveGroupFolders(configSections, selectors.groups),
+  ];
+
+  return relativePaths.filter((relativePath) => {
+    const itemKey = toScreenshotItemKey(relativePath);
+    if (selectors.items.includes(itemKey)) {
+      return true;
+    }
+    return folderSelectors.some((folder) => matchesFolderPrefix(itemKey, folder));
+  });
+}

package/src/step-commands.js

@@ -0,0 +1,37 @@
+export const STEP_COMMANDS = Object.freeze([
+  "blur",
+  "check",
+  "clear",
+  "click",
+  "customEvent",
+  "dblclick",
+  "focus",
+  "goto",
+  "hover",
+  "keypress",
+  "mouseDown",
+  "mouseUp",
+  "move",
+  "rclick",
+  "rightMouseDown",
+  "rightMouseUp",
+  "setViewport",
+  "screenshot",
+  "scroll",
+  "select",
+  "selectOption",
+  "uncheck",
+  "upload",
+  "wait",
+  "waitFor",
+  "write",
+]);
+
+export const STRUCTURED_STEP_KEYS = Object.freeze([
+  "action",
+  "assert",
+]);
+
+export const BLOCK_COMMANDS = Object.freeze([
+  "select",
+]);