e10-ebuilder-prototype 0.5.0

package/dist/readiness.js

@@ -0,0 +1,529 @@
+import { CaptureError, digest, sleep } from './common.js';
+// Global search history does not render inside the E10 page (verified 2026-09-11).
+const ignored = /^(?:\/api\/front\/monitor\/|\/api\/em\/msg\/getTopSearchList$)/;
+export class Monitor {
+    page;
+    origin;
+    expectedPage;
+    generation = 0;
+    lastSample;
+    requestStarted = new Map();
+    entranceAt = 0;
+    pending = new Set();
+    processing = new Set();
+    processingRequests = new Map();
+    lastActivity = Date.now();
+    epoch = 0;
+    issues = [];
+    pageConfig;
+    entrance = false;
+    constructor(page, origin, expectedPage) {
+        this.page = page;
+        this.origin = origin;
+        this.expectedPage = expectedPage;
+        this.pageConfig = expectedPage;
+        page.on('request', (r) => {
+            if (r.isNavigationRequest() && r.frame() === page.mainFrame()) {
+                this.generation++;
+                this.pending.clear();
+                this.requestStarted.clear();
+                this.processing.clear();
+                this.processingRequests.clear();
+                this.issues = [];
+                this.entrance = false;
+                this.pageConfig = expectedPage;
+                this.touch();
+            }
+            if (this.blocking(r)) {
+                this.pending.add(r);
+                this.requestStarted.set(r, Date.now());
+                this.touch();
+            }
+        });
+        page.on('requestfinished', (r) => {
+            if (this.pending.delete(r))
+                this.touch();
+            this.requestStarted.delete(r);
+        });
+        page.on('requestfailed', (r) => {
+            const processing = this.processingRequests.get(r);
+            if (processing)
+                this.processing.delete(processing);
+            this.processingRequests.delete(r);
+            if (this.relevant(r))
+                this.issue(r, 'NETWORK_FAILED');
+            if (this.pending.delete(r)) {
+                this.touch();
+                this.requestStarted.delete(r);
+            }
+        });
+        page.on('response', (r) => {
+            const req = r.request();
+            if (!this.relevant(req))
+                return;
+            if (r.status() >= 400)
+                this.issue(req, `HTTP_${r.status()}`);
+            if (new URL(r.url()).origin !== origin ||
+                !['xhr', 'fetch'].includes(req.resourceType()) ||
+                !/json/i.test(r.headers()['content-type'] || ''))
+                return;
+            const generation = this.generation;
+            const promise = (async () => {
+                const url = new URL(r.url());
+                if (url.origin === origin &&
+                    ['xhr', 'fetch'].includes(req.resourceType()) &&
+                    /json/i.test(r.headers()['content-type'] || '')) {
+                    const j = await r.json().catch(() => null);
+                    if (generation !== this.generation)
+                        return;
+                    if (j && typeof j === 'object') {
+                        if ('code' in j &&
+                            (j.status === false ||
+                                j.fail === true ||
+                                ![0, 200, '0', '200', null].includes(j.code)))
+                            this.issue(req, `BUSINESS_${String(j.code ?? 'FAIL').slice(0, 20)}`);
+                        if (url.pathname === '/api/ebuilder/page/view/entrance') {
+                            const terminalMessage = /当前页面不支持(?:PC|移动)端访问/.test(j.msg || '')
+                                ? j.msg
+                                : undefined;
+                            if (j.data?.page || terminalMessage) {
+                                this.entrance = true;
+                                this.entranceAt = Date.now();
+                                this.pageConfig = {
+                                    id: j.data?.page?.id,
+                                    layoutType: j.data?.page?.layoutType,
+                                    componentCount: Array.isArray(j.data?.page?.comps)
+                                        ? j.data.page.comps.length
+                                        : undefined,
+                                    terminalMessage,
+                                };
+                            }
+                        }
+                    }
+                }
+            })()
+                .catch(() => {
+                if (generation === this.generation)
+                    this.issue(req, 'RESPONSE_UNREADABLE');
+            })
+                .finally(() => {
+                this.processing.delete(promise);
+                this.processingRequests.delete(req);
+                if (generation === this.generation && this.blocking(req)) {
+                    this.touch();
+                }
+            });
+            if (this.blocking(req)) {
+                this.processing.add(promise);
+                this.processingRequests.set(req, promise);
+            }
+        });
+    }
+    touch() {
+        this.lastActivity = Date.now();
+        this.epoch++;
+    }
+    relevant(r) {
+        const u = new URL(r.url());
+        return (['document', 'script', 'stylesheet', 'font', 'image', 'xhr', 'fetch'].includes(r.resourceType()) && !ignored.test(u.pathname));
+    }
+    blocking(r) {
+        const u = new URL(r.url());
+        let embeddedRequest = false;
+        try {
+            embeddedRequest = r.frame().url().startsWith(`${this.origin}/sp/chtml/`);
+        }
+        catch {
+            /* service workers have no frame */
+        }
+        // The page's own data and custom components must settle. Global application
+        // background requests do not decide whether the displayed page is ready.
+        return (this.relevant(r) &&
+            u.origin === this.origin &&
+            ((r.isNavigationRequest() && r.frame() === this.page.mainFrame()) ||
+                embeddedRequest ||
+                (r.isNavigationRequest() && u.pathname.startsWith('/sp/chtml/')) ||
+                (['xhr', 'fetch'].includes(r.resourceType()) &&
+                    u.pathname.startsWith('/api/bs/ebuilder/form/')) ||
+                (['xhr', 'fetch'].includes(r.resourceType()) && u.pathname.startsWith('/api/ebuilder/')) ||
+                (['script', 'stylesheet'].includes(r.resourceType()) &&
+                    u.pathname.startsWith('/ecodestatic/'))));
+    }
+    issue(r, kind) {
+        const u = new URL(r.url());
+        const critical = u.origin === this.origin &&
+            ['document', 'script', 'stylesheet', 'font', 'xhr', 'fetch'].includes(r.resourceType());
+        if (this.issues.length < 100 &&
+            !this.issues.some((i) => i.path === u.origin + u.pathname && i.kind === kind))
+            this.issues.push({ path: u.origin + u.pathname, kind, critical });
+    }
+    evidence() {
+        return {
+            lastSample: this.lastSample,
+            pending: [...this.pending].map((r) => new URL(r.url()).pathname).slice(0, 20),
+            processing: this.processing.size,
+            issues: this.issues,
+        };
+    }
+    check() {
+        const failures = this.issues.filter((i) => i.critical);
+        if (failures.some((i) => /^(HTTP|BUSINESS)_(401|403)$/.test(i.kind)))
+            throw new CaptureError('E10_LOGIN_REQUIRED', '页面认证失效，请重新执行 auth set');
+        // Stable page error states are screenshot content; preserve them as warnings.
+    }
+}
+export async function sample(page, viewId, requireEntrance, monitor) {
+    const data = await page.evaluate(({ viewId, pageConfig }) => {
+        const ordinaryRoot = document.getElementById(`ebpage_${viewId}`);
+        const placeholders = [...document.querySelectorAll('.ebcoms-empty,.ui-empty')];
+        const emptyRoot = pageConfig?.id === viewId && pageConfig.componentCount === 0
+            ? placeholders.find((e) => e.innerText.trim() === '暂无内容')
+            : undefined;
+        const terminalRoot = pageConfig?.terminalMessage
+            ? placeholders.find((e) => e.innerText.includes(pageConfig.terminalMessage))
+            : undefined;
+        const codeRoot = pageConfig?.id === viewId
+            ? document.querySelector('.weapp-de-sourcecode-render')
+            : null;
+        const codeContent = codeRoot &&
+            (codeRoot.innerText.trim() || codeRoot.querySelector('iframe,canvas,svg,img,table'));
+        const root = ordinaryRoot || emptyRoot || terminalRoot || (codeContent ? codeRoot : null);
+        const pageState = emptyRoot && !ordinaryRoot
+            ? 'empty'
+            : terminalRoot && !ordinaryRoot
+                ? 'terminal-unavailable'
+                : 'rendered';
+        const visible = (e) => {
+            const r = e.getBoundingClientRect();
+            let left = r.left, right = r.right, top = r.top, bottom = r.bottom;
+            if (r.width <= 0 || r.height <= 0)
+                return false;
+            for (let p = e; p; p = p.parentElement) {
+                const style = getComputedStyle(p);
+                if (style.visibility === 'hidden' ||
+                    style.display === 'none' ||
+                    Number(style.opacity) === 0)
+                    return false;
+                if (p !== e && p !== document.documentElement && p !== document.body) {
+                    const b = p.getBoundingClientRect();
+                    if (/hidden|clip|auto|scroll/.test(style.overflowX)) {
+                        left = Math.max(left, b.left);
+                        right = Math.min(right, b.right);
+                    }
+                    if (/hidden|clip|auto|scroll/.test(style.overflowY)) {
+                        top = Math.max(top, b.top);
+                        bottom = Math.min(bottom, b.bottom);
+                    }
+                }
+            }
+            return right - left > 0.5 && bottom - top > 0.5;
+        };
+        const inside = (e) => {
+            const r = e.getBoundingClientRect();
+            return (visible(e) && r.bottom > 0 && r.top < innerHeight && r.right > 0 && r.left < innerWidth);
+        };
+        const loading = [
+            ...document.querySelectorAll('[aria-busy="true"],.ui-spin-spinning,.ant-spin-spinning,.ui-loading,.ebpage-loading,.ui-skeleton,[data-capture-loading]'),
+        ].filter(visible).length;
+        const error = [
+            ...document.querySelectorAll('.ui-message-error,.ant-message-error,.ebcom-error,[data-capture-error]'),
+        ].filter(visible).length;
+        const elements = root ? [root, ...root.querySelectorAll('*')] : [];
+        const geometry = elements.filter(visible).map((e) => {
+            const r = e.getBoundingClientRect();
+            return [
+                e.tagName,
+                e.id,
+                e.getAttribute('data-type'),
+                Math.round(r.x),
+                Math.round(r.y),
+                Math.round(r.width),
+                Math.round(r.height),
+                e.childElementCount === 0 ? e.textContent : '',
+            ];
+        });
+        const components = elements
+            .filter((e) => e.matches('[data-type][data-id],.ebcom[id]') && visible(e))
+            .map((e) => ({
+            id: e.id || e.getAttribute('data-id'),
+            type: e.getAttribute('data-type') ||
+                [...e.classList].find((c) => c.startsWith('ebcom-')) ||
+                'component',
+        }));
+        const canvases = [...document.querySelectorAll('canvas')].filter(visible).map((c) => {
+            try {
+                const dst = document.createElement('canvas');
+                dst.width = 48;
+                dst.height = 48;
+                const ctx = dst.getContext('2d');
+                ctx.drawImage(c, 0, 0, 48, 48);
+                const data = ctx.getImageData(0, 0, 48, 48).data;
+                let h = 2166136261;
+                for (const n of data)
+                    h = Math.imul(h ^ n, 16777619);
+                return `${c.width}x${c.height}:${h >>> 0}`;
+            }
+            catch {
+                return 'UNREADABLE';
+            }
+        });
+        const images = [...document.images].filter(inside);
+        const broken = images.filter((i) => i.complete && !i.naturalWidth && !!i.currentSrc).length;
+        const pendingImages = images.filter((i) => !i.complete).length;
+        const finiteAnimations = document
+            .getAnimations()
+            .filter((a) => a.playState === 'running' && a.effect?.getComputedTiming().iterations !== Infinity).length;
+        const virtual = [
+            ...document.querySelectorAll('[data-capture-virtual],.ReactVirtualized__Grid,.react-window,[class*=virtual-list-holder]'),
+        ].filter(visible).length;
+        const rootSize = root
+            ? { width: root.getBoundingClientRect().width, height: root.getBoundingClientRect().height }
+            : null;
+        return {
+            timeOrigin: performance.timeOrigin,
+            origin: location.origin,
+            pathname: location.pathname,
+            root: !!root && visible(root),
+            boundContent: !!ordinaryRoot ||
+                !!(codeContent &&
+                    pageConfig?.id === viewId &&
+                    location.pathname.startsWith(`/sp/ebdpage/view/${viewId}/`)),
+            pageState,
+            rootSize,
+            readyState: document.readyState,
+            loading,
+            error,
+            geometry,
+            components,
+            canvases,
+            broken,
+            pendingImages,
+            fonts: document.fonts.status,
+            finiteAnimations,
+            virtual,
+            width: Math.max(document.documentElement.scrollWidth, document.body.scrollWidth),
+            height: Math.max(document.documentElement.scrollHeight, document.body.scrollHeight),
+            frames: [...document.querySelectorAll('iframe')].filter(visible).length,
+        };
+    }, { viewId, pageConfig: monitor.pageConfig });
+    for (const r of monitor.pending) {
+        const start = monitor.requestStarted.get(r);
+        if (start && start < data.timeOrigin) {
+            monitor.pending.delete(r);
+            monitor.requestStarted.delete(r);
+        }
+    }
+    if (data.origin !== monitor.origin || /\/(login|passport)(\/|$)/i.test(data.pathname))
+        throw new CaptureError('E10_LOGIN_REQUIRED', '页面已跳转登录或其他环境');
+    monitor.check();
+    // A settled business error or a broken image is captured as displayed, with warnings.
+    if (data.canvases.includes('UNREADABLE'))
+        throw new CaptureError('CANVAS_UNVERIFIABLE', 'Canvas 无法读取，不能验证渲染稳定性');
+    if (data.virtual)
+        throw new CaptureError('VIRTUAL_CONTENT_UNSUPPORTED', '检测到虚拟滚动列表，无法证明整段内容已渲染');
+    const frameStates = [];
+    if (data.frames)
+        for (const frame of page.frames().slice(1)) {
+            const element = await frame.frameElement();
+            const shown = await element
+                .evaluate((node) => {
+                const e = node;
+                const r = e.getBoundingClientRect();
+                let left = r.left, right = r.right, top = r.top, bottom = r.bottom;
+                for (let p = e; p; p = p.parentElement) {
+                    const s = getComputedStyle(p), b = p.getBoundingClientRect();
+                    if (s.display === 'none' || s.visibility === 'hidden' || Number(s.opacity) === 0)
+                        return false;
+                    if (p !== e && p !== document.body && p !== document.documentElement) {
+                        if (/hidden|clip|auto|scroll/.test(s.overflowX)) {
+                            left = Math.max(left, b.left);
+                            right = Math.min(right, b.right);
+                        }
+                        if (/hidden|clip|auto|scroll/.test(s.overflowY)) {
+                            top = Math.max(top, b.top);
+                            bottom = Math.min(bottom, b.bottom);
+                        }
+                    }
+                }
+                return right - left > 0.5 && bottom - top > 0.5;
+            })
+                .finally(() => element.dispose());
+            if (!shown)
+                continue;
+            const state = await frame.evaluate(() => ({
+                state: document.readyState,
+                fonts: document.fonts.status,
+                text: document.body?.innerText || '',
+                geometry: [...document.querySelectorAll('*')].flatMap((e) => {
+                    const r = e.getBoundingClientRect(), s = getComputedStyle(e);
+                    return r.width > 0 &&
+                        r.height > 0 &&
+                        r.bottom > 0 &&
+                        r.top < innerHeight &&
+                        s.display !== 'none' &&
+                        s.visibility !== 'hidden'
+                        ? [
+                            [
+                                e.tagName,
+                                ...[r.x, r.y, r.width, r.height].map(Math.round),
+                                e.childElementCount ? '' : e.textContent,
+                            ],
+                        ]
+                        : [];
+                }),
+                width: document.documentElement.scrollWidth,
+                height: document.documentElement.scrollHeight,
+                images: [...document.images].map((i) => [i.complete, i.naturalWidth]),
+                loading: !!document.querySelector('[aria-busy="true"],.ui-spin-spinning'),
+            }));
+            frameStates.push({
+                signature: digest(JSON.stringify(state)),
+                ready: state.state === 'complete' &&
+                    state.fonts === 'loaded' &&
+                    !state.loading &&
+                    state.images.every((i) => i[0]),
+            });
+        }
+    const warnings = [
+        ...monitor.issues
+            .filter((i) => i.critical)
+            .map((i) => ({ code: 'PAGE_RESOURCE_ERROR', message: `${i.kind}: ${i.path}` })),
+        ...(data.error
+            ? [{ code: 'VISIBLE_PAGE_ERROR', message: '页面本身显示业务错误，按原样截图' }]
+            : []),
+        ...(data.broken
+            ? [{ code: 'BROKEN_IMAGE', message: `页面存在 ${data.broken} 张可见失效图片，按原样截图` }]
+            : []),
+        ...(data.pageState === 'terminal-unavailable'
+            ? [
+                {
+                    code: 'TERMINAL_UNAVAILABLE',
+                    message: '此页面 URL 在当前终端显示不支持访问，已保留原页面提示',
+                },
+            ]
+            : []),
+        ...(data.frames && monitor.pageConfig?.layoutType !== 'ECODE_HTML'
+            ? [{ code: 'IFRAME_VIEWPORT', message: 'iframe 保留页面设计的显示区域，不展开内嵌外部网站' }]
+            : []),
+    ];
+    const { geometry, ...evidence } = data;
+    return {
+        evidence: { ...evidence, warnings },
+        contentSignature: digest(JSON.stringify({
+            content: geometry.map((g) => [g[0], g[1], g[2], g[7]]),
+            canvases: data.canvases,
+        })),
+        signature: digest(JSON.stringify({
+            geometry,
+            canvases: data.canvases,
+            frameStates,
+            width: data.width,
+            height: data.height,
+        })),
+        ready: data.root &&
+            data.readyState !== 'loading' &&
+            !data.loading &&
+            frameStates.every((f) => f.ready) &&
+            !data.pendingImages &&
+            data.fonts === 'loaded' &&
+            !data.finiteAnimations &&
+            (!requireEntrance ||
+                data.boundContent ||
+                (monitor.entrance && monitor.entranceAt >= data.timeOrigin)) &&
+            !monitor.pending.size &&
+            !monitor.processing.size,
+    };
+}
+export async function ready(page, viewId, monitor, deadline, stableMs, requireEntrance = true) {
+    let previous = '', since = Date.now(), last;
+    while (Date.now() < deadline) {
+        try {
+            last = await sample(page, viewId, requireEntrance, monitor);
+        }
+        catch (e) {
+            if (/Execution context was destroyed|Frame (?:has been|was) detached|Cannot find context with specified id/.test(String(e))) {
+                since = Date.now();
+                await sleep(150);
+                continue;
+            }
+            throw e;
+        }
+        monitor.lastSample = {
+            ...last.evidence,
+            ready: last.ready,
+            stableForMs: Date.now() - since,
+            networkIdleForMs: Date.now() - monitor.lastActivity,
+            entrance: monitor.entrance,
+        };
+        if (last.signature !== previous || !last.ready) {
+            previous = last.signature;
+            since = Date.now();
+        }
+        if (last.ready &&
+            Date.now() - since >= stableMs &&
+            Date.now() - monitor.lastActivity >= stableMs) {
+            await page.evaluate(async () => {
+                await document.fonts.ready;
+                await Promise.all([...document.images]
+                    .filter((i) => i.complete && i.naturalWidth)
+                    .map((i) => i.decode().catch(() => { })));
+                await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(() => resolve())));
+            });
+            const confirmed = await sample(page, viewId, requireEntrance, monitor);
+            if (confirmed.ready && confirmed.signature === last.signature)
+                return confirmed;
+            since = Date.now();
+        }
+        await sleep(150);
+    }
+    throw new CaptureError('READINESS_TIMEOUT', '等待页面加载/渲染稳定超时', {
+        ...monitor.evidence(),
+        last: last?.evidence,
+    });
+}
+export async function lazyScroll(page, waitReady) {
+    const count = await page.evaluate(() => {
+        const root = document.scrollingElement || document.documentElement;
+        const regions = [
+            ...(root.scrollHeight > root.clientHeight + 3 ? [root] : []),
+            ...[...document.querySelectorAll('*')].filter((e) => e !== root &&
+                e.clientHeight > 60 &&
+                e.clientWidth > 60 &&
+                getComputedStyle(e).visibility !== 'hidden' &&
+                /(auto|scroll)/.test(getComputedStyle(e).overflowY) &&
+                e.scrollHeight > e.clientHeight + 3),
+        ];
+        window.__e10CaptureScrollers = regions;
+        return regions.length;
+    });
+    for (let i = 0; i < count; i++) {
+        let endCount = 0;
+        for (let step = 0; step < 100; step++) {
+            const before = await page.evaluate((i) => {
+                const e = window.__e10CaptureScrollers[i];
+                const old = e.scrollTop;
+                e.style.setProperty('scroll-behavior', 'auto', 'important');
+                e.scrollTop = Math.min(e.scrollTop + Math.max(100, e.clientHeight * 0.8), e.scrollHeight);
+                return { old, top: e.scrollTop, height: e.scrollHeight };
+            }, i);
+            await waitReady();
+            const after = await page.evaluate((i) => {
+                const e = window.__e10CaptureScrollers[i];
+                return { end: e.scrollTop + e.clientHeight >= e.scrollHeight - 3, height: e.scrollHeight };
+            }, i);
+            endCount = after.end && after.height === before.height ? endCount + 1 : 0;
+            if (endCount >= 2)
+                break;
+            if (step === 99 || (!after.end && before.old === before.top))
+                throw new CaptureError('SCROLL_LIMIT', '滚动未抵达稳定底部');
+        }
+        await page.evaluate((i) => {
+            const e = window.__e10CaptureScrollers[i];
+            e.scrollTop = 0;
+            e.scrollLeft = 0;
+        }, i);
+    }
+    if (count)
+        await waitReady();
+    return count;
+}

package/dist/runtime-support.d.mts

@@ -0,0 +1,52 @@
+export function environmentValue(env: any, name: any, platform?: NodeJS.Platform): any;
+export function productStateRoot(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, homeDirectory?: string): string;
+export function npmEnvironment(env?: NodeJS.ProcessEnv): {
+    [x: string]: string | undefined;
+    TZ?: string;
+};
+export function resolveNpmPath({ platform, env, nodePath, fileExists, }?: {
+    platform?: NodeJS.Platform | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    nodePath?: string | undefined;
+    fileExists?: typeof existsSync | undefined;
+}): string;
+export function processInvocation(command: any, args: any, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv, nodePath?: string): {
+    command: any;
+    args: any;
+    shell: boolean;
+    env: NodeJS.ProcessEnv;
+    windowsVerbatimArguments?: undefined;
+} | {
+    command: any;
+    args: string[];
+    shell: boolean;
+    env: {
+        [x: string]: string | undefined;
+        TZ?: string;
+    };
+    windowsVerbatimArguments: boolean;
+};
+export function processTreeTerminationInvocation(pid: any, platform?: NodeJS.Platform): {
+    command: string;
+    args: string[];
+    shell: boolean;
+} | null;
+export function processAlive(pid: any): boolean;
+export function terminateProcessTree(pid: any): Promise<void>;
+export function runChild(command: any, args: any, { cwd, stdio, timeout, env }?: {
+    stdio?: string | undefined;
+    timeout?: number | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+}): Promise<any>;
+export function chromeExecutable({ platform, env, homeDirectory, fileExists, }?: {
+    platform?: NodeJS.Platform | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    homeDirectory?: string | undefined;
+    fileExists?: typeof existsSync | undefined;
+}): string;
+export function renameWithRetry(source: any, target: any, rename?: typeof fs.rename): Promise<void>;
+export function renameWithRetrySync(source: any, target: any): void;
+export function reservedWindowsName(name: any): boolean;
+export function cleanupOwnedDirectory(target: any, parent: any, prefix: any): Promise<void>;
+import { existsSync } from 'node:fs';
+import fs from 'node:fs/promises';