@d-zero/archaeologist 1.1.1 → 1.1.3

package/dist/analize-url.d.ts

@@ -3,5 +3,9 @@ type AnalyzedUrlList = {
     hasAuth: boolean;
     hasNoSSL: boolean;
 };
+/**
+ *
+ * @param list
+ */
 export declare function analyzeUrlList(list: readonly URLPair[]): AnalyzedUrlList;
 export {};

package/dist/analize-url.js

@@ -1,3 +1,7 @@
+/**
+ *
+ * @param list
+ */
 export function analyzeUrlList(list) {
     const result = {
         hasAuth: false,

package/dist/analyze.d.ts

@@ -6,4 +6,9 @@ export interface AnalyzeOptions {
     readonly limit?: number;
     readonly debug?: boolean;
 }
+/**
+ *
+ * @param list
+ * @param options
+ */
 export declare function analyze(list: readonly URLPair[], options?: AnalyzeOptions): Promise<Result[]>;

package/dist/analyze.js

@@ -1,43 +1,36 @@
 import { writeFile, mkdir } from 'node:fs/promises';
 import path from 'node:path';
-import { deal } from '@d-zero/dealer';
+import { deal } from '@d-zero/puppeteer-dealer';
 import c from 'ansi-colors';
-import puppeteer from 'puppeteer';
 import { analyzeUrlList } from './analize-url.js';
 import { diffImages } from './diff-images.js';
 import { diffTree } from './diff-tree.js';
 import { getData } from './get-data.js';
-import { label, score } from './output-utils.js';
+import { score } from './output-utils.js';
+/**
+ *
+ * @param list
+ * @param options
+ */
 export async function analyze(list, options) {
-    const urlInfo = analyzeUrlList(list);
-    const useOldMode = urlInfo.hasAuth && urlInfo.hasNoSSL;
-    const browser = await puppeteer.launch({
-        headless: useOldMode ? 'shell' : true,
-        args: [
-            //
-            '--lang=ja',
-            '--no-zygote',
-            '--ignore-certificate-errors',
-        ],
-    });
     const results = [];
     const dir = path.resolve(process.cwd(), '.archaeologist');
     await mkdir(dir, { recursive: true }).catch(() => { });
-    await deal(list, 
-    //
-    async (urlPair, update, index) => {
-        const page = await browser.newPage();
-        page.setDefaultNavigationTimeout(0);
-        await page.setUserAgent('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36');
-        await page.setExtraHTTPHeaders({
-            'Accept-Language': 'ja-JP',
-        });
-        return async () => {
+    const urlInfo = analyzeUrlList(list);
+    const useOldMode = urlInfo.hasAuth || urlInfo.hasNoSSL;
+    await deal(list.map(([urlA]) => ({ id: null, url: urlA })), (_, done, total) => {
+        return `${c.bold.magenta('🕵️  Archaeologist')} ${done}/${total}`;
+    }, {
+        async deal(page, _, urlA, logger, index) {
+            const urlPair = list.find(([url]) => url === urlA);
+            if (!urlPair) {
+                throw new Error(`Failed to find urlPair: ${urlA}`);
+            }
             const dataPair = [];
             for (const url of urlPair) {
                 const data = await getData(page, url, {
                     ...options,
-                }, update);
+                }, logger);
                 dataPair.push(data);
                 await delay(600);
             }
@@ -46,10 +39,10 @@ export async function analyze(list, options) {
                 throw new Error('Failed to get screenshots');
             }
             const screenshotResult = {};
-            const outputUrl = c.gray(urlPair.join(' vs '));
+            const outputUrl = 'vs ' + c.gray(urlPair[1]);
             for (const [name, screenshotA] of Object.entries(a.screenshots)) {
                 const screenshotB = b.screenshots[name];
-                const sizeName = label(name);
+                const sizeName = c.bgMagenta(` ${name} `);
                 const id = `${index}_${name}`;
                 if (!screenshotB) {
                     throw new Error(`Failed to get screenshotB: ${id}`);
@@ -57,28 +50,28 @@ export async function analyze(list, options) {
                 const imageDiff = await diffImages(screenshotA, screenshotB, (phase, data) => {
                     switch (phase) {
                         case 'create': {
-                            update(`%braille% ${outputUrl} ${sizeName}: 🖼️ Create images`);
+                            logger(`${sizeName} ${outputUrl} 🖼️ Create images`);
                             break;
                         }
                         case 'resize': {
                             const { width, height } = data;
-                            update(`%braille% ${outputUrl} ${sizeName}: ↔️ Resize images to ${width}x${height}`);
+                            logger(`${sizeName} ${outputUrl} ↔️ Resize images to ${width}x${height}`);
                             break;
                         }
                         case 'diff': {
-                            update(`%braille% ${outputUrl} ${sizeName}: 📊 Compare images`);
+                            logger(`${sizeName} ${outputUrl} 📊 Compare images`);
                             break;
                         }
                     }
                 });
                 let image = null;
                 if (imageDiff) {
-                    update(`%braille% ${outputUrl} ${sizeName}: 🧩 Matches ${score(imageDiff.matches, 0.9)}`);
+                    logger(`${sizeName} ${outputUrl} 🧩 Matches ${score(imageDiff.matches, 0.9)}`);
                     await delay(1500);
                     await writeFile(path.resolve(dir, `${id}_a.png`), imageDiff.images.a);
                     await writeFile(path.resolve(dir, `${id}_b.png`), imageDiff.images.b);
                     const outFilePath = path.resolve(dir, `${id}_diff.png`);
-                    update(`%braille% ${outputUrl} ${sizeName}: 📊 Save diff image to ${path.relative(dir, outFilePath)}`);
+                    logger(`${sizeName} ${outputUrl} 📊 Save diff image to ${path.relative(dir, outFilePath)}`);
                     await writeFile(outFilePath, imageDiff.images.diff);
                     image = {
                         matches: imageDiff.matches,
@@ -102,17 +95,17 @@ export async function analyze(list, options) {
                 screenshots: screenshotResult,
             };
             results.push(result);
-        };
-    }, {
-        limit: options?.limit,
-        debug: options?.debug,
-        header(_, done, total) {
-            return `${c.bold.magenta('🕵️  Archaeologist')} ${done}/${total}`;
         },
+    }, {
+        ...options,
+        headless: useOldMode ? 'shell' : true,
     });
-    await browser.close();
     return results;
 }
+/**
+ *
+ * @param ms
+ */
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/archaeologist.d.ts

@@ -2,4 +2,9 @@ import type { AnalyzeOptions } from './analyze.js';
 import type { URLPair } from './types.js';
 export interface ArchaeologistOptions extends AnalyzeOptions {
 }
+/**
+ *
+ * @param list
+ * @param options
+ */
 export declare function archaeologist(list: readonly URLPair[], options?: ArchaeologistOptions): Promise<void>;

package/dist/archaeologist.js

@@ -1,6 +1,11 @@
 import c from 'ansi-colors';
 import { analyze } from './analyze.js';
-import { label, score } from './output-utils.js';
+import { score } from './output-utils.js';
+/**
+ *
+ * @param list
+ * @param options
+ */
 export async function archaeologist(list, options) {
     const results = await analyze(list, options);
     const output = [];
@@ -9,9 +14,9 @@ export async function archaeologist(list, options) {
         for (const [sizeName, { image, dom }] of Object.entries(result.screenshots)) {
             if (image) {
                 const { matches, file } = image;
-                output.push(`  ${label(sizeName)} ${score(matches, 0.9)} ${file}`);
+                output.push(`  ${c.bgMagenta(` ${sizeName} `)} ${score(matches, 0.9)} ${file}`);
             }
-            output.push(`  ${label('HTML', c.bgBlueBright)}: ${score(dom.matches, 0.995)} ${dom.file}`);
+            output.push(`  ${c.bgBlueBright(' HTML ')}: ${score(dom.matches, 0.995)} ${dom.file}`);
         }
     }
     process.stdout.write(output.join('\n') + '\n');

package/dist/diff-images.d.ts

@@ -16,12 +16,18 @@ export type DiffImagesPhase = {
     };
 };
 type DiffImagesListener = (phase: keyof DiffImagesPhase, data: DiffImagesPhase[keyof DiffImagesPhase]) => void;
+/**
+ *
+ * @param dataA
+ * @param dataB
+ * @param listener
+ */
 export declare function diffImages(dataA: Screenshot, dataB: Screenshot, listener: DiffImagesListener): Promise<{
     matches: number;
     images: {
-        a: Buffer;
-        b: Buffer;
-        diff: Buffer;
+        a: Buffer<ArrayBufferLike>;
+        b: Buffer<ArrayBufferLike>;
+        diff: Buffer<ArrayBufferLike>;
     };
 } | null>;
 export {};

package/dist/diff-images.js

@@ -1,6 +1,12 @@
 import { Jimp, HorizontalAlign, VerticalAlign, JimpMime } from 'jimp';
 import pixelmatch from 'pixelmatch';
 import { PNG } from 'pngjs';
+/**
+ *
+ * @param dataA
+ * @param dataB
+ * @param listener
+ */
 export async function diffImages(dataA, dataB, listener) {
     if (!dataA.binary || !dataB.binary) {
         return null;
@@ -31,6 +37,12 @@ export async function diffImages(dataA, dataB, listener) {
         },
     };
 }
+/**
+ *
+ * @param bin
+ * @param width
+ * @param height
+ */
 async function resizeImg(bin, width, height) {
     const img = await Jimp.read(bin);
     img.contain({

package/dist/diff-tree.d.ts

@@ -1,3 +1,10 @@
+/**
+ *
+ * @param urlA
+ * @param urlB
+ * @param dataA
+ * @param dataB
+ */
 export declare function diffTree(urlA: string, urlB: string, dataA: string, dataB: string): {
     changed: boolean;
     maxLine: number;

package/dist/diff-tree.js

@@ -1,5 +1,12 @@
 import { createTwoFilesPatch } from 'diff';
 import parse from 'parse-diff';
+/**
+ *
+ * @param urlA
+ * @param urlB
+ * @param dataA
+ * @param dataB
+ */
 export function diffTree(urlA, urlB, dataA, dataB) {
     const result = createTwoFilesPatch(urlA, urlB, dataA, dataB);
     const info = parse(result)[0];

package/dist/freeze.d.ts

@@ -0,0 +1,13 @@
+import type { PageData } from './types.js';
+import type { PageHook } from '@d-zero/puppeteer-screenshot';
+export interface FreezeOptions {
+    readonly hooks: readonly PageHook[];
+    readonly limit?: number;
+    readonly debug?: boolean;
+}
+/**
+ *
+ * @param list
+ * @param options
+ */
+export declare function freeze(list: readonly string[], options?: FreezeOptions): Promise<PageData[]>;

package/dist/freeze.js

@@ -0,0 +1,34 @@
+import { mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { deal } from '@d-zero/puppeteer-dealer';
+import { delay } from '@d-zero/shared/delay';
+import c from 'ansi-colors';
+import { analyzeUrlList } from './analize-url.js';
+import { getData } from './get-data.js';
+/**
+ *
+ * @param list
+ * @param options
+ */
+export async function freeze(list, options) {
+    const results = [];
+    const dir = path.resolve(process.cwd(), '.archaeologist');
+    await mkdir(dir, { recursive: true }).catch(() => { });
+    const urlInfo = analyzeUrlList(list);
+    const useOldMode = urlInfo.hasAuth || urlInfo.hasNoSSL;
+    await deal(list.map((url) => ({ id: null, url })), (_, done, total) => {
+        return `${c.bold.magenta('🕵️  Archaeologist Freeze❄️')} ${done}/${total}`;
+    }, {
+        async deal(page, _, url, logger) {
+            const data = await getData(page, url, {
+                ...options,
+            }, logger);
+            await delay(600);
+            results.push(data);
+        },
+    }, {
+        ...options,
+        headless: useOldMode ? 'shell' : true,
+    });
+    return results;
+}

package/dist/get-data.d.ts

@@ -1,8 +1,15 @@
 import type { PageData } from './types.js';
+import type { Page } from '@d-zero/puppeteer-page';
 import type { PageHook } from '@d-zero/puppeteer-screenshot';
-import type { Page } from 'puppeteer';
 export interface GetDataOptions {
     readonly hooks?: readonly PageHook[];
     readonly htmlDiffOnly?: boolean;
 }
+/**
+ *
+ * @param page
+ * @param url
+ * @param options
+ * @param update
+ */
 export declare function getData(page: Page, url: string, options: GetDataOptions, update: (log: string) => void): Promise<PageData>;

package/dist/get-data.js

@@ -1,5 +1,12 @@
 import { distill } from '@d-zero/html-distiller';
 import { screenshotListener, screenshot } from '@d-zero/puppeteer-screenshot';
+/**
+ *
+ * @param page
+ * @param url
+ * @param options
+ * @param update
+ */
 export async function getData(page, url, options, update) {
     const htmlDiffOnly = options.htmlDiffOnly ?? false;
     const screenshots = await screenshot(page, url, {

package/dist/output-utils.d.ts

@@ -1,3 +1,6 @@
-import c from 'ansi-colors';
-export declare function label(str: string, color?: c.StyleFunction): string;
+/**
+ *
+ * @param matches
+ * @param threshold
+ */
 export declare function score(matches: number, threshold: number): string;

package/dist/output-utils.js

@@ -1,7 +1,9 @@
 import c from 'ansi-colors';
-export function label(str, color = c.bgMagenta) {
-    return color(` ${str} `);
-}
+/**
+ *
+ * @param matches
+ * @param threshold
+ */
 export function score(matches, threshold) {
     const color = matches > threshold ? c.green : c.red;
     const num = (matches * 100).toFixed(1);

package/dist/read-config.d.ts

@@ -1,3 +1,7 @@
+/**
+ *
+ * @param filePath
+ */
 export declare function readConfig(filePath: string): Promise<{
     pairList: [string, string][];
     hooks: import("@d-zero/puppeteer-page-scan").PageHook[];

package/dist/read-config.js

@@ -3,6 +3,10 @@ import path from 'node:path';
 import { readPageHooks } from '@d-zero/puppeteer-page-scan';
 import { toList } from '@d-zero/readtext/list';
 import fm from 'front-matter';
+/**
+ *
+ * @param filePath
+ */
 export async function readConfig(filePath) {
     const fileContent = await fs.readFile(filePath, 'utf8');
     const content = 

package/dist/utils.d.ts

@@ -1,2 +1,6 @@
-export declare function label(str: string): string;
+/**
+ *
+ * @param matches
+ * @param threshold
+ */
 export declare function score(matches: number, threshold: number): string;

package/dist/utils.js

@@ -1,7 +1,9 @@
 import c from 'ansi-colors';
-export function label(str) {
-    return c.bgMagenta(` ${str} `);
-}
+/**
+ *
+ * @param matches
+ * @param threshold
+ */
 export function score(matches, threshold) {
     const color = matches > threshold ? c.green : c.red;
     const num = (matches * 100).toFixed(1);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@d-zero/archaeologist",
-	"version": "1.1.1",
+	"version": "1.1.3",
 	"description": "Uncover visual and HTML differences in web pages with precision",
 	"author": "D-ZERO",
 	"license": "MIT",
@@ -23,28 +23,29 @@
 	],
 	"scripts": {
 		"build": "tsc",
+		"watch": "tsc --watch",
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@d-zero/dealer": "1.1.0",
-		"@d-zero/html-distiller": "1.0.0",
-		"@d-zero/puppeteer-page-scan": "1.0.0",
-		"@d-zero/puppeteer-screenshot": "1.2.0",
-		"@d-zero/readtext": "1.1.0",
+		"@d-zero/html-distiller": "1.0.2",
+		"@d-zero/puppeteer-dealer": "0.3.0",
+		"@d-zero/puppeteer-page-scan": "3.0.0",
+		"@d-zero/puppeteer-screenshot": "3.0.0",
+		"@d-zero/readtext": "1.1.2",
 		"ansi-colors": "4.1.3",
 		"diff": "7.0.0",
 		"front-matter": "4.0.2",
 		"jimp": "1.6.0",
 		"minimist": "1.2.8",
 		"parse-diff": "0.11.1",
-		"pixelmatch": "6.0.0",
-		"pngjs": "7.0.0",
-		"puppeteer": "23.5.0"
+		"pixelmatch": "7.1.0",
+		"pngjs": "7.0.0"
 	},
 	"devDependencies": {
-		"@types/diff": "5.2.2",
+		"@d-zero/puppeteer-page": "0.3.0",
+		"@types/diff": "7.0.1",
 		"@types/pixelmatch": "5.2.6",
 		"@types/pngjs": "6.0.5"
 	},
-	"gitHead": "e8f65086bf7c316dda6667f1173da8585a5ef19c"
+	"gitHead": "e4fd17857e31022d121527b00fd7f009dbdb2142"
 }

package/dist/diff-tree-color.d.ts

@@ -1 +0,0 @@
-export declare function diffTreeColor(diff: string): string;

package/dist/diff-tree-color.js

@@ -1,15 +0,0 @@
-import c from 'ansi-colors';
-export function diffTreeColor(diff) {
-    return diff
-        .split('\n')
-        .map((line) => {
-        if (line.startsWith('+')) {
-            return c.green(line);
-        }
-        if (line.startsWith('-')) {
-            return c.red(line);
-        }
-        return c.gray(line);
-    })
-        .join('\n');
-}

package/dist/read-hooks.d.ts

@@ -1,2 +0,0 @@
-import type { PageHook } from '@d-zero/puppeteer-screenshot';
-export declare function readHooks(hooks: readonly string[], listfile: string): Promise<PageHook[]>;

package/dist/read-hooks.js

@@ -1,20 +0,0 @@
-import path from 'node:path';
-export async function readHooks(hooks, listfile) {
-    const listfileDir = path.dirname(listfile);
-    const pageHooks = await Promise.all(hooks.map(async (hook) => {
-        const hookAbsPath = path.isAbsolute(hook) ? hook : path.resolve(listfileDir, hook);
-        const { default: mod } = await import(hookAbsPath).catch((error) => {
-            if (error instanceof Error &&
-                'code' in error &&
-                error.code === 'ERR_MODULE_NOT_FOUND') {
-                throw new Error(`Hook: ${hook} not found`, { cause: error });
-            }
-            throw error;
-        });
-        if (typeof mod !== 'function') {
-            throw new TypeError(`Hook ${hook} is not a function`);
-        }
-        return mod;
-    }));
-    return pageHooks;
-}