@zucker-framework/ext-kit 1.0.2 → 1.0.6

package/dist/scroll-capture.js

@@ -0,0 +1,309 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/scroll-capture.js
+  var scroll_capture_exports = {};
+  __export(scroll_capture_exports, {
+    prepare: () => prepare,
+    restore: () => restore
+  });
+  var sessions = /* @__PURE__ */ new WeakMap();
+  function pageTask(action, id, index, leaseMs) {
+    const key = "__zuckerScrollCapture";
+    let state = window[key];
+    if (action === "restore") {
+      if (state?.id === id) state.restore();
+      return {};
+    }
+    if (action === "init") {
+      if (state) throw new Error("Another scrolling-content capture is active");
+      const elements = [...document.querySelectorAll("*")];
+      if (elements.length > 3e4)
+        throw new Error(
+          "This page is too complex to expand its scrolling content safely."
+        );
+      const panels = elements.filter((el) => {
+        if (el === document.body || el === document.documentElement || el === document.scrollingElement || el.closest(
+          'nav,aside,[role="navigation"],[role="menu"],textarea,select'
+        ))
+          return false;
+        const rect = el.getBoundingClientRect(), css = getComputedStyle(el);
+        if (rect.width < 120 || rect.height < 80 || el.scrollHeight <= el.clientHeight + 2 || !/^(auto|scroll|overlay)$/.test(css.overflowY) || css.visibility !== "visible")
+          return false;
+        for (let parent = el; parent; parent = parent.parentElement) {
+          const style = getComputedStyle(parent);
+          if (style.display === "none" || Number(style.opacity) === 0)
+            return false;
+        }
+        return true;
+      });
+      if (!panels.length) return { count: 0 };
+      if (panels.length > 24)
+        throw new Error(
+          "This page has too many independent scrolling areas. Use Visible window or export smaller sections."
+        );
+      const virtual = '.rc-virtual-list-holder,.ant-table-tbody-virtual-holder,[data-virtuoso-scroller],.ReactVirtualized__Grid,.ReactVirtualized__List,[data-virtualized="true"]';
+      if (panels.some(
+        (el) => el.matches(virtual) || [...el.querySelectorAll(virtual)].some(
+          (list) => list.getClientRects().length && list.checkVisibility({
+            checkOpacity: true,
+            checkVisibilityCSS: true
+          })
+        )
+      ))
+        throw new Error(
+          "This page uses a virtual scrolling list. A complete full-page capture is not available; use the table's export or Visible window."
+        );
+      const changes = /* @__PURE__ */ new Map(), scrolls = /* @__PURE__ */ new Map();
+      state = {
+        id,
+        panels,
+        changes,
+        scrolls,
+        boxes: /* @__PURE__ */ new Map(),
+        watchdog: null,
+        leaseMs
+      };
+      state.set = (el, property, value) => {
+        if (!changes.has(el))
+          changes.set(el, {
+            hadStyle: el.hasAttribute("style"),
+            properties: /* @__PURE__ */ new Map()
+          });
+        const saved = changes.get(el).properties;
+        if (!saved.has(property))
+          saved.set(property, {
+            value: el.style.getPropertyValue(property),
+            priority: el.style.getPropertyPriority(property)
+          });
+        el.style.setProperty(property, value, "important");
+      };
+      state.restore = () => {
+        clearTimeout(state.watchdog);
+        const scrollingProperties = /* @__PURE__ */ new Set([
+          "scroll-behavior",
+          "scroll-snap-type",
+          "overflow-anchor"
+        ]);
+        const restoreProperty = (el, property, old) => old.value ? el.style.setProperty(property, old.value, old.priority) : el.style.removeProperty(property);
+        for (const [el, saved] of [...changes].reverse())
+          for (const [property, old] of saved.properties)
+            if (!scrollingProperties.has(property))
+              restoreProperty(el, property, old);
+        for (const [el, saved] of scrolls) {
+          el.scrollLeft = saved.x;
+          el.scrollTop = saved.y;
+        }
+        for (const [el, saved] of changes) {
+          for (const [property, old] of saved.properties)
+            if (scrollingProperties.has(property))
+              restoreProperty(el, property, old);
+          if (!saved.hadStyle && !el.style.length) {
+            el.getAttribute("style");
+            el.removeAttribute("style");
+          }
+        }
+        if (window[key]?.id === id) delete window[key];
+      };
+      window[key] = state;
+      state.watchdog = setTimeout(state.restore, state.leaseMs);
+      for (const el of elements) {
+        if (!el.scrollTop && !el.scrollLeft) continue;
+        scrolls.set(el, { x: el.scrollLeft, y: el.scrollTop });
+        state.set(el, "scroll-behavior", "auto");
+        state.set(el, "scroll-snap-type", "none");
+        state.set(el, "overflow-anchor", "none");
+      }
+      for (const panel of panels) {
+        const rect = panel.getBoundingClientRect();
+        state.boxes.set(panel, { width: rect.width, x: rect.x });
+        scrolls.set(panel, { x: panel.scrollLeft, y: panel.scrollTop });
+        state.set(panel, "scroll-behavior", "auto");
+        state.set(panel, "scroll-snap-type", "none");
+        state.set(panel, "overflow-anchor", "none");
+        panel.scrollTop = 0;
+      }
+      return { count: panels.length };
+    }
+    if (!state || state.id !== id)
+      throw new Error(
+        "The page changed while preparing its scrolling content."
+      );
+    clearTimeout(state.watchdog);
+    state.watchdog = setTimeout(state.restore, state.leaseMs);
+    if (action === "scroll" || action === "position") {
+      const panel = state.panels[index];
+      if (!panel.isConnected)
+        throw new Error(
+          "A scrolling area changed during capture. Please retry."
+        );
+      if (action === "scroll")
+        panel.scrollTop += Math.max(80, panel.clientHeight * 0.8);
+      return {
+        bottom: panel.scrollTop + panel.clientHeight >= panel.scrollHeight - 1,
+        height: panel.scrollHeight
+      };
+    }
+    if (action === "expand") {
+      for (const panel of [...state.panels].reverse()) {
+        if (!panel.isConnected)
+          throw new Error(
+            "A scrolling area changed during capture. Please retry."
+          );
+        let el = panel;
+        while (el) {
+          const rect = el.getBoundingClientRect(), css = getComputedStyle(el);
+          if (!state.scrolls.has(el))
+            state.scrolls.set(el, { x: el.scrollLeft, y: el.scrollTop });
+          if (!state.boxes.has(el))
+            state.boxes.set(el, { width: rect.width, x: rect.x });
+          state.set(el, "scroll-behavior", "auto");
+          state.set(el, "overflow-anchor", "none");
+          state.set(el, "transition", "none");
+          state.set(el, "box-sizing", "border-box");
+          state.set(el, "width", `${state.boxes.get(el).width}px`);
+          state.set(el, "max-height", "none");
+          state.set(el, "flex-shrink", "0");
+          if (css.position === "fixed") {
+            state.set(el, "position", "absolute");
+            state.set(el, "top", `${rect.top + scrollY}px`);
+            state.set(el, "left", `${rect.left + scrollX}px`);
+            state.set(el, "right", "auto");
+          }
+          if (css.position === "fixed" || css.position === "absolute")
+            state.set(el, "bottom", "auto");
+          if (state.panels.includes(el)) {
+            const height = el.scrollHeight + el.offsetHeight - el.clientHeight;
+            state.set(el, "height", `${height}px`);
+            state.set(el, "min-height", `${height}px`);
+            state.set(el, "scrollbar-gutter", "stable");
+            state.set(el, "overflow-y", "hidden");
+            el.scrollTop = 0;
+          } else {
+            state.set(el, "height", "auto");
+            state.set(
+              el,
+              "min-height",
+              `${Math.max(rect.height, el.clientHeight)}px`
+            );
+            if (/hidden|clip|auto|scroll/.test(css.overflowY)) {
+              state.set(el, "overflow-x", "clip");
+              state.set(el, "overflow-y", "visible");
+            }
+          }
+          if (css.contain !== "none") state.set(el, "contain", "none");
+          el = el.parentElement;
+        }
+      }
+      return { height: document.documentElement.scrollHeight };
+    }
+    if (action === "measure") {
+      for (const panel of state.panels) {
+        const rect = panel.getBoundingClientRect(), original = state.boxes.get(panel);
+        if (Math.abs(rect.width - original.width) > 1 || Math.abs(rect.x - original.x) > 1)
+          throw new Error(
+            "This scrolling layout cannot be expanded without changing its width. Use Visible window or the website's export."
+          );
+      }
+      return {
+        height: Math.max(
+          document.documentElement.scrollHeight,
+          document.body?.scrollHeight || 0
+        ),
+        panels: state.panels.map((el) => [el.scrollHeight, el.clientHeight]),
+        ready: document.fonts.status === "loaded" && [...document.images].every(
+          (image) => image.complete || !state.panels.some((panel) => panel.contains(image)) || !image.getClientRects().length || image.checkVisibility?.({
+            checkOpacity: true,
+            checkVisibilityCSS: true
+          }) === false
+        )
+      };
+    }
+    return {};
+  }
+  async function command(ctx, id, action, index, leaseMs) {
+    const response = await ctx[action === "restore" ? "cleanup" : "send"](
+      "Runtime.evaluate",
+      {
+        expression: `(${pageTask.toString()})(${JSON.stringify(action)},${JSON.stringify(id)},${JSON.stringify(index)},${JSON.stringify(leaseMs)})`,
+        returnByValue: true
+      }
+    );
+    if (response?.exceptionDetails)
+      throw new Error(
+        response.exceptionDetails.exception?.description?.split("\n")[0] || "Could not prepare scrolling content"
+      );
+    return response?.result?.value || {};
+  }
+  async function prepare(ctx, waitForContent = async () => {
+  }) {
+    const id = crypto.randomUUID();
+    sessions.set(ctx, id);
+    const readinessMs = Math.min(
+      6e4,
+      Math.max(0, Number(ctx.options?.readyTimeoutMs) || 25e3)
+    );
+    const initial = await command(
+      ctx,
+      id,
+      "init",
+      null,
+      Math.max(6e4, readinessMs + 15e3)
+    );
+    if (!initial.count) {
+      sessions.delete(ctx);
+      return;
+    }
+    let deadline = Date.now() + readinessMs + 15e3;
+    for (let index = 0; index < initial.count; index++) {
+      let bottom = false;
+      for (let step = 0; step < 60 && Date.now() < deadline; step++) {
+        const position = await command(ctx, id, "scroll", index);
+        await new Promise((resolve) => setTimeout(resolve, 120));
+        if (position.bottom) {
+          await waitForContent();
+          const loaded = await command(ctx, id, "position", index);
+          if (loaded.bottom && loaded.height === position.height) {
+            bottom = true;
+            break;
+          }
+        }
+      }
+      if (!bottom)
+        throw new Error(
+          "Scrolling content keeps growing or exceeds the capture limit. Use Visible window or a smaller section."
+        );
+    }
+    await waitForContent();
+    await command(ctx, id, "expand");
+    await waitForContent();
+    deadline = Date.now() + 15e3;
+    let previous = "", stable = 0;
+    while (Date.now() < deadline) {
+      await command(ctx, id, "expand");
+      await new Promise((resolve) => setTimeout(resolve, 250));
+      const measured = await command(ctx, id, "measure");
+      const signature = JSON.stringify([measured.height, measured.panels]);
+      stable = measured.ready && signature === previous && measured.panels.every(([full, view]) => full <= view + 2) ? stable + 1 : 0;
+      if (stable >= 2) return;
+      previous = signature;
+    }
+    throw new Error(
+      "Scrolling content did not settle in time. Wait for it to finish loading and retry."
+    );
+  }
+  async function restore(ctx) {
+    const id = sessions.get(ctx);
+    if (!id) return;
+    sessions.delete(ctx);
+    await command(ctx, id, "restore");
+  }
+
+  // src/scroll-capture.entry.ts
+  globalThis.ZuckerScrollCapture = scroll_capture_exports;
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zucker-framework/ext-kit",
-  "version": "1.0.2",
+  "version": "1.0.6",
   "description": "Browser extension infrastructure kit — batch engine, capture session, licensing, popup driver. Vendored into extensions as ext-kit.js / ext-kit-popup.js.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -47,6 +47,8 @@
   "scripts": {
     "build": "tsup && node build-vendored.mjs",
     "clean": "rm -rf dist",
-    "lint": "eslint src/"
+    "lint": "eslint src/",
+    "test:unit": "node --test test/engine.test.cjs test/licensing.test.cjs test/lifecycle.test.cjs && vitest run --root ../.. packages/ext-kit/src/naming.spec.ts",
+    "test:browser": "node --test test/browser.test.cjs"
   }
 }