@bendyline/docblocks 2.6.1 → 2.7.0

package/dist/chunk-R2JX5N3F.js

@@ -0,0 +1,382 @@
+// src/workspace-settings/catalog.ts
+var CATALOG_GENERATOR = "docblocks-workspace-catalog";
+var CATALOG_FORMAT_VERSION = 1;
+var CATALOG_LIMITS = {
+  maxOutlineEntries: 100,
+  maxOutlineTitleCharacters: 256,
+  maxExcerptCharacters: 280,
+  maxDescriptionCharacters: 1024,
+  maxMetadataCharacters: 256,
+  maxTags: 32
+};
+var markdownModule = null;
+function loadMarkdown() {
+  markdownModule ?? (markdownModule = import("@bendyline/squisq/markdown"));
+  return markdownModule;
+}
+function normalizeLineEndings(text) {
+  return text.replace(/\r\n?/g, "\n");
+}
+var WORD_PATTERN = /[\p{L}\p{N}]+(?:['’_-][\p{L}\p{N}]+)*/gu;
+function countWords(text) {
+  return text.match(WORD_PATTERN)?.length ?? 0;
+}
+function collapseWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function truncate(text, maximum) {
+  if (text.length <= maximum) return text;
+  const slice = text.slice(0, maximum - 1);
+  const space = slice.lastIndexOf(" ");
+  return `${(space > maximum / 2 ? slice.slice(0, space) : slice).trimEnd()}\u2026`;
+}
+function metadataText(value, maximum) {
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (value instanceof Date && Number.isFinite(value.getTime())) {
+    return value.toISOString().slice(0, 10);
+  }
+  if (typeof value !== "string") return void 0;
+  const text = collapseWhitespace(value);
+  return text ? truncate(text, maximum) : void 0;
+}
+function firstMetadataText(frontmatter, keys, maximum) {
+  for (const key of keys) {
+    const value = metadataText(frontmatter?.[key], maximum);
+    if (value) return value;
+  }
+  return void 0;
+}
+function metadataTags(frontmatter) {
+  const raw = frontmatter?.tags ?? frontmatter?.keywords;
+  const values = Array.isArray(raw) ? raw : typeof raw === "string" ? (
+    // Squisq's frontmatter reader keeps YAML flow lists (`[a, b]`) as text.
+    raw.replace(/^\s*\[|\]\s*$/g, "").split(",").map((tag) => tag.trim().replace(/^(["'])(.*)\1$/, "$2"))
+  ) : [];
+  const tags = [];
+  for (const value of values) {
+    const tag = metadataText(value, CATALOG_LIMITS.maxMetadataCharacters);
+    if (tag && !tags.includes(tag)) tags.push(tag);
+    if (tags.length >= CATALOG_LIMITS.maxTags) break;
+  }
+  return tags.length > 0 ? tags : void 0;
+}
+function stemOf(path) {
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+async function catalogEntryFromDocument(source, document, hints = {}) {
+  const { extractPlainText, inferDocumentTitle, readFrontmatterThemeId } = await loadMarkdown();
+  const frontmatter = document.frontmatter;
+  const title = metadataText(inferDocumentTitle(document), CATALOG_LIMITS.maxMetadataCharacters) ?? metadataText(hints.fallbackTitle, CATALOG_LIMITS.maxMetadataCharacters) ?? stemOf(source.path);
+  const outline = [];
+  let words = 0;
+  let excerpt;
+  for (const block of document.children) {
+    const text = extractPlainText(block);
+    words += countWords(text);
+    if (block.type === "heading") {
+      const headingTitle = collapseWhitespace(text);
+      if (headingTitle && outline.length < CATALOG_LIMITS.maxOutlineEntries) {
+        outline.push({
+          level: block.depth,
+          title: truncate(headingTitle, CATALOG_LIMITS.maxOutlineTitleCharacters)
+        });
+      }
+    } else if (block.type === "paragraph" && excerpt === void 0) {
+      const paragraph = collapseWhitespace(text);
+      if (paragraph && paragraph !== title && paragraph !== hints.fallbackTitle) {
+        excerpt = truncate(paragraph, CATALOG_LIMITS.maxExcerptCharacters);
+      }
+    }
+  }
+  const description = firstMetadataText(
+    frontmatter,
+    ["description", "summary", "excerpt"],
+    CATALOG_LIMITS.maxDescriptionCharacters
+  ) ?? metadataText(hints.description, CATALOG_LIMITS.maxDescriptionCharacters);
+  const author = firstMetadataText(frontmatter, ["author"], CATALOG_LIMITS.maxMetadataCharacters);
+  const date = firstMetadataText(
+    frontmatter,
+    ["date", "updated", "published"],
+    CATALOG_LIMITS.maxMetadataCharacters
+  );
+  const theme = readFrontmatterThemeId(frontmatter);
+  return {
+    path: source.path,
+    ...source.source !== void 0 && source.source !== source.path ? { source: source.source } : {},
+    format: source.format,
+    title,
+    ...description ? { description } : {},
+    ...author ? { author } : {},
+    ...date ? { date } : {},
+    ...metadataTags(frontmatter) ? { tags: metadataTags(frontmatter) } : {},
+    ...theme ? { theme } : {},
+    outline,
+    wordCount: words,
+    ...excerpt ? { excerpt } : {}
+  };
+}
+async function catalogEntryFromMarkdown(source, markdown, options = {}) {
+  const { parseMarkdown } = await loadMarkdown();
+  const normalized = normalizeLineEndings(markdown);
+  const entry = await catalogEntryFromDocument(source, parseMarkdown(normalized));
+  return options.includeMarkdown ? { ...entry, markdown: normalized } : entry;
+}
+function catalogEntryForUnreadable(source) {
+  return {
+    path: source.path,
+    format: source.format,
+    title: stemOf(source.path),
+    outline: [],
+    wordCount: 0
+  };
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function sortCatalogEntries(entries, order) {
+  const byPath = (left, right) => compareCodeUnits(left.path, right.path);
+  const byTitle = (left, right) => compareCodeUnits(left.title.toLowerCase(), right.title.toLowerCase()) || compareCodeUnits(left.title, right.title) || byPath(left, right);
+  return [...entries].sort((left, right) => {
+    if (order === "path") return byPath(left, right);
+    if (order === "date") {
+      if (left.date && right.date) {
+        return compareCodeUnits(right.date, left.date) || byTitle(left, right);
+      }
+      if (left.date) return -1;
+      if (right.date) return 1;
+    }
+    return byTitle(left, right);
+  });
+}
+function createWorkspaceCatalog(title, entries, order) {
+  return {
+    generator: CATALOG_GENERATOR,
+    version: CATALOG_FORMAT_VERSION,
+    title,
+    documents: sortCatalogEntries(entries, order)
+  };
+}
+function orderedEntry(entry) {
+  const ordered = {};
+  const keys = [
+    "path",
+    "source",
+    "format",
+    "title",
+    "description",
+    "author",
+    "date",
+    "tags",
+    "theme",
+    "outline",
+    "wordCount",
+    "excerpt",
+    "markdown"
+  ];
+  for (const key of keys) {
+    const value = entry[key];
+    if (value === void 0) continue;
+    ordered[key] = key === "outline" ? value.map((item) => ({
+      level: item.level,
+      title: item.title
+    })) : value;
+  }
+  return ordered;
+}
+function serializeCatalogJson(catalog) {
+  return `${JSON.stringify(
+    {
+      generator: catalog.generator,
+      version: catalog.version,
+      title: catalog.title,
+      documents: catalog.documents.map(orderedEntry)
+    },
+    null,
+    2
+  )}
+`;
+}
+var CATALOG_JSON_MARKER = /^\uFEFF?\{\s*"generator"\s*:\s*"docblocks-workspace-catalog"/;
+function isGeneratedCatalogJson(text) {
+  return CATALOG_JSON_MARKER.test(text.slice(0, 256));
+}
+var CATALOG_HTML_MARKER = /<!-- docblocks-workspace-catalog v1 inputs=sha256:([0-9a-f]{64}) -->/;
+var CATALOG_HTML_MARKER_SCAN_CHARACTERS = 2048;
+function stampCatalogHtml(html, inputsDigest) {
+  if (!/^[0-9a-f]{64}$/.test(inputsDigest)) throw new Error("Catalog digest must be SHA-256 hex.");
+  const marker = `<!-- ${CATALOG_GENERATOR} v1 inputs=sha256:${inputsDigest} -->
+`;
+  const doctype = /^<!DOCTYPE html>\r?\n/i.exec(html);
+  return doctype ? `${doctype[0]}${marker}${html.slice(doctype[0].length)}` : `${marker}${html}`;
+}
+function readCatalogHtmlDigest(text) {
+  return CATALOG_HTML_MARKER.exec(text.slice(0, CATALOG_HTML_MARKER_SCAN_CHARACTERS))?.[1] ?? null;
+}
+function isGeneratedCatalogHtml(text) {
+  return readCatalogHtmlDigest(text) !== null;
+}
+function relativeCatalogLink(fromDirectory, toPath) {
+  const from = fromDirectory.split("/").filter(Boolean);
+  const to = toPath.split("/").filter(Boolean);
+  let shared = 0;
+  while (shared < from.length && shared < to.length - 1 && from[shared] === to[shared]) shared += 1;
+  const up = from.slice(shared).map(() => "..");
+  return [...up, ...to.slice(shared).map((segment) => encodeURIComponent(segment))].join("/");
+}
+function textNode(value) {
+  return { type: "text", value };
+}
+function folderOf(path) {
+  const slash = path.lastIndexOf("/");
+  return slash < 0 ? "" : path.slice(0, slash);
+}
+function buildCatalogMarkdownDocument(catalog, outputPath) {
+  const outputDirectory = folderOf(outputPath);
+  const children = [
+    { type: "heading", depth: 1, children: [textNode(catalog.title)] }
+  ];
+  if (catalog.documents.length === 0) {
+    children.push({ type: "paragraph", children: [textNode("No documents yet.")] });
+    return { type: "document", children };
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of catalog.documents) {
+    const folder = folderOf(entry.path);
+    const group = groups.get(folder);
+    if (group) group.push(entry);
+    else groups.set(folder, [entry]);
+  }
+  const folders = [...groups.keys()].sort(compareCodeUnits);
+  const showFolders = folders.length > 1 || folders[0] !== "";
+  for (const folder of folders) {
+    if (showFolders && folder) {
+      children.push({ type: "heading", depth: 2, children: [textNode(folder)] });
+    }
+    const items = groups.get(folder).map((entry) => {
+      const inline = [
+        {
+          type: "link",
+          url: relativeCatalogLink(outputDirectory, entry.path),
+          title: null,
+          children: [textNode(entry.title)]
+        }
+      ];
+      if (entry.date) inline.push(textNode(` \xB7 ${entry.date}`));
+      const description = entry.description ?? entry.excerpt;
+      if (description) inline.push(textNode(` \u2014 ${description}`));
+      return {
+        type: "listItem",
+        spread: false,
+        children: [{ type: "paragraph", children: inline }]
+      };
+    });
+    children.push({ type: "list", ordered: false, spread: false, children: items });
+  }
+  return { type: "document", children };
+}
+async function sha256Hex(text) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// src/workspace-settings/outside-in-layout.ts
+var OUTSIDE_IN_FORMAT_IDS = ["html", "docx", "pdf", "pptx", "xlsx", "csv"];
+var FORMAT_IDS = new Set(OUTSIDE_IN_FORMAT_IDS);
+function normalizePath(path) {
+  const leading = path.replace(/\\/g, "/").startsWith("/") ? "/" : "";
+  const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+  if (parts.some((part) => part === "." || part === "..")) {
+    throw new Error(`Outside-in paths must be canonical workspace paths: ${path}`);
+  }
+  return leading + parts.join("/");
+}
+function join(parent, child) {
+  if (!parent || parent === "/") return parent === "/" ? `/${child}` : child;
+  return `${parent}/${child}`;
+}
+function slug(stem) {
+  return stem.normalize("NFKD").replace(/\p{Mark}+/gu, "").toLocaleLowerCase("en-US").replace(/[^\p{Letter}\p{Number}]+/gu, "-").replace(/^-+|-+$/g, "") || "document";
+}
+function resolveOutsideInLayout(path) {
+  const targetPath = normalizePath(path);
+  const slash = targetPath.lastIndexOf("/");
+  const parentDirectory = slash < 0 ? "" : slash === 0 ? "/" : targetPath.slice(0, slash);
+  const filename = slash < 0 ? targetPath : targetPath.slice(slash + 1);
+  const dot = filename.lastIndexOf(".");
+  if (dot <= 0) return null;
+  const rawFormat = filename.slice(dot + 1).toLowerCase();
+  const format = rawFormat === "htm" ? "html" : rawFormat;
+  if (!FORMAT_IDS.has(format)) return null;
+  const stem = filename.slice(0, dot);
+  const companionName = `${stem}_files`;
+  const companionDirectory = join(parentDirectory, companionName);
+  const markdownFilename = `${slug(stem)}.md`;
+  const backupDirectory = join(companionDirectory, ".original");
+  const backupFilename = `original.${format}`;
+  return {
+    targetPath,
+    format,
+    parentDirectory,
+    stem,
+    companionName,
+    companionDirectory,
+    markdownFilename,
+    markdownPath: join(companionDirectory, markdownFilename),
+    relativeTargetPath: `../${filename}`,
+    backupDirectory,
+    backupFilename,
+    backupPath: join(backupDirectory, backupFilename)
+  };
+}
+function relocateOutsideInLayout(layout, targetPath) {
+  const next = resolveOutsideInLayout(targetPath);
+  if (!next || next.format !== layout.format)
+    throw new Error("Keep the outside-in document format when moving it.");
+  const root = `${normalizePath(layout.companionDirectory).replace(/\/$/, "")}/`;
+  const source = normalizePath(layout.markdownPath);
+  if (!source.startsWith(root))
+    throw new Error("The Markdown source is outside its companion directory.");
+  const markdownPath = join(next.companionDirectory, source.slice(root.length));
+  return { ...next, markdownPath, markdownFilename: layout.markdownFilename };
+}
+function chooseOutsideInMarkdownPath(layout, paths) {
+  const canonical = normalizePath(layout.markdownPath);
+  const normalized = paths.map(normalizePath);
+  const exact = normalized.find((path) => path === canonical);
+  if (exact) return exact;
+  const folded = normalized.find(
+    (path) => path.toLocaleLowerCase("en-US") === canonical.toLocaleLowerCase("en-US")
+  );
+  if (folded) return folded;
+  const prefix = `${normalizePath(layout.companionDirectory).replace(/\/$/, "")}/`;
+  const markdown = normalized.filter(
+    (path) => path.startsWith(prefix) && !path.slice(prefix.length).includes("/") && path.toLocaleLowerCase("en-US").endsWith(".md")
+  );
+  return markdown.length === 1 ? markdown[0] : null;
+}
+
+export {
+  CATALOG_GENERATOR,
+  CATALOG_FORMAT_VERSION,
+  CATALOG_LIMITS,
+  normalizeLineEndings,
+  catalogEntryFromDocument,
+  catalogEntryFromMarkdown,
+  catalogEntryForUnreadable,
+  sortCatalogEntries,
+  createWorkspaceCatalog,
+  serializeCatalogJson,
+  isGeneratedCatalogJson,
+  stampCatalogHtml,
+  readCatalogHtmlDigest,
+  isGeneratedCatalogHtml,
+  relativeCatalogLink,
+  buildCatalogMarkdownDocument,
+  sha256Hex,
+  OUTSIDE_IN_FORMAT_IDS,
+  resolveOutsideInLayout,
+  relocateOutsideInLayout,
+  chooseOutsideInMarkdownPath
+};

package/dist/{chunk-ZO7G53QP.js → chunk-UDEWLHQI.js}

@@ -4,9 +4,11 @@ import {
 import {
   compareSnapshotsByName,
   compareText,
-  copyBytes,
+  copyBytes
+} from "./chunk-HABG2JM3.js";
+import {
   parseFileSystemVersion
-} from "./chunk-M62ZGJ5I.js";
+} from "./chunk-LPIJ6HKL.js";
 import {
   decodeUtf8Text
 } from "./chunk-M5ZNQGR5.js";