@mokly/mokly 0.8.0

package/dist/browser/workspace_events.js

@@ -0,0 +1,50 @@
+// src/client/workspace_events.ts
+function installWorkspaceEvents(root, win, signal, actions) {
+  const doc = root.ownerDocument;
+  root.addEventListener(
+    "click",
+    (event) => {
+      const target = event.target instanceof win.Element ? event.target : void 0;
+      if (target?.closest("[data-workspace-highlight]")) actions.highlight();
+      if (target?.closest("[data-workspace-scheme]")) actions.scheme();
+    },
+    { signal }
+  );
+  root.addEventListener(
+    "change",
+    (event) => {
+      const target = event.target;
+      if (!(target instanceof win.HTMLSelectElement)) return;
+      if (target.matches("[data-workspace-viewport]")) actions.viewport();
+      if (target.matches("[data-workspace-variant]"))
+        actions.variant(target.value);
+    },
+    { signal }
+  );
+  doc.addEventListener(
+    "keydown",
+    (event) => {
+      if (event.key === "Escape") actions.escape(event);
+    },
+    { signal }
+  );
+  for (const frame of root.querySelectorAll("iframe[data-workspace-frame]"))
+    frame.addEventListener("load", actions.refresh, { signal });
+  const mutations = new MutationObserver(actions.refresh);
+  mutations.observe(doc.body, {
+    attributes: true,
+    attributeFilter: ["data-mokly-color-scheme"]
+  });
+  const stage = root.querySelector("[data-mokly-stage]");
+  if (stage)
+    mutations.observe(stage, {
+      attributes: true,
+      attributeFilter: ["data-viewport"]
+    });
+  signal.addEventListener("abort", () => mutations.disconnect(), {
+    once: true
+  });
+}
+export {
+  installWorkspaceEvents
+};

package/dist/browser/workspace_evidence.js

@@ -0,0 +1,207 @@
+// src/client/workspace_evidence.ts
+import { element } from "./inspector_panels.js";
+
+// src/components/data.ts
+var DataBudget = class {
+  constructor(depthLimit = 64) {
+    this.depthLimit = depthLimit;
+  }
+  depthLimit;
+  nodes = 0;
+  visit(depth, at) {
+    if (depth > this.depthLimit || ++this.nodes > 1e4)
+      invalidData(at, "validation limit exceeded");
+  }
+};
+var ComponentValidationError = class extends Error {
+  constructor(path, detail) {
+    super(`[mokly/components] ${path}: ${detail}`);
+    this.path = path;
+    this.detail = detail;
+    this.name = "ComponentValidationError";
+  }
+  path;
+  detail;
+};
+function invalidData(at, message) {
+  throw new ComponentValidationError(at, message);
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function plainKeys(value, at) {
+  if (!record(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+    invalidData(at, "expected a plain object");
+  const keys = [];
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string") invalidData(at, "symbol keys are unsupported");
+    if (["__proto__", "constructor", "prototype"].includes(key))
+      invalidData(`${at}.${key}`, "reserved property name");
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor.enumerable || !("value" in descriptor))
+      invalidData(
+        `${at}.${key}`,
+        "only enumerable data properties are supported"
+      );
+    keys.push(key);
+  }
+  return keys.sort();
+}
+function denseArray(value, at) {
+  if (!Array.isArray(value)) invalidData(at, "expected an array");
+  if (Reflect.ownKeys(value).length !== value.length + 1)
+    invalidData(at, "expected a dense array without extra properties");
+  for (let i = 0; i < value.length; i++) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
+    if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+      invalidData(`${at}[${i}]`, "expected an array data element");
+  }
+}
+
+// src/components/codec.ts
+function decodeProps(value) {
+  const budget = new DataBudget();
+  budget.visit(0, "$props");
+  return Object.fromEntries(
+    plainKeys(value, "$props").map((key) => [
+      key,
+      decode(
+        value[key],
+        `$props.${key}`,
+        budget,
+        1
+      )
+    ])
+  );
+}
+function decode(value, at, budget, depth) {
+  budget.visit(depth, at);
+  denseArray(value, at);
+  const [kind, payload] = value;
+  if (kind === "null" && value.length === 1) return null;
+  if (value.length !== 2) invalidData(at, "invalid wire tuple length");
+  if (kind === "string" && typeof payload === "string") return payload;
+  if (kind === "boolean" && typeof payload === "boolean") return payload;
+  if (kind === "number" && typeof payload === "string") {
+    const number = Number(payload);
+    if (Number.isFinite(number) && (Object.is(number, -0) ? "-0" : String(number)) === payload)
+      return number;
+    invalidData(at, "noncanonical number");
+  }
+  if (kind === "array") {
+    denseArray(payload, at);
+    return payload.map(
+      (item, i) => decode(item, `${at}[${i}]`, budget, depth + 1)
+    );
+  }
+  if (kind === "object") {
+    denseArray(payload, at);
+    const object = {};
+    let previous;
+    for (const pair of payload) {
+      denseArray(pair, at);
+      if (pair.length !== 2 || typeof pair[0] !== "string")
+        invalidData(at, "invalid object entry");
+      const key = pair[0];
+      if (previous !== void 0 && previous >= key)
+        invalidData(at, "object keys must be unique and sorted");
+      plainKeys({ [key]: null }, at);
+      object[key] = decode(pair[1], `${at}.${key}`, budget, depth + 1);
+      previous = key;
+    }
+    return object;
+  }
+  return invalidData(at, "unknown or malformed wire value");
+}
+
+// src/client/workspace_evidence.ts
+import { propText } from "./prop_display.js";
+function renderWorkspaceEvidence(panel, data, variantId) {
+  const doc = panel.ownerDocument;
+  panel.replaceChildren();
+  panel.hidden = data.status === void 0;
+  if (panel.hidden) return;
+  panel.append(
+    element(doc, "h3", "Comparison details"),
+    element(doc, "p", `Compared with the branch point on ${data.base}.`)
+  );
+  const labels = {
+    added: "Added to this branch.",
+    removed: "Removed on this branch.",
+    material: "Rendered content changed.",
+    inputs: "Supplied props or slots changed.",
+    structure: "Component instances changed.",
+    metadata: "Page details or saved examples changed."
+  };
+  for (const component of data.relatedComponents) {
+    const link = element(doc, "a", component.title);
+    link.href = `/view/${component.route.split("/").map(encodeURIComponent).join("/")}`;
+    const row = element(doc, "p", "Changed component: ");
+    row.append(link);
+    panel.append(row);
+  }
+  for (const change of data.inputChanges.filter(
+    (item) => item.variantId === variantId
+  )) {
+    panel.append(
+      element(
+        doc,
+        "h3",
+        `${change.title} \xB7 ${change.instanceId} \xB7 ${change.viewport} \xB7 ${change.colorScheme}`
+      )
+    );
+    for (const [label, props] of [
+      ["Before", change.before],
+      ["Current", change.after]
+    ])
+      panel.append(
+        element(doc, "p", label),
+        element(doc, "pre", propText(decodeProps(props)))
+      );
+  }
+  for (const reason of data.change?.reasons ?? [])
+    panel.append(
+      element(
+        doc,
+        "p",
+        reason.kind === "dependency" ? `Related file changed: ${reason.path}` : reason.kind === "screen" ? `A screen in this flow changed: ${reason.route}` : labels[reason.kind]
+      )
+    );
+  if (data.comparison) {
+    const views = "variants" in data.comparison ? data.comparison.variants.find((item) => item.id === variantId)?.views ?? [] : data.comparison.views;
+    const ignored = [...new Set(views.flatMap((view) => view.ignoredIds))];
+    if (ignored.length)
+      panel.append(
+        element(doc, "p", `Excluded content: ${ignored.join(", ")}.`)
+      );
+    if (!data.change && views.some((view) => view.state === "changed"))
+      panel.append(
+        element(
+          doc,
+          "p",
+          "Shared component changes affect this preview. This page has no independent entry in Changes."
+        )
+      );
+    if ("variants" in data.comparison) {
+      const variant = data.comparison.variants.find(
+        (item) => item.id === variantId
+      );
+      if (variant?.before && variant.after && JSON.stringify(variant.before.props) !== JSON.stringify(variant.after.props)) {
+        panel.append(element(doc, "h3", "Saved props changed"));
+        for (const [title, props] of [
+          ["Before", variant.before.props],
+          ["Current", variant.after.props]
+        ])
+          panel.append(
+            element(doc, "p", title),
+            element(doc, "pre", propText(decodeProps(props)))
+          );
+      }
+    }
+  }
+  if (data.status === "Unmodified")
+    panel.append(element(doc, "p", "No changes to this saved view."));
+}
+export {
+  renderWorkspaceEvidence
+};

package/dist/browser/workspace_loading.js

@@ -0,0 +1,26 @@
+// src/client/workspace_loading.ts
+function workspaceLoader(data, signal, changed) {
+  const requested = /* @__PURE__ */ new Set();
+  return (views) => {
+    if (!data.previewGeneration || signal.aborted) return;
+    for (const view of views) {
+      if (view.usage || requested.has(view.path)) continue;
+      requested.add(view.path);
+      const url = `/__mokly/views/${view.path.split("/").map(encodeURIComponent).join("/")}?generation=${data.previewGeneration}`;
+      void fetch(url, { signal }).then(async (response) => {
+        if (!response.ok) return;
+        const result = await response.json();
+        if (signal.aborted || result.generation !== data.previewGeneration || result.route !== view.path || result.usage?.viewport !== view.viewport || result.usage.colorScheme !== view.colorScheme)
+          return;
+        data.views = data.views.map(
+          (previous) => previous.path === view.path ? { ...previous, usage: result.usage } : previous
+        );
+        changed();
+      }).catch(() => {
+      });
+    }
+  };
+}
+export {
+  workspaceLoader
+};

package/dist/browser/workspace_preview.js

@@ -0,0 +1,88 @@
+// src/client/workspace_preview.ts
+import { currentColorScheme, currentViewport } from "./browse_state.js";
+import { authenticateRanges } from "./component_geometry.js";
+import { element } from "./inspector_panels.js";
+function workspaceViews(doc, data, variantId) {
+  const views = data.views.filter((view) => view.variantId === variantId);
+  const scheme = currentColorScheme(doc);
+  const viewport = currentViewport(doc);
+  return ["mobile", "desktop"].filter((size) => viewport === "both" || viewport === size).flatMap((size) => {
+    const view = views.find(
+      (item) => item.viewport === size && item.colorScheme === scheme
+    ) ?? views.find(
+      (item) => item.viewport === size && item.colorScheme === "light"
+    );
+    return view ? [view] : [];
+  });
+}
+function workspaceFrames(root, views) {
+  return views.flatMap((value) => {
+    const frame = root.querySelector(
+      `iframe[data-workspace-frame="${value.viewport}"]`
+    );
+    return frame && value.usage && authenticateRanges(frame, value.path, value.usage) ? [{ frame, path: value.path, usage: value.usage }] : [];
+  });
+}
+function revealWorkspaceInstance(root, viewport, view, key) {
+  const frame = root.querySelector(
+    `iframe[data-workspace-frame="${viewport}"]`
+  );
+  if (!frame || !view?.usage) return;
+  const range = authenticateRanges(frame, view.path, view.usage)?.ranges.get(
+    key
+  )?.[0];
+  const node = range?.startContainer.childNodes[range.startOffset];
+  const target = node?.nodeType === 1 ? node : node?.parentElement;
+  target?.scrollIntoView({ block: "nearest", inline: "nearest" });
+}
+function highlightUnavailable(root, views, frames, invalidSelection) {
+  const mode = root.querySelector('[data-diff-mode][aria-pressed="true"]')?.getAttribute("data-diff-mode");
+  if (mode && mode !== "current")
+    return "Highlighting is available in Current.";
+  if (invalidSelection) return "This preview is unavailable.";
+  if (!views.some((view) => view.usage))
+    return "Component inspection is unavailable for this view.";
+  if (!views.some((view) => view.usage?.instances.length))
+    return "No registered components are used in this view.";
+  if (frames.length !== views.length) {
+    const invalid = views.some((view) => {
+      const frame = root.querySelector(
+        `iframe[data-workspace-frame="${view.viewport}"]`
+      );
+      try {
+        return frame?.contentDocument?.readyState === "complete" && decodeURIComponent(frame.contentWindow.location.pathname).replace(
+          /\.html$/,
+          ""
+        ) === `/static/${view.path}`.replace(/\.html$/, "") && !frames.some((item) => item.frame === frame);
+      } catch {
+        return true;
+      }
+    });
+    return invalid ? "Component inspection is unavailable for this view." : "Waiting for the component preview.";
+  }
+}
+function renderViewContexts(panel, views, activeViewport, select) {
+  if (views.length < 2) return;
+  for (const context of [...views].reverse()) {
+    const button = element(
+      panel.ownerDocument,
+      "button",
+      `${context.viewport === "mobile" ? "Mobile" : "Desktop"} \xB7 ${context.colorScheme}`
+    );
+    button.type = "button";
+    button.className = "mbk-instance-context mbk-chip";
+    button.setAttribute(
+      "aria-pressed",
+      String(context.viewport === activeViewport)
+    );
+    button.addEventListener("click", () => select(context.viewport));
+    panel.prepend(button);
+  }
+}
+export {
+  highlightUnavailable,
+  renderViewContexts,
+  revealWorkspaceInstance,
+  workspaceFrames,
+  workspaceViews
+};

package/dist/browser/workspace_updates.js

@@ -0,0 +1,179 @@
+// src/client/workspace_updates.ts
+import { copyChildren } from "./browse_evidence.js";
+import { captureRegionScrolls, restoreRegionScrolls } from "./browse_state.js";
+import { renderUsage } from "./inspector_panels.js";
+import { renderWorkspaceEvidence } from "./workspace_evidence.js";
+import { applyVariant, selectedVariant } from "./workspace_variants.js";
+function workspaceEvidence(doc, next) {
+  const root = doc.querySelector("[data-workspace]");
+  const incoming = next.querySelector("[data-workspace-data]")?.textContent;
+  if (!root && !incoming) return () => {
+  };
+  if (!root || !incoming) return;
+  try {
+    const previous = JSON.parse(
+      root.querySelector("[data-workspace-data]")?.textContent ?? ""
+    );
+    const data = JSON.parse(incoming);
+    if (data.entry.id !== previous.entry.id || data.entry.kind !== previous.entry.kind || data.removed !== previous.removed)
+      return;
+    return () => root.dispatchEvent(
+      new doc.defaultView.CustomEvent("mokly:workspace-evidence", {
+        detail: data
+      })
+    );
+  } catch {
+    return void 0;
+  }
+}
+function mergeWorkspaceEvidence(current, next) {
+  const views = current.views;
+  const generation = current.previewGeneration;
+  for (const key of [
+    "status",
+    "change",
+    "comparison",
+    "usageComplete",
+    "previewGeneration",
+    "renderCapability"
+  ])
+    delete current[key];
+  Object.assign(current, next);
+  if (generation && generation === next.previewGeneration) {
+    current.views = next.views.map((view) => {
+      const retained = views.find(
+        (previous) => previous.path === view.path
+      )?.usage;
+      const merged = { ...view };
+      delete merged.usage;
+      return retained ? { ...merged, usage: retained } : merged;
+    });
+  }
+}
+function updateWorkspaceEvidence(root, data, search) {
+  const doc = root.ownerDocument;
+  const scrolls = captureRegionScrolls(doc);
+  const selected = selectedVariant(data, search);
+  const selector = root.querySelector(
+    "[data-workspace-variant]"
+  );
+  if (selector) {
+    const remaining = new Map(
+      data.variants.map((variant) => [variant.value.id, variant])
+    );
+    for (const option of [...selector.options]) {
+      const variant = remaining.get(option.value);
+      if (!variant) option.remove();
+      else {
+        option.textContent = `${variant.value.title}${variant.removed ? " \xB7 Removed" : ""}`;
+        remaining.delete(option.value);
+      }
+    }
+    for (const variant of remaining.values()) {
+      const option = doc.createElement("option");
+      option.value = variant.value.id;
+      option.textContent = `${variant.value.title}${variant.removed ? " \xB7 Removed" : ""}`;
+      selector.append(option);
+    }
+  }
+  applyVariant(root, data, selected.variant, selected.error, {
+    preservePreview: true
+  });
+  const usage = root.querySelector(
+    '[data-inspector-panel="usage"]'
+  );
+  if (usage) updateUsage(usage, data);
+  const evidence = doc.createElement("div");
+  renderWorkspaceEvidence(evidence, data, selected.variant?.value.id);
+  const panel = root.querySelector("[data-workspace-evidence]");
+  copyChildren(panel, evidence);
+  if (panel) panel.hidden = evidence.hidden;
+  const json = root.querySelector("[data-workspace-data]");
+  if (json) json.textContent = JSON.stringify(data);
+  restoreRegionScrolls(doc, scrolls);
+  return selected;
+}
+function updateUsage(panel, data) {
+  const expected = panel.ownerDocument.createElement("div");
+  renderUsage(expected, data);
+  const sections = new Map(
+    [...panel.children].map((section) => [usageKey(section), section])
+  );
+  let position = panel.firstElementChild;
+  for (const next of [...expected.children]) {
+    const key = usageKey(next);
+    const current = sections.get(key);
+    if (current?.tagName === next.tagName) {
+      if (current instanceof HTMLElement && next instanceof HTMLElement)
+        updateUsageSection(current, next);
+      sections.delete(key);
+      if (current === position) position = position.nextElementSibling;
+      else panel.insertBefore(current, position);
+    } else {
+      const inserted = panel.ownerDocument.importNode(next, true);
+      panel.insertBefore(inserted, position);
+    }
+  }
+  for (const stale of sections.values()) stale.remove();
+}
+function updateUsageSection(current, next) {
+  const currentList = current.querySelector(
+    ":scope > .mbk-usage-list"
+  );
+  const nextList = next.querySelector(
+    ":scope > .mbk-usage-list"
+  );
+  if (!currentList || !nextList) {
+    copyChildren(current, next);
+    return;
+  }
+  const heading = current.querySelector(":scope > h3");
+  const nextHeading = next.querySelector(":scope > h3");
+  if (heading && nextHeading && heading.textContent !== nextHeading.textContent)
+    heading.textContent = nextHeading.textContent;
+  updateUsageLinks(currentList, nextList);
+}
+function updateUsageLinks(current, next) {
+  const rows = new Map(
+    [...current.children].map((row) => [usageKey(row), row])
+  );
+  let position = current.firstElementChild;
+  for (const nextRow of [...next.children]) {
+    const key = usageKey(nextRow);
+    const row = rows.get(key);
+    if (row instanceof HTMLLIElement && nextRow instanceof HTMLLIElement) {
+      updateUsageLink(row, nextRow);
+      rows.delete(key);
+      if (row === position) position = position.nextElementSibling;
+      else current.insertBefore(row, position);
+    } else {
+      const inserted = current.ownerDocument.importNode(nextRow, true);
+      current.insertBefore(inserted, position);
+    }
+  }
+  for (const stale of rows.values()) stale.remove();
+}
+function updateUsageLink(current, next) {
+  const link = current.querySelector(":scope > a");
+  const nextLink = next.querySelector(":scope > a");
+  const details = current.querySelector(":scope > small");
+  const nextDetails = next.querySelector(":scope > small");
+  if (!link || !nextLink || !details || !nextDetails) {
+    copyChildren(current, next);
+    return;
+  }
+  if (link.getAttribute("href") !== nextLink.getAttribute("href"))
+    link.setAttribute("href", nextLink.getAttribute("href"));
+  if (link.textContent !== nextLink.textContent)
+    link.textContent = nextLink.textContent;
+  if (details.textContent !== nextDetails.textContent)
+    details.textContent = nextDetails.textContent;
+}
+function usageKey(element) {
+  return element.getAttribute("data-usage-section") ?? element.getAttribute("data-usage-link") ?? "";
+}
+export {
+  mergeWorkspaceEvidence,
+  updateWorkspaceEvidence,
+  workspaceEvidence
+};

package/dist/browser/workspace_variants.js

@@ -0,0 +1,84 @@
+// src/client/workspace_variants.ts
+import { currentColorScheme, setColorScheme } from "./browse_state.js";
+import { element } from "./inspector_panels.js";
+function selectedVariant(data, search) {
+  if (data.entry.kind !== "component")
+    return { comparisonEligible: data.comparisonEligible };
+  const ids = new URLSearchParams(search).getAll("variant");
+  if (ids.length > 1)
+    return {
+      error: "Choose one saved variant.",
+      comparisonEligible: false
+    };
+  const variant = ids.length ? data.variants.find((item) => item.value.id === ids[0]) : data.variants[0];
+  return variant ? { variant, comparisonEligible: variant.comparisonEligible } : {
+    error: "This saved variant is unavailable. Choose another variant.",
+    comparisonEligible: false
+  };
+}
+function selectedComparisonEligible(data, variant, error) {
+  return !error && (data.entry.kind === "component" ? variant?.comparisonEligible ?? false : data.comparisonEligible);
+}
+function applyVariant(root, data, variant, error, options = {}) {
+  const doc = root.ownerDocument;
+  const message = root.querySelector("[data-workspace-error]");
+  message.hidden = !error;
+  message.textContent = error ?? "";
+  const selector = root.querySelector(
+    "[data-workspace-variant]"
+  );
+  if (selector) selector.value = variant?.value.id ?? "";
+  const diff = root.querySelector("[data-diff-screen]");
+  if (diff) diff.dataset["diffVariant"] = variant?.value.id ?? "";
+  const title = root.querySelector("[data-workspace-status]");
+  if (data.status) title.dataset["status"] = data.status;
+  else delete title.dataset["status"];
+  title.textContent = data.status ?? "";
+  title.hidden = data.status === void 0;
+  const variantStatus = root.querySelector(
+    "[data-workspace-variant-status]"
+  );
+  if (variantStatus) {
+    variantStatus.hidden = !variant?.status;
+    variantStatus.textContent = variant?.status ? `${variant.value.title} \xB7 ${variant.status}` : "";
+  }
+  const eligible = selectedComparisonEligible(data, variant, error);
+  const toolbar = root.querySelector(".mbk-diff-toolbar");
+  if (toolbar) {
+    if (!eligible)
+      root.querySelector(
+        '[data-diff-mode="current"][aria-pressed="false"]'
+      )?.click();
+    toolbar.hidden = !eligible;
+  }
+  const preview = root.querySelector("[data-current-screen]") ?? root.querySelector("[data-workspace-preview]");
+  let empty = preview.querySelector("[data-workspace-empty]");
+  if (!empty) {
+    empty = element(doc, "div");
+    empty.className = "mbk-empty";
+    empty.dataset["workspaceEmpty"] = "";
+    preview.append(empty);
+  }
+  empty.hidden = !error && !variant?.removed;
+  empty.textContent = error ? "Choose a saved variant to see its preview." : "This variant was removed. Select a comparison to see its previous version.";
+  const stage = preview.querySelector("[data-mokly-stage]");
+  if (stage) stage.hidden = Boolean(error || variant?.removed);
+  if (variant && !variant.removed && !options.preservePreview) {
+    for (const frame of root.querySelectorAll(
+      "iframe[data-workspace-frame]"
+    )) {
+      const viewport = frame.dataset["workspaceFrame"] === "mobile" ? "mobile" : "desktop";
+      const path = (route) => `/static/${route.split("/").map(encodeURIComponent).join("/")}`;
+      frame.dataset["fragmentLight"] = path(variant.value.fragments[viewport]);
+      const dark = variant.value.darkFragments?.[viewport];
+      if (dark) frame.dataset["fragmentDark"] = path(dark);
+      else delete frame.dataset["fragmentDark"];
+      frame.title = `${data.entry.title} \xB7 ${variant.value.title} \u2014 ${viewport}`;
+    }
+    setColorScheme(doc, currentColorScheme(doc));
+  }
+}
+export {
+  applyVariant,
+  selectedVariant
+};

package/dist/build/check.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedConfig } from "../config/types.js";
+import type { Compilation } from "./compile.js";
+/** Compare expected bytes with committed output without writing anything. */
+export declare function checkCompilation(compilation: Compilation, config: ResolvedConfig): void;
+//# sourceMappingURL=check.d.ts.map

package/dist/build/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/build/check.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,cAAc,GACrB,IAAI,CA0BN"}

package/dist/build/check.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import path from "node:path";
+import { MoklyError } from "../errors.js";
+import { pendingGeneratedOrphanRoutes } from "./ownership.js";
+/** Compare expected bytes with committed output without writing anything. */
+export function checkCompilation(compilation, config) {
+    config = { ...config, sourceFiles: compilation.manifest.sourceFiles };
+    const missing = [];
+    const stale = [];
+    for (const [route, expected] of compilation.outputs) {
+        const target = path.join(config.mockupsDir, route);
+        if (!fs.existsSync(target)) {
+            missing.push(route);
+        }
+        else if (fs.readFileSync(target, "utf8") !== expected) {
+            stale.push(route);
+        }
+    }
+    const orphan = pendingGeneratedOrphanRoutes(config, compilation.outputs.keys());
+    if (missing.length === 0 && stale.length === 0 && orphan.length === 0)
+        return;
+    const groups = [
+        formatGroup("missing generated files", missing),
+        formatGroup("stale generated files", stale),
+        formatGroup("orphan generated files", orphan),
+    ].filter(Boolean);
+    throw new MoklyError("build-invalid", `committed output does not match source; run mokly build:\n${groups.join("\n")}`);
+}
+function formatGroup(title, routes) {
+    if (routes.length === 0)
+        return "";
+    return `${title}:\n${[...routes]
+        .sort()
+        .map((route) => `  - ${route}`)
+        .join("\n")}`;
+}
+//# sourceMappingURL=check.js.map