@mokly/mokly 0.8.0

package/dist/browser/browse_evidence.js

@@ -0,0 +1,119 @@
+// src/client/browse_evidence.ts
+import { applyNavVisibility } from "./browse_navigation_state.js";
+function applyNavigationEvidence(doc, next) {
+  const tree = doc.querySelector("[data-mokly-nav-scroll]");
+  const scroll = tree?.scrollTop ?? 0;
+  const filter = doc.querySelector("[data-changes-status]");
+  const nextFilter = next.querySelector("[data-changes-status]");
+  if (filter && nextFilter) {
+    filter.dataset["changesStatus"] = nextFilter.dataset["changesStatus"];
+    copyChildren(
+      filter.querySelector(".mbk-nav-filter-count"),
+      nextFilter.querySelector(".mbk-nav-filter-count")
+    );
+  }
+  copyChildren(
+    doc.querySelector("[data-nav-status]"),
+    next.querySelector("[data-nav-status]")
+  );
+  const nextRows = new Map(
+    [...next.querySelectorAll("a[data-nav-row]")].map(
+      (row) => [row.getAttribute("href"), row]
+    )
+  );
+  const removed = /* @__PURE__ */ new Map();
+  for (const row of doc.querySelectorAll(
+    "a[data-nav-row]"
+  )) {
+    const replacement = nextRows.get(row.getAttribute("href"));
+    if (!replacement) {
+      if (row.hasAttribute("data-nav-removed")) row.remove();
+      continue;
+    }
+    if (replacement.getAttribute("data-changed") === "true") {
+      if (row.getAttribute("data-changed") !== "true")
+        row.setAttribute("data-changed", "true");
+    } else row.removeAttribute("data-changed");
+    if (row.hasAttribute("data-nav-removed")) {
+      removed.set(row.getAttribute("href"), row);
+      copyChildren(row, replacement);
+      for (const name of [
+        "data-tags",
+        "data-entry-id",
+        "data-entry-kind",
+        "data-removed-page"
+      ]) {
+        const value = replacement.getAttribute(name);
+        if (value === null) row.removeAttribute(name);
+        else row.setAttribute(name, value);
+      }
+    }
+    nextRows.delete(row.getAttribute("href"));
+  }
+  reconcileRemovedRows(doc, next, tree, removed);
+  applyNavVisibility(doc, "preserve");
+  if (tree) tree.scrollTop = scroll;
+}
+function reconcileRemovedRows(doc, next, tree, removed) {
+  if (!tree) return;
+  const currentSections = new Map(
+    [
+      ...tree.querySelectorAll(
+        ":scope > [data-nav-section]"
+      )
+    ].map((section) => [section.dataset["navSection"], section]).filter(
+      (entry) => entry[0] !== void 0
+    )
+  );
+  const nextSections = [
+    ...next.querySelectorAll(
+      "[data-mokly-nav-scroll] > [data-nav-section]"
+    )
+  ];
+  const nextIds = new Set(
+    nextSections.flatMap(
+      (section) => section.dataset["navSection"] ? [section.dataset["navSection"]] : []
+    )
+  );
+  let following = null;
+  for (const nextSection of [...nextSections].reverse()) {
+    const id = nextSection.dataset["navSection"];
+    if (!id) continue;
+    let current = currentSections.get(id);
+    if (!current) {
+      current = doc.importNode(nextSection, true);
+    } else {
+      let rowFollowing = null;
+      const nextRemoved = [
+        ...nextSection.querySelectorAll(
+          ":scope > a[data-nav-removed]"
+        )
+      ];
+      for (const row of nextRemoved.reverse()) {
+        const retained = removed.get(row.getAttribute("href")) ?? doc.importNode(row, true);
+        if (retained.parentElement !== current || retained.nextSibling !== rowFollowing)
+          current.insertBefore(retained, rowFollowing);
+        rowFollowing = retained;
+      }
+    }
+    if (current.parentElement !== tree || current.nextSibling !== following)
+      tree.insertBefore(current, following);
+    following = current;
+  }
+  for (const [id, section] of currentSections) {
+    if (!nextIds.has(id) && !section.querySelector("[data-nav-row]"))
+      section.remove();
+  }
+}
+function copyChildren(current, next) {
+  if (current && next && current.innerHTML !== next.innerHTML)
+    current.replaceChildren(
+      ...[...next.childNodes].map(
+        (node) => current.ownerDocument.importNode(node, true)
+      )
+    );
+}
+export {
+  applyNavigationEvidence,
+  copyChildren
+};

package/dist/browser/browse_fetch.js

@@ -0,0 +1,33 @@
+// src/client/browse_fetch.ts
+import { readPageStamp } from "./browse_update_state.js";
+import { adoptStaticDelivery } from "./static_delivery.js";
+async function fetchBrowseDestination(doc, win, url, slot) {
+  try {
+    while (slot.isCurrent()) {
+      const response = await win.fetch(url, {
+        headers: { accept: "text/html" },
+        signal: slot.signal,
+        cache: "no-store"
+      });
+      if (!response.ok && response.status !== 404) break;
+      const html = await response.text();
+      if (!slot.isCurrent()) return;
+      const parsed = new win.DOMParser().parseFromString(html, "text/html");
+      const currentStamp = readPageStamp(doc);
+      const nextStamp = readPageStamp(parsed);
+      if (currentStamp) {
+        if (!nextStamp || nextStamp.content !== currentStamp.content) break;
+        if (nextStamp.version < currentStamp.version) continue;
+      }
+      const view = parsed.querySelector("[data-mokly-view]");
+      if (!view || !adoptStaticDelivery(doc, parsed)) break;
+      return { parsed, view, url: response.url || url };
+    }
+  } catch {
+  }
+  if (slot.isCurrent()) win.location.assign(url);
+  return void 0;
+}
+export {
+  fetchBrowseDestination
+};

package/dist/browser/browse_frames.js

@@ -0,0 +1,62 @@
+// src/client/browse_frames.ts
+function expandedFrame(doc) {
+  return doc.querySelector(".browser-frame.is-expanded") ?? void 0;
+}
+function collapseFrame(doc, frame) {
+  doc.body.classList.remove("frame-expanded");
+  if (!frame) return;
+  frame.classList.remove("is-expanded");
+  const button = frame.querySelector(".browser-expand");
+  if (!button) return;
+  button.setAttribute("aria-expanded", "false");
+  button.setAttribute("aria-label", "Expand to a wider viewport");
+  button.setAttribute("title", "Expand to a wider viewport");
+}
+function expandFrame(doc, frame) {
+  frame.classList.add("is-expanded");
+  doc.body.classList.add("frame-expanded");
+  const button = frame.querySelector(".browser-expand");
+  if (!button) return;
+  button.setAttribute("aria-expanded", "true");
+  button.setAttribute("aria-label", "Collapse viewport");
+  button.setAttribute("title", "Collapse viewport");
+}
+function handleFrameClick(doc, target) {
+  const button = target.closest(".browser-expand");
+  if (button) {
+    const frame = button.closest(".browser-frame");
+    if (!frame) return true;
+    const current2 = expandedFrame(doc);
+    if (current2 && current2 !== frame) collapseFrame(doc, current2);
+    if (frame.classList.contains("is-expanded")) collapseFrame(doc, frame);
+    else expandFrame(doc, frame);
+    return true;
+  }
+  const current = expandedFrame(doc);
+  if (current && !target.closest(".browser-frame.is-expanded")) {
+    collapseFrame(doc, current);
+  }
+  return false;
+}
+function handleAddressClick(doc, target, copy) {
+  const address = target.closest(".browser-bar .address");
+  if (!address) return false;
+  const url = address.querySelector(".address-url") ?? address;
+  const text = url.textContent?.trim() ?? "";
+  if (text !== "") void copy(text);
+  const bar = address.parentElement;
+  if (!bar) return true;
+  bar.querySelector(".address-copied")?.remove();
+  const hint = doc.createElement("span");
+  hint.className = "address-copied";
+  hint.textContent = "URL copied";
+  bar.appendChild(hint);
+  setTimeout(() => hint.remove(), 1400);
+  return true;
+}
+export {
+  collapseFrame,
+  expandedFrame,
+  handleAddressClick,
+  handleFrameClick
+};

package/dist/browser/browse_links.js

@@ -0,0 +1,18 @@
+// src/client/browse_links.ts
+import { isEligibleBrowseLink, isSameBrowseDocument } from "./navigation.js";
+function browseLinkTarget(event, element, location) {
+  const anchor = element.closest("a");
+  if (!anchor || event.defaultPrevented) return void 0;
+  const url = new URL(anchor.href, location.href);
+  return isEligibleBrowseLink({
+    download: anchor.hasAttribute("download"),
+    modified: event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || event.button !== 0,
+    pathname: url.pathname,
+    sameOrigin: url.origin === location.origin,
+    samePageHash: isSameBrowseDocument(new URL(location.href), url) && url.hash !== "",
+    target: anchor.getAttribute("target") ?? ""
+  }) ? url.href : void 0;
+}
+export {
+  browseLinkTarget
+};

package/dist/browser/browse_navigation.js

@@ -0,0 +1,74 @@
+// src/client/browse_navigation.ts
+var NAV_DISCLOSURE_KEY = "mokly:nav-disclosure:v2";
+function isNavDisclosureKey(value) {
+  return value.startsWith("collection:") || value === "section:pages" || value === "section:components";
+}
+function isNavDisclosureClosed(closed, key) {
+  if (closed.has(key)) return true;
+  for (const prefix of ["collection:pages:", "collection:components:"]) {
+    if (key.startsWith(prefix)) {
+      return closed.has(`collection:${key.slice(prefix.length)}`);
+    }
+  }
+  return false;
+}
+var NavDisclosurePreference = class {
+  #storage;
+  #closed;
+  constructor(storage = void 0) {
+    this.#storage = storage;
+    this.#closed = this.read();
+  }
+  /** Apply an explicit stored preference without replacing server defaults. */
+  apply(doc) {
+    if (!this.#closed) return;
+    for (const group of navigationGroups(doc)) {
+      const key = group.getAttribute("data-nav-disclosure");
+      if (key && isNavDisclosureKey(key))
+        group.open = !isNavDisclosureClosed(this.#closed, key);
+    }
+  }
+  /** Capture and persist the current closed-group set. */
+  remember(doc) {
+    const closed = navigationGroups(doc).flatMap((group) => {
+      const key = group.getAttribute("data-nav-disclosure");
+      return !group.open && key && isNavDisclosureKey(key) ? [key] : [];
+    });
+    this.#closed = new Set(closed);
+    try {
+      this.#storage?.setItem(NAV_DISCLOSURE_KEY, JSON.stringify(closed));
+    } catch {
+    }
+  }
+  read() {
+    try {
+      const value = this.#storage?.getItem(NAV_DISCLOSURE_KEY);
+      if (value === null || value === void 0) return void 0;
+      const parsed = JSON.parse(value);
+      if (!Array.isArray(parsed) || !parsed.every((item) => typeof item === "string")) {
+        return void 0;
+      }
+      return new Set(parsed.filter(isNavDisclosureKey));
+    } catch {
+      return void 0;
+    }
+  }
+};
+function createBrowserNavPreference(win) {
+  try {
+    return new NavDisclosurePreference(win.localStorage);
+  } catch {
+    return new NavDisclosurePreference();
+  }
+}
+function navigationGroups(doc) {
+  return [
+    ...doc.querySelectorAll("details[data-nav-disclosure]")
+  ];
+}
+export {
+  NavDisclosurePreference,
+  createBrowserNavPreference,
+  isNavDisclosureClosed,
+  isNavDisclosureKey
+};

package/dist/browser/browse_navigation_state.js

@@ -0,0 +1,125 @@
+// src/client/browse_navigation_state.ts
+import {
+  parseSearchQuery,
+  queryConstrains,
+  rowMatchesQuery
+} from "./search_query.js";
+function navigationConstraintChanges(facts) {
+  const matchesQuery = rowMatchesQuery(parseSearchQuery(facts.query), facts);
+  return {
+    clearQuery: !matchesQuery,
+    showAll: facts.changedOnly && !facts.changed
+  };
+}
+function applyNavVisibility(doc, disclosure) {
+  const query = parseSearchQuery(
+    doc.querySelector("[data-mokly-search]")?.value ?? ""
+  );
+  const changedOnly = doc.querySelector('[data-filter="changed"]')?.getAttribute("aria-pressed") === "true";
+  const status = doc.querySelector("[data-changes-status]")?.dataset["changesStatus"];
+  const waiting = changedOnly && status !== void 0 && status !== "ready";
+  let visible = false;
+  for (const row of doc.querySelectorAll("[data-nav-row]")) {
+    const matchesFilter = changedOnly ? row.getAttribute("data-changed") === "true" : !row.hasAttribute("data-removed-page");
+    row.hidden = waiting || !(matchesFilter && rowMatchesQuery(query, navRowFacts(row)));
+    visible ||= !row.hidden;
+  }
+  const notice = doc.querySelector("[data-nav-status]");
+  if (notice) {
+    notice.hidden = !changedOnly || !waiting && visible;
+    const text = notice.querySelector("[data-nav-status-text]");
+    if (text && status === "ready")
+      text.textContent = queryConstrains(query) ? "No matching changes." : "No changes found.";
+  }
+  doc.querySelector("[data-mokly-nav-scroll]")?.setAttribute("aria-busy", String(waiting && status === "pending"));
+  applyGroupVisibility(doc, queryConstrains(query) || changedOnly, disclosure);
+}
+function selectAndRevealRoute(doc, pathname, baseHref, cause) {
+  const rows = [...doc.querySelectorAll("a[data-nav-row]")];
+  let active;
+  for (const row of rows) {
+    const matches = active === void 0 && new URL(row.getAttribute("href") ?? "", baseHref).pathname === pathname;
+    if (matches) {
+      active = row;
+      row.setAttribute("aria-current", "page");
+    } else {
+      row.removeAttribute("aria-current");
+    }
+  }
+  if (!active) return void 0;
+  const search = doc.querySelector("[data-mokly-search]");
+  const changedOnly = doc.querySelector('[data-filter="changed"]')?.getAttribute("aria-pressed") === "true";
+  const changes = navigationConstraintChanges({
+    changed: active.getAttribute("data-changed") === "true",
+    changedOnly,
+    query: search?.value ?? "",
+    ...navRowFacts(active)
+  });
+  if (changes.clearQuery && search) search.value = "";
+  if (changes.showAll) {
+    for (const option of doc.querySelectorAll("[data-filter]")) {
+      option.setAttribute(
+        "aria-pressed",
+        option.getAttribute("data-filter") === "all" ? "true" : "false"
+      );
+    }
+  }
+  applyNavVisibility(doc, "preserve");
+  let ancestor = active.closest(
+    "details[data-nav-disclosure]"
+  );
+  while (ancestor) {
+    const wasOpen = ancestor.open;
+    ancestor.open = true;
+    if (ancestor.dataset["filterOpen"] !== void 0 && (cause === "navigation" || !wasOpen)) {
+      ancestor.dataset["filterOpen"] = "1";
+    }
+    ancestor = ancestor.parentElement?.closest(
+      "details[data-nav-disclosure]"
+    ) ?? null;
+  }
+  active.scrollIntoView({ block: "nearest" });
+  return active;
+}
+function navRowFacts(row) {
+  const id = row.getAttribute("data-entry-id");
+  return {
+    ...id === null ? {} : { id },
+    route: row.getAttribute("data-route") ?? "",
+    tags: (row.getAttribute("data-tags") ?? "").split(/\s+/).filter((tag) => tag !== ""),
+    text: row.textContent ?? ""
+  };
+}
+function applyGroupVisibility(doc, filtering, disclosure) {
+  const groups = [
+    ...doc.querySelectorAll("details[data-nav-disclosure]")
+  ];
+  if (filtering) {
+    for (const group of groups) {
+      if (group.dataset["filterOpen"] === void 0) {
+        group.dataset["filterOpen"] = group.open ? "1" : "0";
+      }
+      if (disclosure === "reveal-matches") group.open = true;
+    }
+    for (const group of [...groups].reverse()) {
+      const visible = [
+        ...group.querySelectorAll("[data-nav-row]")
+      ].some((row) => !row.hidden);
+      group.hidden = !visible;
+    }
+    return;
+  }
+  for (const group of groups) {
+    const saved = group.dataset["filterOpen"];
+    if (saved !== void 0) {
+      group.open = saved === "1";
+      delete group.dataset["filterOpen"];
+    }
+    group.hidden = false;
+  }
+}
+export {
+  applyNavVisibility,
+  navigationConstraintChanges,
+  selectAndRevealRoute
+};

package/dist/browser/browse_recovery.js

@@ -0,0 +1,43 @@
+// src/client/browse_recovery.ts
+function parseBrowseRecoveryState(value) {
+  if (!record(value)) return void 0;
+  const changedOnly = value["changedOnly"];
+  const changesStatus = value["changesStatus"];
+  const colorScheme = value["colorScheme"];
+  const storedFilterBaselineClosedCollectionIds = value["filterBaselineClosedCollectionIds"];
+  const filterBaselineClosedCollectionIds = storedFilterBaselineClosedCollectionIds === void 0 ? null : storedFilterBaselineClosedCollectionIds;
+  const query = value["query"];
+  const viewport = value["viewport"];
+  if (typeof changedOnly !== "boolean" || changesStatus !== void 0 && changesStatus !== "pending" && changesStatus !== "ready" && changesStatus !== "unavailable" || !stringArray(value["closedCollectionIds"]) || colorScheme !== "dark" && colorScheme !== "light" || typeof value["detailsOpen"] !== "boolean" || typeof value["drawerOpen"] !== "boolean" || !nonNegativeNumber(value["navScroll"]) || typeof query !== "string" || !scrollRecord(value["regionScrolls"]) || viewport !== "both" && viewport !== "desktop" && viewport !== "mobile")
+    return void 0;
+  if (filterBaselineClosedCollectionIds !== null && (!stringArray(filterBaselineClosedCollectionIds) || !changedOnly && query.trim() === ""))
+    return void 0;
+  return {
+    changedOnly,
+    ...changesStatus ? { changesStatus } : {},
+    closedCollectionIds: [...new Set(value["closedCollectionIds"])],
+    colorScheme,
+    detailsOpen: value["detailsOpen"],
+    drawerOpen: value["drawerOpen"],
+    filterBaselineClosedCollectionIds: filterBaselineClosedCollectionIds === null ? null : [...new Set(filterBaselineClosedCollectionIds)],
+    navScroll: value["navScroll"],
+    query,
+    regionScrolls: { ...value["regionScrolls"] },
+    viewport
+  };
+}
+function nonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function scrollRecord(value) {
+  return record(value) && Object.values(value).every((entry) => nonNegativeNumber(entry));
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string" && item.length > 0);
+}
+export {
+  parseBrowseRecoveryState
+};

package/dist/browser/browse_refresh.js

@@ -0,0 +1,45 @@
+// src/client/browse_refresh.ts
+import { applyNavigationEvidence } from "./browse_evidence.js";
+import {
+  navigationPending,
+  readPageStamp,
+  waitForNavigation
+} from "./browse_update_state.js";
+import { workspaceEvidence } from "./workspace_updates.js";
+async function refreshBrowseEvidence(doc, win, version, signal) {
+  if (!readPageStamp(doc)) return;
+  while (!signal.aborted) {
+    await waitForNavigation(doc, signal);
+    const href = win.location.href;
+    const view = doc.querySelector("[data-mokly-view]")?.firstElementChild;
+    const response = await win.fetch(href, {
+      signal,
+      cache: "no-store",
+      headers: { accept: "text/html" }
+    });
+    const html = await response.text();
+    signal.throwIfAborted();
+    if (navigationPending(doc) || href !== win.location.href || view !== doc.querySelector("[data-mokly-view]")?.firstElementChild)
+      continue;
+    if (!response.ok || response.url !== href.split("#")[0]) return;
+    const next = new win.DOMParser().parseFromString(html, "text/html");
+    const current = readPageStamp(doc);
+    const stamp = readPageStamp(next);
+    if (!current || !stamp || stamp.content !== current.content || stamp.version < Math.max(version, current.version) || doc.querySelector("[data-mokly-view]")?.getAttribute("data-mokly-baseline") !== next.querySelector("[data-mokly-view]")?.getAttribute("data-mokly-baseline"))
+      return;
+    const evidence = workspaceEvidence(doc, next);
+    if (!evidence) return;
+    applyNavigationEvidence(doc, next);
+    evidence();
+    doc.documentElement.setAttribute(
+      "data-mokly-update-version",
+      String(stamp.version)
+    );
+    doc.dispatchEvent(new win.Event("mokly:evidence-updated"));
+    return stamp.version;
+  }
+  return void 0;
+}
+export {
+  refreshBrowseEvidence
+};