@silicajs/core 0.6.0 → 0.7.0

package/dist/{chunk-2EKH4A4V.js → chunk-4A6TRY75.js}

@@ -87,16 +87,26 @@ function createWikiLinkResolutionIndex(allSlugs, options = {}) {
     )
   );
   const uniqueSlugByBasename = /* @__PURE__ */ new Map();
+  const slugsByBasename = /* @__PURE__ */ new Map();
   for (const slug of candidates) {
     const basename = basenameForNormalizedSlug(slug);
     if (!basename) continue;
+    const basenameCandidates = slugsByBasename.get(basename);
+    if (basenameCandidates) {
+      basenameCandidates.push(slug);
+    } else {
+      slugsByBasename.set(basename, [slug]);
+    }
     if (uniqueSlugByBasename.has(basename)) {
       uniqueSlugByBasename.set(basename, null);
       continue;
     }
     uniqueSlugByBasename.set(basename, slug);
   }
-  return { candidates, uniqueSlugByBasename };
+  for (const basenameCandidates of slugsByBasename.values()) {
+    basenameCandidates.sort(compareSlugs);
+  }
+  return { candidates, uniqueSlugByBasename, slugsByBasename };
 }
 function createAssetResolutionIndex(assets, options = {}) {
   const assetPathBySourcePath = /* @__PURE__ */ new Map();
@@ -132,7 +142,11 @@ function resolveWikiLink(currentSlug, target, index, strategy = "shortest", opti
     return asFullSlug(`${normalizedTarget}/index`);
   const targetBasename = normalizedTarget.split("/").at(-1) ?? "";
   const byBasename = index.uniqueSlugByBasename.get(targetBasename);
-  return byBasename ? asFullSlug(byBasename) : void 0;
+  if (byBasename) return asFullSlug(byBasename);
+  return closestWikiLinkCandidate(
+    currentSlug,
+    candidatesForBasename(index, targetBasename)
+  );
 }
 function resolveAssetPath(currentSourcePath, target, index, strategy = "shortest", options = {}) {
   if (/^(?:https?:|#|\/)/.test(target)) return void 0;
@@ -166,6 +180,49 @@ function basenameForNormalizedSlug(slug) {
   const simplified = slug === "index" ? "" : slug.replace(/\/index$/, "");
   return simplified.split("/").at(-1) ?? "";
 }
+function candidatesForBasename(index, basename) {
+  const indexedCandidates = index.slugsByBasename?.get(basename);
+  if (indexedCandidates) return indexedCandidates;
+  return [...index.candidates].filter((slug) => basenameForNormalizedSlug(slug) === basename).sort(compareSlugs);
+}
+function closestWikiLinkCandidate(currentSlug, candidates) {
+  if (candidates.length === 0) return void 0;
+  const currentDirectory = normalizeSlug(currentSlug, {
+    numericPrefixes: false
+  }).split("/").slice(0, -1);
+  const [bestCandidate] = [...candidates].sort((left, right) => {
+    const leftScore = wikiLinkCandidateScore(currentDirectory, left);
+    const rightScore = wikiLinkCandidateScore(currentDirectory, right);
+    return rightScore.sharedPrefixLength - leftScore.sharedPrefixLength || leftScore.depth - rightScore.depth || compareSlugs(left, right);
+  });
+  return bestCandidate ? asFullSlug(bestCandidate) : void 0;
+}
+function wikiLinkCandidateScore(currentDirectory, slug) {
+  const simplified = simplifyCandidateSlug(slug);
+  const segments = simplified ? simplified.split("/") : [];
+  return {
+    sharedPrefixLength: sharedPrefixLength(
+      currentDirectory,
+      segments.slice(0, -1)
+    ),
+    depth: segments.length
+  };
+}
+function simplifyCandidateSlug(slug) {
+  return slug === "index" ? "" : slug.replace(/\/index$/, "");
+}
+function sharedPrefixLength(left, right) {
+  let length = 0;
+  while (left[length] !== void 0 && left[length] === right[length]) {
+    length += 1;
+  }
+  return length;
+}
+function compareSlugs(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
 function normalizeAssetSegment(segment, options = {}) {
   const extension = path.posix.extname(segment);
   if (!extension) return slugifySegment(segment, options);
@@ -206,6 +263,197 @@ function numericPrefixSortSegment(segment) {
   return `${order}:${slugifySegment(match[2])}`;
 }
 
+// src/pipeline/frontmatter.ts
+import { slug as slugifyHeading } from "github-slugger";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import {
+  remarkObsidian
+} from "@silicajs/remark-obsidian";
+var RESERVED_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
+  "aliases",
+  "alias",
+  "created",
+  "cssclass",
+  "cssclasses",
+  "date",
+  "description",
+  "draft",
+  "listed",
+  "menu_label",
+  "modified",
+  "permalink",
+  "publish",
+  "tag",
+  "tags",
+  "title"
+]);
+function getMenuLabel(frontmatter, title) {
+  if (typeof frontmatter.menu_label === "string" && frontmatter.menu_label.trim()) {
+    return frontmatter.menu_label.trim();
+  }
+  return title;
+}
+function getPageProperties(frontmatter) {
+  return Object.entries(frontmatter).filter(([key]) => !RESERVED_FRONTMATTER_KEYS.has(key.toLowerCase())).map(([key, value]) => {
+    const formatted = formatPropertyValue(value);
+    if (formatted === void 0) return void 0;
+    return {
+      key,
+      label: formatPropertyLabel(key),
+      value: formatted
+    };
+  }).filter((property) => property !== void 0).sort((a, b) => a.key.localeCompare(b.key));
+}
+function getResolvedPageProperties(frontmatter, context) {
+  return getPageProperties(frontmatter).map((property) => ({
+    ...property,
+    parts: resolvePagePropertyValue(property.value, context).parts
+  }));
+}
+function analyzePagePropertyLinks(frontmatter, context) {
+  const links = /* @__PURE__ */ new Set();
+  const brokenLinks = [];
+  for (const property of getPageProperties(frontmatter)) {
+    const resolution = resolvePagePropertyValue(property.value, context);
+    for (const link of resolution.links) links.add(link);
+    brokenLinks.push(...resolution.brokenLinks);
+  }
+  return { links: [...links], brokenLinks };
+}
+function resolvePagePropertyValue(value, context) {
+  const nodes = collectPropertyWikiNodes(value, context);
+  if (nodes.length === 0) {
+    return {
+      parts: [{ type: "text", value }],
+      links: [],
+      brokenLinks: []
+    };
+  }
+  const parts = [];
+  const links = /* @__PURE__ */ new Set();
+  const brokenLinks = [];
+  let cursor = 0;
+  for (const node of nodes) {
+    const range = nodeRange(node);
+    if (!range || range.start < cursor) continue;
+    if (range.start > cursor) {
+      parts.push({ type: "text", value: value.slice(cursor, range.start) });
+    }
+    const label = node.alias || node.target || "";
+    const targetPath = node.linkTarget.path || String(context.slug);
+    const resolved = resolvePagePropertyWikiTarget(context, targetPath);
+    if (resolved) {
+      links.add(resolved);
+      parts.push({
+        type: "link",
+        value: label,
+        target: node.rawTarget,
+        slug: resolved,
+        href: `${slugToHref(resolved)}${targetFragment(node)}`
+      });
+    } else {
+      brokenLinks.push({
+        source: String(context.slug),
+        target: node.rawTarget
+      });
+      parts.push({
+        type: "broken-link",
+        value: label,
+        target: node.rawTarget
+      });
+    }
+    cursor = range.end;
+  }
+  if (cursor < value.length) {
+    parts.push({ type: "text", value: value.slice(cursor) });
+  }
+  return { parts, links: [...links], brokenLinks };
+}
+function formatPropertyLabel(key) {
+  return key.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase();
+}
+function formatPropertyValue(value) {
+  if (value === null || value === void 0) return void 0;
+  if (value instanceof Date) {
+    return value.toISOString().slice(0, 10);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || void 0;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => formatPropertyValue(item)).filter((item) => item !== void 0);
+    return items.length ? items.join(", ") : void 0;
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function collectPropertyWikiNodes(value, context) {
+  const processor = unified().use(remarkParse).use(remarkObsidian, { inlineTags: context.tags?.inline ?? true });
+  const tree = processor.parse(value);
+  const nodes = [];
+  visitPropertyNodes(tree, (node) => {
+    if (!isPropertyWikiNode(node)) return;
+    if (node.type === "obsidianWikiEmbed" && isAssetTarget(node.rawTarget)) {
+      return;
+    }
+    nodes.push(node);
+  });
+  return nodes.sort(
+    (a, b) => (nodeRange(a)?.start ?? 0) - (nodeRange(b)?.start ?? 0)
+  );
+}
+function visitPropertyNodes(node, visitor) {
+  visitor(node);
+  for (const child of node.children ?? []) {
+    visitPropertyNodes(child, visitor);
+  }
+}
+function isPropertyWikiNode(node) {
+  return node.type === "obsidianWikilink" || node.type === "obsidianWikiEmbed";
+}
+function resolvePagePropertyWikiTarget(context, targetPath) {
+  if (context.resolveWikiLink) {
+    return context.resolveWikiLink(context.slug, targetPath);
+  }
+  if (!context.wikilinkIndex) return void 0;
+  return resolveWikiLink(
+    context.slug,
+    targetPath,
+    context.wikilinkIndex,
+    context.wikilinkStrategy ?? "shortest",
+    context.ordering
+  );
+}
+function nodeRange(node) {
+  const start = node.position?.start?.offset;
+  const end = node.position?.end?.offset;
+  if (typeof start !== "number" || typeof end !== "number" || end < start) {
+    return void 0;
+  }
+  return { start, end };
+}
+function targetFragment(node) {
+  if (node.linkTarget.blockId) {
+    return `#^${encodeURIComponent(node.linkTarget.blockId)}`;
+  }
+  if (node.linkTarget.heading) {
+    return `#${slugifyHeading(node.linkTarget.heading)}`;
+  }
+  return "";
+}
+function isAssetTarget(target) {
+  return /\.(png|jpe?g|gif|webp|svg|pdf|mp4|mov|mp3|wav|ogg|canvas)(?:[?#].*)?$/i.test(
+    target
+  );
+}
+
 // src/tags.ts
 import { normalizeTag } from "@silicajs/remark-obsidian";
 function tagToHref(tag) {
@@ -217,8 +465,8 @@ function tagToHref(tag) {
 
 // src/pipeline/index.ts
 import matter from "gray-matter";
-import { unified } from "unified";
-import remarkParse from "remark-parse";
+import { unified as unified2 } from "unified";
+import remarkParse2 from "remark-parse";
 import remarkFrontmatter from "remark-frontmatter";
 import remarkGfm from "remark-gfm";
 import remarkMath from "remark-math";
@@ -231,7 +479,7 @@ import rehypeAutolinkHeadings from "rehype-autolink-headings";
 import rehypeShiki from "@shikijs/rehype";
 import rehypeReact from "rehype-react";
 import rehypeStringify from "rehype-stringify";
-import { getTags, remarkObsidian } from "@silicajs/remark-obsidian";
+import { getTags, remarkObsidian as remarkObsidian2 } from "@silicajs/remark-obsidian";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 
 // src/pipeline/code-block.ts
@@ -340,7 +588,7 @@ function toText(node) {
 
 // src/pipeline/obsidian.ts
 import { visit } from "unist-util-visit";
-import { slug as slugifyHeading } from "github-slugger";
+import { slug as slugifyHeading2 } from "github-slugger";
 function remarkSilicaObsidian(context) {
   return async (tree, file) => {
     const links = /* @__PURE__ */ new Set();
@@ -359,11 +607,11 @@ function remarkSilicaObsidian(context) {
         return;
       }
       if (!isWikiNode(node)) return;
-      if (node.type === "obsidianWikiEmbed" && !isAssetTarget(node.rawTarget)) {
+      if (node.type === "obsidianWikiEmbed" && !isAssetTarget2(node.rawTarget)) {
         embedPromises.push(resolveEmbedNode(node, context));
       }
       const targetPath = node.linkTarget.path || String(context.slug);
-      if (node.type === "obsidianWikiEmbed" && isAssetTarget(node.rawTarget)) {
+      if (node.type === "obsidianWikiEmbed" && isAssetTarget2(node.rawTarget)) {
         const resolvedAsset = resolveAssetTarget(context, node.rawTarget);
         if (resolvedAsset) {
           node.data = {
@@ -411,7 +659,7 @@ function createSilicaObsidianHandlers(context) {
       return wikilinkToHast(state, node);
     },
     obsidianWikiEmbed(state, node) {
-      if (node.rawTarget && isAssetTarget(node.rawTarget)) {
+      if (node.rawTarget && isAssetTarget2(node.rawTarget)) {
         return assetEmbedToHast(context, node);
       }
       const embedHtml = getStringData(node, "silicaEmbedHtml");
@@ -522,7 +770,7 @@ function wikilinkToHast(_state, node) {
   return {
     type: "element",
     tagName: "a",
-    properties: { href: `${slugToHref(resolved)}${targetFragment(node)}` },
+    properties: { href: `${slugToHref(resolved)}${targetFragment2(node)}` },
     children: [{ type: "text", value: label }]
   };
 }
@@ -593,12 +841,12 @@ function assetEmbedToHast(context, node) {
     children: [{ type: "text", value: label }]
   };
 }
-function targetFragment(node) {
+function targetFragment2(node) {
   if (node.linkTarget.blockId) {
     return `#^${encodeURIComponent(node.linkTarget.blockId)}`;
   }
   if (node.linkTarget.heading) {
-    return `#${slugifyHeading(node.linkTarget.heading)}`;
+    return `#${slugifyHeading2(node.linkTarget.heading)}`;
   }
   return "";
 }
@@ -626,7 +874,7 @@ function sizeProperties(size) {
   };
 }
 function rewriteAssetUrl(url, assetBaseUrl) {
-  if (!isAssetTarget(url)) return url;
+  if (!isAssetTarget2(url)) return url;
   if (/^(?:https?:|#|\/)/.test(url)) return url;
   return `${assetBaseUrl}/${url.replace(/^\.?\//, "")}`;
 }
@@ -642,7 +890,7 @@ function resolveAssetTarget(context, target) {
   ) : void 0);
   return resolved ? `${resolved}${assetReferenceSuffix(target)}` : void 0;
 }
-function isAssetTarget(target) {
+function isAssetTarget2(target) {
   return /\.(png|jpe?g|gif|webp|svg|pdf|mp4|mov|mp3|wav|ogg|canvas)(?:[?#].*)?$/i.test(
     target
   );
@@ -1033,16 +1281,22 @@ async function analyzeMarkdown(raw, context) {
   const file = await runRemarkObsidian(parsed.content, context);
   const plainText = extractPlainText(parsed.content);
   const frontmatter = parsed.data;
-  const brokenLinks = getDataArray(
+  const contentBrokenLinks = getDataArray(
     file.data,
     "silicaObsidianBrokenLinks"
   ).map((link) => ({ source: String(context.slug), target: link.target }));
+  const pagePropertyLinks = analyzePagePropertyLinks(frontmatter, context);
   const description = getDescription(frontmatter);
   return {
     frontmatter,
-    links: getDataArray(file.data, "silicaObsidianLinks"),
+    links: [
+      .../* @__PURE__ */ new Set([
+        ...getDataArray(file.data, "silicaObsidianLinks"),
+        ...pagePropertyLinks.links
+      ])
+    ],
     embeds: getDataArray(file.data, "silicaObsidianEmbeds"),
-    brokenLinks,
+    brokenLinks: [...contentBrokenLinks, ...pagePropertyLinks.brokenLinks],
     plainText,
     title: getTitle(frontmatter),
     description,
@@ -1078,13 +1332,13 @@ function cleanPlainText(text, maxLength, options = {}) {
   return truncated || void 0;
 }
 function baseProcessor(context) {
-  return unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkMath).use(remarkObsidian, { inlineTags: context.tags?.inline ?? true }).use(remarkSilicaObsidian, context).use(remarkRehype, {
+  return unified2().use(remarkParse2).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkMath).use(remarkObsidian2, { inlineTags: context.tags?.inline ?? true }).use(remarkSilicaObsidian, context).use(remarkRehype, {
     allowDangerousHtml: true,
     handlers: createSilicaObsidianHandlers(context)
   });
 }
 async function runRemarkObsidian(markdown, context) {
-  const processor = unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkMath).use(remarkObsidian, { inlineTags: context.tags?.inline ?? true }).use(remarkSilicaObsidian, context);
+  const processor = unified2().use(remarkParse2).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkMath).use(remarkObsidian2, { inlineTags: context.tags?.inline ?? true }).use(remarkSilicaObsidian, context);
   const tree = processor.parse(markdown);
   const file = { data: {} };
   await processor.run(tree, file);
@@ -1100,7 +1354,7 @@ function extractPlainText(markdown, options = {}) {
   return normalizePlainText(parts.join(" "));
 }
 function parsePlainTextMarkdown(markdown) {
-  return unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkMath).use(remarkObsidian).parse(markdown);
+  return unified2().use(remarkParse2).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkMath).use(remarkObsidian2).parse(markdown);
 }
 function collectPlainText(node, parts) {
   if (plainTextSkipTypes.has(node.type)) return;
@@ -1149,6 +1403,13 @@ export {
   resolveAssetPath,
   resolveRelativeAsset,
   joinSegments,
+  getMenuLabel,
+  getPageProperties,
+  getResolvedPageProperties,
+  analyzePagePropertyLinks,
+  resolvePagePropertyValue,
+  formatPropertyLabel,
+  formatPropertyValue,
   tagToHref,
   renderMarkdown,
   renderMarkdownHtml,
@@ -1158,4 +1419,4 @@ export {
   generateDescriptionFromContent,
   getMetaDescription
 };
-//# sourceMappingURL=chunk-2EKH4A4V.js.map
+//# sourceMappingURL=chunk-4A6TRY75.js.map