@coder/pixel-storybook 0.1.0 → 0.1.3-canary.20260616.2a423fe

package/README.md

@@ -13,7 +13,3 @@ npm install @coder/pixel-storybook
 ```sh
 npx pixel-storybook
 ```
-
-## License
-
-[MIT](LICENSE)

package/{dist → build}/api.d.ts

@@ -1,6 +1,6 @@
-import type { PlatformModeConfig } from './config.js';
-import { type LogMemory, log } from './log.js';
-import type { StabilizationResult } from './types.js';
+import type { PlatformModeConfig } from "./config.js";
+import { type LogMemory, log } from "./log.js";
+import type { StabilizationResult } from "./types.js";
 export type ShotConfig = {
     name: string;
     threshold?: number;

package/{dist → build}/api.js

@@ -1,52 +1,52 @@
-import { readFile } from 'node:fs/promises';
-import { retry } from './concurrency.js';
-import { log, logMemory } from './log.js';
-import { getVersion } from './utils.js';
+import { readFile } from "node:fs/promises";
+import { retry } from "./concurrency.js";
+import { log, logMemory } from "./log.js";
+import { getVersion } from "./utils.js";
 const version = getVersion();
 const defaultHeaders = {
-    'x-api-version': '3',
-    'x-client-version': version ?? 'unknown',
+    "x-api-version": "3",
+    "x-client-version": version ?? "unknown",
 };
 const apiRoutes = {
-    getApiToken: '/auth/get-api-token',
-    init: '/app/init',
-    finalize: '/app/finalize',
-    prepareUpload: '/file/prepare-upload',
-    uploadShot: '/file/upload-shot',
-    processShots: '/app/process-shots',
-    recordLogs: '/app/record-logs',
-    uploadStorybookBuild: '/app/upload-storybook',
+    getApiToken: "/auth/get-api-token",
+    init: "/app/init",
+    finalize: "/app/finalize",
+    prepareUpload: "/file/prepare-upload",
+    uploadShot: "/file/upload-shot",
+    processShots: "/app/process-shots",
+    recordLogs: "/app/record-logs",
+    uploadStorybookBuild: "/app/upload-storybook",
 };
 class ApiError extends Error {
     status;
     responseData;
     constructor(message, status, responseData) {
         super(message);
-        this.name = 'ApiError';
+        this.name = "ApiError";
         this.status = status;
         this.responseData = responseData;
     }
 }
 const sendToAPI = async (config, parameters, fileKey, customLogger) => {
     const logger = customLogger?.process ?? log.process;
-    logger('info', 'api', `⚡️ Sending to API [${parameters.action}]`);
-    logger('info', 'api', `Endpoint: ${config.lostPixelPlatform}${apiRoutes[parameters.action]}`);
+    logger("info", "api", `⚡️ Sending to API [${parameters.action}]`);
+    logger("info", "api", `Endpoint: ${config.lostPixelPlatform}${apiRoutes[parameters.action]}`);
     try {
         const apiCall = async () => {
             const url = `${config.lostPixelPlatform}${apiRoutes[parameters.action]}`;
             let body;
             const headers = {
                 ...defaultHeaders,
-                Authorization: `Bearer ${parameters.apiToken ?? ''}`,
-                'x-api-key': config.apiKey ?? 'undefined',
+                "Authorization": `Bearer ${parameters.apiToken ?? ""}`,
+                "x-api-key": config.apiKey ?? "undefined",
             };
             if (fileKey) {
                 const form = new FormData();
                 for (const [key, element] of Object.entries(parameters.payload)) {
                     if (key === fileKey) {
                         const fileBuffer = await readFile(element);
-                        const blob = new Blob([fileBuffer], { type: 'image/png' });
-                        form.append(key, blob, element.split('/').pop());
+                        const blob = new Blob([fileBuffer], { type: "image/png" });
+                        form.append(key, blob, element.split("/").pop());
                     }
                     else {
                         form.append(key, element);
@@ -57,10 +57,10 @@ const sendToAPI = async (config, parameters, fileKey, customLogger) => {
             }
             else {
                 body = JSON.stringify(parameters.payload);
-                headers['Content-type'] = 'application/json';
+                headers["Content-type"] = "application/json";
             }
             const response = await fetch(url, {
-                method: 'POST',
+                method: "POST",
                 headers,
                 body,
             });
@@ -80,8 +80,8 @@ const sendToAPI = async (config, parameters, fileKey, customLogger) => {
             times: 3,
             interval(retryCount) {
                 const delay = Math.round(2 ** retryCount * 3000 * Math.random());
-                logger('info', 'api', `🔄 Retry attempt ${retryCount} in ${delay}ms [${parameters.action}]`);
-                logger('info', 'api', `${config.lostPixelPlatform}${apiRoutes[parameters.action]}`);
+                logger("info", "api", `🔄 Retry attempt ${retryCount} in ${delay}ms [${parameters.action}]`);
+                logger("info", "api", `${config.lostPixelPlatform}${apiRoutes[parameters.action]}`);
                 return delay;
             },
             errorFilter(error) {
@@ -93,33 +93,33 @@ const sendToAPI = async (config, parameters, fileKey, customLogger) => {
             },
         }, apiCall);
         if (!response.ok) {
-            logger('error', 'api', `Error: Failed to send to API [${parameters.action}]. Status: ${response.status}`);
+            logger("error", "api", `Error: Failed to send to API [${parameters.action}]. Status: ${response.status}`);
             process.exit(1);
         }
-        const outdatedApiRequest = response?.headers?.['x-api-version-warning'];
+        const outdatedApiRequest = response?.headers?.["x-api-version-warning"];
         if (outdatedApiRequest &&
-            (parameters.action === 'prepareUpload' ||
-                parameters.action === 'finalize')) {
-            logger('info', 'api', [
-                '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~',
+            (parameters.action === "prepareUpload" ||
+                parameters.action === "finalize")) {
+            logger("info", "api", [
+                "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
                 `~~ ⚠️  ${outdatedApiRequest}`,
-                '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~',
-            ].join('\n'));
+                "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~",
+            ].join("\n"));
         }
-        logger('info', 'api', `🤘 Successfully sent to API [${parameters.action}]`);
+        logger("info", "api", `🤘 Successfully sent to API [${parameters.action}]`);
         return response.data;
     }
     catch (error) {
         if (error instanceof ApiError) {
-            logger('error', 'api', 'API response: ', error.responseData || error.message);
+            logger("error", "api", "API response: ", error.responseData || error.message);
         }
         else if (error instanceof Error) {
-            logger('error', 'api', error.message);
+            logger("error", "api", error.message);
         }
         else {
-            logger('error', 'api', error);
+            logger("error", "api", error);
         }
-        if (parameters.action === 'getApiToken') {
+        if (parameters.action === "getApiToken") {
             process.exit(1);
         }
         throw error;
@@ -127,7 +127,7 @@ const sendToAPI = async (config, parameters, fileKey, customLogger) => {
 };
 export const getApiToken = async (config) => {
     return sendToAPI(config, {
-        action: 'getApiToken',
+        action: "getApiToken",
         payload: {
             projectId: config.lostPixelProjectId,
         },
@@ -135,7 +135,7 @@ export const getApiToken = async (config) => {
 };
 export const sendInitToAPI = async (config, apiToken) => {
     return sendToAPI(config, {
-        action: 'init',
+        action: "init",
         apiToken,
         payload: {
             commit: config.commitHash,
@@ -146,7 +146,7 @@ export const sendInitToAPI = async (config, apiToken) => {
 };
 export const sendFinalizeToAPI = async (config, apiToken) => {
     return sendToAPI(config, {
-        action: 'finalize',
+        action: "finalize",
         apiToken,
         payload: {
             projectId: config.lostPixelProjectId,
@@ -158,7 +158,7 @@ export const sendFinalizeToAPI = async (config, apiToken) => {
 };
 export const prepareUpload = async (config, apiToken, shotNamesWithHashes) => {
     return sendToAPI(config, {
-        action: 'prepareUpload',
+        action: "prepareUpload",
         apiToken,
         payload: {
             branchName: config.commitRefName,
@@ -173,18 +173,18 @@ export const uploadShot = async ({ config, apiToken, uploadToken, uploadUrl, nam
         ...config,
         lostPixelPlatform: uploadUrl,
     }, {
-        action: 'uploadShot',
+        action: "uploadShot",
         apiToken,
         payload: {
             uploadToken,
             name,
             file,
         },
-    }, 'file', logger);
+    }, "file", logger);
 };
 export const processShots = async (config, apiToken, uploadToken, shotsConfig) => {
     return sendToAPI(config, {
-        action: 'processShots',
+        action: "processShots",
         apiToken,
         payload: {
             uploadToken,
@@ -198,7 +198,7 @@ export const processShots = async (config, apiToken, uploadToken, shotsConfig) =
 };
 export const uploadStorybookBuild = async (config, apiToken, filePath) => {
     return sendToAPI(config, {
-        action: 'uploadStorybookBuild',
+        action: "uploadStorybookBuild",
         apiToken,
         payload: {
             projectId: config.lostPixelProjectId,
@@ -208,12 +208,12 @@ export const uploadStorybookBuild = async (config, apiToken, filePath) => {
             commit: config.commitHash,
             file: filePath,
         },
-    }, 'file');
+    }, "file");
 };
 export const sendRecordLogsToAPI = async (config, apiToken) => {
     try {
         await sendToAPI(config, {
-            action: 'recordLogs',
+            action: "recordLogs",
             apiToken,
             payload: {
                 branchName: config.commitRefName,
@@ -225,14 +225,15 @@ export const sendRecordLogsToAPI = async (config, apiToken) => {
     }
     catch (error) {
         if (error instanceof ApiError) {
-            log.process('error', 'api', 'API response: ', error.responseData || error.message);
+            log.process("error", "api", "API response: ", error.responseData || error.message);
         }
         else if (error instanceof Error) {
-            log.process('error', 'api', error.message);
+            log.process("error", "api", error.message);
         }
         else {
-            log.process('error', 'api', error);
+            log.process("error", "api", error);
         }
-        log.process('error', 'api', 'Error: Failed to send logs to API');
+        log.process("error", "api", "Error: Failed to send logs to API");
     }
 };
+//# sourceMappingURL=api.js.map

package/build/bin.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from "node:fs";
+import { cp } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { sendFinalizeToAPI } from "./api.js";
+import { config, configure, isPlatformModeConfig } from "./config.js";
+import { log } from "./log.js";
+import { getPlatformApiToken, platformRunner, runner } from "./runner.js";
+import { uploadStorybook } from "./uploadStorybook.js";
+import { getVersion, isLocalDebugMode } from "./utils.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const { positionals: commandArgs, values: optionValues } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+        help: { type: "boolean", short: "h" },
+        version: { type: "boolean", short: "v" },
+    },
+    allowPositionals: true,
+    strict: false,
+});
+const version = getVersion();
+if (optionValues.version) {
+    log.process("info", "general", version ?? "unknown");
+    process.exit(0);
+}
+if (optionValues.help) {
+    printHelp();
+    process.exit(0);
+}
+if (version) {
+    log.process("info", "general", `Version: ${version}`);
+}
+function printHelp() {
+    log.process("info", "general", [
+        "Usage: pixel-storybook [command] [options]",
+        "",
+        "Visual regression testing tool for Storybook. Captures screenshots",
+        "via Playwright and compares them against baselines.",
+        "",
+        "Commands:",
+        "  init-js             Create a lostpixel.config.js in the current directory",
+        "  init-ts             Create a lostpixel.config.ts in the current directory",
+        "  update              Update baseline images with the current shots",
+        "  local               Enable local debug mode",
+        "  meta                Generate metadata for each shot",
+        "  finalize            Finalize a platform run (platform mode)",
+        "  upload-storybook    Upload a Storybook build to the platform",
+        "",
+        "Options:",
+        "  -h, --help          Print this help message and exit",
+        "  -v, --version       Print the version and exit",
+        "  -m <mode>           Set the mode (e.g. update)",
+        "  --shard <n/total>   Run a specific shard of the suite (e.g. 2/4)",
+        "",
+        "Environment variables:",
+        "  LOST_PIXEL_MODE             Same as -m",
+        '  LOST_PIXEL_LOCAL            Set to "true" for local debug mode',
+        '  LOST_PIXEL_GENERATE_META    Set to "true" to generate metadata',
+        "  LOST_PIXEL_SHARD            Same as --shard",
+    ].join("\n"));
+}
+(async () => {
+    if (commandArgs.includes("init-js")) {
+        log.process("info", "general", "Initializing javascript lost-pixel config");
+        await cp(path.join(__dirname, "..", "config-templates", "example.lostpixel.config.js"), path.join(process.cwd(), "./lostpixel.config.js"));
+        log.process("info", "general", "✅ Config successfully initialized");
+    }
+    else if (commandArgs.includes("init-ts")) {
+        log.process("info", "general", "Initializing typescript lost-pixel config");
+        // Replace local type resolution with module resolution
+        const file = readFileSync(path.join(__dirname, "..", "config-templates", "example.lostpixel.config.ts"));
+        const modifiedFile = file.toString().replace("../src/config", "lost-pixel");
+        writeFileSync(path.join(process.cwd(), "./lostpixel.config.ts"), modifiedFile);
+        log.process("info", "general", "✅ Config successfully initialized");
+    }
+    else {
+        await configure({
+            localDebugMode: isLocalDebugMode(),
+        });
+        if (isPlatformModeConfig(config)) {
+            log.process("info", "general", `🚀 Starting Pixel Storybook in 'platform' mode`);
+            const apiToken = await getPlatformApiToken(config);
+            if (commandArgs.includes("finalize")) {
+                await sendFinalizeToAPI(config, apiToken);
+            }
+            else if (commandArgs.includes("upload-storybook")) {
+                log.process("info", "general", "📤 Starting Pixel storybook build upload");
+                await uploadStorybook(config, apiToken);
+            }
+            else {
+                await platformRunner(config, apiToken);
+            }
+        }
+        else {
+            log.process("info", "general", `🚀 Starting Pixel Storybook in 'generateOnly' mode`);
+            await runner(config);
+        }
+    }
+})();
+//# sourceMappingURL=bin.js.map

package/{dist → build}/checkDifferences.d.ts

@@ -1,10 +1,10 @@
-import type { ShotItem } from './types.js';
+import type { ShotItem } from "./types.js";
 export declare const checkDifferences: (shotItems: ShotItem[]) => Promise<{
     aboveThresholdDifferenceItems: {
+        url: string;
         shotMode: "storybook";
         id: string;
         shotName: string;
-        url: string;
         filePathBaseline: string;
         filePathCurrent: string;
         filePathDifference: string;
@@ -31,10 +31,10 @@ export declare const checkDifferences: (shotItems: ShotItem[]) => Promise<{
         waitForSelector?: string | undefined;
     }[];
     noBaselinesItems: {
+        url: string;
         shotMode: "storybook";
         id: string;
         shotName: string;
-        url: string;
         filePathBaseline: string;
         filePathCurrent: string;
         filePathDifference: string;

package/{dist → build}/checkDifferences.js

@@ -1,15 +1,15 @@
-import { existsSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { compareImages } from './compare/compare.js';
-import { mapLimit } from './concurrency.js';
-import { config, isPlatformModeConfig } from './config.js';
-import { log } from './log.js';
-import { featureNotSupported, shallGenerateMeta } from './utils.js';
+import { existsSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { compareImages } from "./compare/compare.js";
+import { mapLimit } from "./concurrency.js";
+import { config, isPlatformModeConfig } from "./config.js";
+import { log } from "./log.js";
+import { featureNotSupported, shallGenerateMeta } from "./utils.js";
 export const checkDifferences = async (shotItems) => {
     if (isPlatformModeConfig(config)) {
-        return featureNotSupported('checkDifferences()');
+        return featureNotSupported("checkDifferences()");
     }
-    log.process('info', 'general', `Comparing ${shotItems.length} screenshots using '${config.compareEngine}' as compare engine`);
+    log.process("info", "general", `Comparing ${shotItems.length} screenshots using '${config.compareEngine}' as compare engine`);
     const total = shotItems.length;
     const noBaselinesItems = [];
     const aboveThresholdDifferenceItems = [];
@@ -23,12 +23,12 @@ export const checkDifferences = async (shotItems) => {
                 itemIndex: index,
                 totalItems: total,
             })
-                .process('info', 'general', message);
+                .process("info", "general", message);
         };
         logger(`Comparing '${shotItem.id}'`);
         const baselineImageExists = existsSync(shotItem.filePathBaseline);
         if (!baselineImageExists) {
-            logger('Baseline image missing. Will be treated as addition.');
+            logger("Baseline image missing. Will be treated as addition.");
             noBaselinesItems.push(shotItem);
             return;
         }
@@ -55,13 +55,14 @@ export const checkDifferences = async (shotItems) => {
             }
         }
         else {
-            logger('No difference found.');
+            logger("No difference found.");
         }
     });
     if (shallGenerateMeta()) {
-        log.process('info', 'general', `Writing meta file with ${Object.entries(comparisonResults).length} items.`);
-        writeFileSync(`${path.join(config.imagePathCurrent, 'meta')}.json`, JSON.stringify(comparisonResults, null, 2));
+        log.process("info", "general", `Writing meta file with ${Object.entries(comparisonResults).length} items.`);
+        writeFileSync(`${path.join(config.imagePathCurrent, "meta")}.json`, JSON.stringify(comparisonResults, null, 2));
     }
-    log.process('info', 'general', 'Comparison done!');
+    log.process("info", "general", "Comparison done!");
     return { aboveThresholdDifferenceItems, noBaselinesItems };
 };
+//# sourceMappingURL=checkDifferences.js.map

package/{dist → build}/compare/compare.d.ts

@@ -1,5 +1,5 @@
-import { type CompareResult } from './pixelmatch.js';
-export { checkThreshold } from './pixelmatch.js';
+import { type CompareResult } from "./pixelmatch.js";
+export { checkThreshold } from "./pixelmatch.js";
 export declare const compareImagesViaPixelmatch: (threshold: number, baselineShotPath: string, currentShotPath: string, differenceShotPath?: string) => Promise<CompareResult>;
 export declare const compareImagesViaOdiff: (threshold: number, baselineShotPath: string, currentShotPath: string, differenceShotPath: string) => Promise<CompareResult>;
 export declare const compareImages: (threshold: number, baselineShotPath: string, currentShotPath: string, differenceShotPath: string) => Promise<CompareResult>;

package/{dist → build}/compare/compare.js

@@ -1,18 +1,18 @@
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { Worker } from 'node:worker_threads';
-import { compare as odiffCompare } from 'odiff-bin';
-import { config, isPlatformModeConfig } from '../config.js';
-import { featureNotSupported } from '../utils.js';
-import { runPixelmatchComparison } from './pixelmatch.js';
-export { checkThreshold } from './pixelmatch.js';
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+import { compare as odiffCompare } from "odiff-bin";
+import { config, isPlatformModeConfig } from "../config.js";
+import { featureNotSupported } from "../utils.js";
+import { runPixelmatchComparison } from "./pixelmatch.js";
+export { checkThreshold } from "./pixelmatch.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // Resolve the compiled worker script. Available after `pnpm build`.
 // When running from source (e.g. vitest), the .js file won't exist
 // and we fall back to inline comparison on the main thread.
-const workerScript = path.join(__dirname, 'worker.js');
+const workerScript = path.join(__dirname, "worker.js");
 const canUseWorker = existsSync(workerScript);
 const comparePixelmatchWorker = (threshold, baselineShotPath, currentShotPath, differenceShotPath) => {
     return new Promise((resolve, reject) => {
@@ -24,9 +24,9 @@ const comparePixelmatchWorker = (threshold, baselineShotPath, currentShotPath, d
                 differenceShotPath,
             },
         });
-        worker.on('message', resolve);
-        worker.on('error', reject);
-        worker.on('exit', (code) => {
+        worker.on("message", resolve);
+        worker.on("error", reject);
+        worker.on("exit", (code) => {
             if (code !== 0) {
                 reject(new Error(`Pixelmatch worker exited with code ${code}`));
             }
@@ -50,7 +50,7 @@ export const compareImagesViaOdiff = async (threshold, baselineShotPath, current
             isWithinThreshold: true,
         };
     }
-    if (result.reason === 'pixel-diff') {
+    if (result.reason === "pixel-diff") {
         let isWithinThreshold = true;
         // Treat theshold as percentage
         const pixelDifferencePercentage = Number(result.diffPercentage / 100);
@@ -71,10 +71,11 @@ export const compareImagesViaOdiff = async (threshold, baselineShotPath, current
 };
 export const compareImages = async (threshold, baselineShotPath, currentShotPath, differenceShotPath) => {
     if (isPlatformModeConfig(config)) {
-        return featureNotSupported('compareImages()');
+        return featureNotSupported("compareImages()");
     }
-    if (config.compareEngine === 'pixelmatch') {
+    if (config.compareEngine === "pixelmatch") {
         return compareImagesViaPixelmatch(threshold, baselineShotPath, currentShotPath, differenceShotPath);
     }
     return compareImagesViaOdiff(threshold, baselineShotPath, currentShotPath, differenceShotPath);
 };
+//# sourceMappingURL=compare.js.map

package/{dist → build}/compare/pixelmatch.js

@@ -1,7 +1,7 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import pixelmatch from 'pixelmatch';
-import { PNG } from 'pngjs';
-import { resizeImage } from './utils.js';
+import { readFileSync, writeFileSync } from "node:fs";
+import pixelmatch from "pixelmatch";
+import { PNG } from "pngjs";
+import { resizeImage } from "./utils.js";
 export const checkThreshold = (threshold, pixelsTotal, pixelDifference) => {
     // Treat theshold as percentage
     if (threshold < 1) {
@@ -14,13 +14,18 @@ export const runPixelmatchComparison = (threshold, baselineShotPath, currentShot
     const baselineImageBuffer = readFileSync(baselineShotPath);
     const currentImageBuffer = readFileSync(currentShotPath);
     if (baselineImageBuffer.equals(currentImageBuffer)) {
-        return { pixelDifference: 0, pixelDifferencePercentage: 0, isWithinThreshold: true };
+        return {
+            pixelDifference: 0,
+            pixelDifferencePercentage: 0,
+            isWithinThreshold: true,
+        };
     }
     let baselineImage = PNG.sync.read(baselineImageBuffer);
     let currentImage = PNG.sync.read(currentImageBuffer);
     const maxWidth = Math.max(baselineImage.width || 100, currentImage.width || 100);
     const maxHeight = Math.max(baselineImage.height || 100, currentImage.height || 100);
-    if (baselineImage.width !== currentImage.width || baselineImage.height !== currentImage.height) {
+    if (baselineImage.width !== currentImage.width ||
+        baselineImage.height !== currentImage.height) {
         baselineImage = resizeImage(baselineImage, maxWidth, maxHeight);
         currentImage = resizeImage(currentImage, maxWidth, maxHeight);
     }
@@ -44,3 +49,4 @@ export const runPixelmatchComparison = (threshold, baselineShotPath, currentShot
         isWithinThreshold: true,
     };
 };
+//# sourceMappingURL=pixelmatch.js.map

package/{dist → build}/compare/utils.d.ts

@@ -1,2 +1,2 @@
-import { PNG } from 'pngjs';
+import { PNG } from "pngjs";
 export declare const resizeImage: (originalImage: PNG, width: number, height: number) => PNG;

package/{dist → build}/compare/utils.js

@@ -1,4 +1,4 @@
-import { PNG } from 'pngjs';
+import { PNG } from "pngjs";
 export const resizeImage = (originalImage, width, height) => {
     const newImage = new PNG({
         width,
@@ -8,7 +8,6 @@ export const resizeImage = (originalImage, width, height) => {
     });
     for (let x = 0; x < width; x++) {
         for (let y = 0; y < height; y++) {
-            // eslint-disable-next-line no-bitwise
             const index = ((width * y + x) << 2) + 3;
             newImage.data[index] = 64;
         }
@@ -16,3 +15,4 @@ export const resizeImage = (originalImage, width, height) => {
     PNG.bitblt(originalImage, newImage, 0, 0, originalImage.width, originalImage.height, 0, 0);
     return newImage;
 };
+//# sourceMappingURL=utils.js.map

package/{dist → build}/compare/worker.js

@@ -1,6 +1,7 @@
 // This file runs inside a worker_threads Worker.
 // It performs the CPU-bound pixelmatch comparison off the main thread.
-import { parentPort, workerData } from 'node:worker_threads';
-import { runPixelmatchComparison } from './pixelmatch.js';
+import { parentPort, workerData } from "node:worker_threads";
+import { runPixelmatchComparison } from "./pixelmatch.js";
 const result = runPixelmatchComparison(workerData.threshold, workerData.baselineShotPath, workerData.currentShotPath, workerData.differenceShotPath);
 parentPort?.postMessage(result);
+//# sourceMappingURL=worker.js.map

package/{dist → build}/concurrency.d.ts

@@ -1,16 +1,16 @@
 /**
- * Default number of concurrent shots to take, derived from the number of
- * CPUs the process is allowed to use (respects cgroup CPU quotas).
+ * Default number of concurrent shots to take, derived from the number of CPUs
+ * the process is allowed to use (respects cgroup CPU quotas).
  */
 export declare const defaultShotConcurrency: () => number;
 /**
- * Run an array of async tasks with a concurrency limit.
- * Drop-in replacement for `async.mapLimit`.
+ * Run an array of async tasks with a concurrency limit. Drop-in replacement for
+ * `async.mapLimit`.
  */
 export declare const mapLimit: <T, R>(items: Iterable<T>, limit: number, fn: (item: T) => Promise<R>) => Promise<R[]>;
 /**
- * Retry an async function with exponential backoff.
- * Drop-in replacement for `async.retry`.
+ * Retry an async function with exponential backoff. Drop-in replacement for
+ * `async.retry`.
  */
 export declare const retry: <T>(options: {
     times: number;