@davmash/bygone 0.9.8 → 0.10.1

package/out/deepLink.js

@@ -0,0 +1,167 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/deepLink.ts
+var deepLink_exports = {};
+__export(deepLink_exports, {
+  authoredModeTour: () => authoredModeTour,
+  parseDeepLink: () => parseDeepLink,
+  parseDocumentFocus: () => parseDocumentFocus,
+  parseDocumentFragment: () => parseDocumentFragment,
+  resolveDocumentFocus: () => resolveDocumentFocus,
+  serializeDeepLink: () => serializeDeepLink,
+  serializeDocumentFragment: () => serializeDocumentFragment,
+  validateRelativePath: () => validateRelativePath
+});
+module.exports = __toCommonJS(deepLink_exports);
+var oidPattern = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+var focusFields = ["part", "chapter", "scene", "step"];
+function required(params, key) {
+  const value = params.get(key);
+  if (!value || value.length > 4096 || /[\u0000-\u001f\u007f]/.test(value)) throw new Error(`Invalid or missing ${key}.`);
+  return value;
+}
+function validateRelativePath(value) {
+  if (!value || value.startsWith("/") || value.includes("\\") || value.includes("\0") || value.split("/").some((part) => !part || part === "." || part === "..")) {
+    throw new Error("Expected a repository-relative path without traversal.");
+  }
+  return value;
+}
+function validateFields(params, allowed, repeated = []) {
+  for (const key of params.keys()) {
+    if (!allowed.includes(key)) throw new Error(`Unsupported link field: ${key}.`);
+    if (!repeated.includes(key) && params.getAll(key).length !== 1) throw new Error(`Duplicate link field: ${key}.`);
+  }
+}
+function validateLocalFileUrl(value) {
+  const local = new URL(value);
+  if (local.protocol !== "file:" || local.hostname || local.search || local.hash || local.username || local.password || !local.pathname.startsWith("/")) throw new Error("Links require a local file URL.");
+  return value;
+}
+function parseDocumentFocus(params) {
+  const part = required(params, "part");
+  const fields = part === "title" || part === "conclusion" ? [] : part === "chapter" ? ["chapter"] : part === "scene" ? ["scene"] : part === "step" ? ["scene", "step"] : null;
+  if (!fields) throw new Error(`Unsupported document part: ${part}.`);
+  for (const key of focusFields.filter((key2) => key2 !== "part")) {
+    if (params.has(key) && !fields.includes(key)) throw new Error(`${key} is incompatible with ${part}.`);
+  }
+  return Object.fromEntries([["part", part], ...fields.map((key) => [key, required(params, key)])]);
+}
+function parseDeepLink(value) {
+  if (value.length > 16384 || /%(?![\da-f]{2})/i.test(value)) throw new Error("Invalid or oversized Bygone link.");
+  const url = new URL(value);
+  if (url.protocol !== "bygone:" || url.hostname !== "open" || url.pathname !== "/v1" || url.username || url.password || url.port || url.hash) throw new Error("Unsupported Bygone link address or version.");
+  const p = url.searchParams;
+  const kind = required(p, "kind");
+  const repo = validateLocalFileUrl(required(p, "repo"));
+  if (kind === "tour") {
+    validateFields(p, ["kind", "repo", "tour", "mode", ...focusFields]);
+    const mode = required(p, "mode");
+    if (mode !== "historical" && mode !== "deconstructed") throw new Error("Unsupported authored tour mode.");
+    const tour = required(p, "tour");
+    if (/^[a-z][a-z\d+.-]*:/i.test(tour)) validateLocalFileUrl(tour);
+    else validateRelativePath(tour);
+    return { kind, repo, tour, mode, focus: parseDocumentFocus(p) };
+  }
+  if (kind !== "compare") throw new Error("Unsupported Bygone link kind.");
+  validateFields(p, ["kind", "repo", "rev", "file", "revision", "line"], ["rev"]);
+  const revisions = p.getAll("rev");
+  if (revisions.length !== 2 || revisions.some((oid) => !oidPattern.test(oid)) || revisions[0] === revisions[1]) {
+    throw new Error("Comparison links require two distinct full commit IDs in order.");
+  }
+  const file = p.has("file") ? validateRelativePath(required(p, "file")) : void 0;
+  const revision = p.has("revision") ? required(p, "revision") : void 0;
+  if (revision && (!file || !revisions.includes(revision))) throw new Error("Code focus requires a file and one of the comparison revisions.");
+  const line = p.has("line") ? Number(required(p, "line")) : void 0;
+  if (line !== void 0 && (!revision || !Number.isSafeInteger(line) || line < 1)) throw new Error("Line focus requires a revision and positive line number.");
+  return { kind, repo, revisions, ...file ? { file } : {}, ...revision ? { revision } : {}, ...line !== void 0 ? { line } : {} };
+}
+function serializeDeepLink(link) {
+  const url = new URL("bygone://open/v1");
+  url.searchParams.set("kind", link.kind);
+  url.searchParams.set("repo", link.repo);
+  if (link.kind === "tour") {
+    url.searchParams.set("tour", link.tour);
+    url.searchParams.set("mode", link.mode);
+    for (const [key, value] of Object.entries(link.focus)) url.searchParams.set(key, value);
+  } else {
+    for (const revision of link.revisions) url.searchParams.append("rev", revision);
+    for (const key of ["file", "revision", "line"]) if (link[key] !== void 0) url.searchParams.set(key, String(link[key]));
+  }
+  parseDeepLink(url.href);
+  return url.href;
+}
+function authoredModeTour(tour, mode) {
+  if (tour.tours) {
+    const result = tour.tours[mode];
+    if (!result) throw new Error(`This tour has no ${mode} mode.`);
+    return result;
+  }
+  const deconstructed = tour.scenes.some((scene) => scene.kind === "deconstructed-diff");
+  if (mode === "deconstructed" && deconstructed) return tour;
+  if (mode === "historical" && !deconstructed) return tour;
+  if (mode === "historical" && tour.zoom?.final.scenes.some((scene) => scene.kind === "walkthrough")) return tour.zoom.final;
+  throw new Error(`This tour has no ${mode} mode.`);
+}
+function resolveDocumentFocus(tour, mode, focus) {
+  const selected = authoredModeTour(tour, mode);
+  if (focus.part === "title") return { key: "title", sceneIndex: 0, stepIndex: 0 };
+  if (focus.part === "conclusion") {
+    if (!selected.conclusion) throw new Error("Conclusion is unavailable in this tour mode.");
+    return { key: "conclusion", sceneIndex: -1, stepIndex: 0 };
+  }
+  if (focus.part === "chapter") {
+    const chapter = selected.chapters.find((item) => item.id === focus.chapter);
+    const sceneIndex2 = selected.scenes.findIndex((scene2) => scene2.id === chapter?.sceneIds[0]);
+    if (!chapter || sceneIndex2 < 0) throw new Error(`Chapter is unavailable: ${focus.chapter}.`);
+    return { key: chapter.summary?.trim() ? `chapter:${chapter.id}` : `scene:${selected.scenes[sceneIndex2].id}`, sceneIndex: sceneIndex2, stepIndex: 0 };
+  }
+  const sceneIndex = selected.scenes.findIndex((scene2) => scene2.id === focus.scene);
+  if (sceneIndex < 0) throw new Error(`Scene is unavailable: ${focus.scene}.`);
+  const scene = selected.scenes[sceneIndex];
+  if (focus.part === "scene") return { key: `scene:${scene.id}`, sceneIndex, stepIndex: 0 };
+  const stepIndex = "steps" in scene ? scene.steps.findIndex((step) => step.id === focus.step) : -1;
+  if (stepIndex < 0) throw new Error(`Step is unavailable: ${focus.step}.`);
+  return { key: `step:${scene.id}:${focus.step}`, sceneIndex, stepIndex };
+}
+function serializeDocumentFragment(mode, focus) {
+  return `#${new URLSearchParams({ location: "1", mode, ...focus })}`;
+}
+function parseDocumentFragment(hash) {
+  if (!hash) return null;
+  if (hash.length > 16384 || /%(?![\da-f]{2})/i.test(hash)) throw new Error("Oversized tour location.");
+  const p = new URLSearchParams(hash.replace(/^#/, ""));
+  validateFields(p, ["location", "mode", ...focusFields]);
+  if (p.get("location") !== "1") throw new Error("Unsupported tour location version.");
+  const mode = p.get("mode");
+  if (mode !== "historical" && mode !== "deconstructed") throw new Error("Unsupported tour location mode.");
+  return { mode, focus: parseDocumentFocus(p) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  authoredModeTour,
+  parseDeepLink,
+  parseDocumentFocus,
+  parseDocumentFragment,
+  resolveDocumentFocus,
+  serializeDeepLink,
+  serializeDocumentFragment,
+  validateRelativePath
+});
+//# sourceMappingURL=deepLink.js.map

package/out/historyDirectory.js

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/historyDirectory.ts
+var historyDirectory_exports = {};
+__export(historyDirectory_exports, {
+  buildHistoryDirectoryEntries: () => buildHistoryDirectoryEntries
+});
+module.exports = __toCommonJS(historyDirectory_exports);
+function buildHistoryDirectoryEntries(paths, inventories) {
+  const rows = /* @__PURE__ */ new Map();
+  const trees = inventories.map((files) => {
+    const tree = new Set(files);
+    for (const file of files) {
+      const parts = file.split("/");
+      for (let depth = 1; depth < parts.length; depth++) tree.add(parts.slice(0, depth).join("/"));
+    }
+    return tree;
+  });
+  for (const file of paths) {
+    const parts = file.split("/");
+    for (let depth = 0; depth < parts.length; depth++) {
+      const relativePath = parts.slice(0, depth + 1).join("/");
+      if (rows.has(relativePath)) continue;
+      const sides = trees.map((tree) => tree.has(relativePath));
+      rows.set(relativePath, {
+        relativePath,
+        displayName: parts[depth],
+        depth,
+        isDirectory: depth < parts.length - 1,
+        sides,
+        status: sides.every(Boolean) ? "modified" : sides.length !== 2 ? "partial" : sides[0] ? "left-only" : "right-only"
+      });
+    }
+  }
+  return [...rows.values()].sort((a, b) => {
+    const left = a.relativePath.split("/");
+    const right = b.relativePath.split("/");
+    for (let i = 0; i < Math.min(left.length, right.length); i++) {
+      if (left[i] === right[i]) continue;
+      return Number(i < right.length - 1 || b.isDirectory) - Number(i < left.length - 1 || a.isDirectory) || left[i].localeCompare(right[i]);
+    }
+    return left.length - right.length;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildHistoryDirectoryEntries
+});
+//# sourceMappingURL=historyDirectory.js.map