@silicajs/core 0.5.1 → 0.6.1

package/dist/index.js

@@ -10,6 +10,7 @@ import {
   asFullSlug,
   asRelativeURL,
   asSimpleSlug,
+  createAssetResolutionIndex,
   createWikiLinkResolutionIndex,
   generateDescriptionFromContent,
   getDescription,
@@ -18,21 +19,25 @@ import {
   hasNumericPrefixInPath,
   hrefToSlug,
   joinSegments,
+  normalizeAssetReference,
   normalizePath,
   normalizeSlug,
   numericPrefixSortKey,
   pathToRoot,
   renderMarkdown,
   renderMarkdownHtml,
+  resolveAssetPath,
   resolveRelative,
+  resolveRelativeAsset,
   resolveWikiLink,
   simplifySlug,
   slugToHref,
+  slugifyAssetPath,
   slugifyFilePath,
   slugifySegment,
   stripNumericPrefix,
   tagToHref
-} from "./chunk-2TXWBKM4.js";
+} from "./chunk-2EKH4A4V.js";
 
 // src/config.ts
 import path from "path";
@@ -149,6 +154,7 @@ async function scanContent(projectRoot, config) {
   const markdown = [];
   const assets = [];
   for (const relativePath of entries.sort()) {
+    const sourcePath = relativePath.replace(/\\/g, "/");
     const absolutePath = path2.join(contentRoot, relativePath);
     const stats = await fs.lstat(absolutePath);
     if (!stats.isFile()) continue;
@@ -158,7 +164,7 @@ async function scanContent(projectRoot, config) {
       const parsed = matter(raw);
       markdown.push({
         absolutePath,
-        relativePath: relativePath.replace(/\\/g, "/"),
+        sourcePath,
         slug: slugifyFilePath(
           asFilePath(relativePath),
           config.contentDir,
@@ -175,12 +181,26 @@ async function scanContent(projectRoot, config) {
     } else {
       assets.push({
         absolutePath,
-        relativePath: relativePath.replace(/\\/g, "/")
+        sourcePath,
+        assetPath: slugifyAssetPath(sourcePath, config.ordering)
       });
     }
   }
+  assertUniqueAssetPaths(assets);
   return { markdown, assets };
 }
+function assertUniqueAssetPaths(assets) {
+  const sourcePathByAssetPath = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    const existing = sourcePathByAssetPath.get(asset.assetPath);
+    if (existing && existing !== asset.sourcePath) {
+      throw new Error(
+        `Asset path collision: ${existing} and ${asset.sourcePath} both map to ${asset.assetPath}`
+      );
+    }
+    sourcePathByAssetPath.set(asset.assetPath, asset.sourcePath);
+  }
+}
 async function isWithinRoot(absolutePath, realRoot) {
   const realPath = await fs.realpath(absolutePath);
   const relative = path2.relative(realRoot, realPath);
@@ -208,7 +228,7 @@ import {
   makeExcerpt
 } from "@silicajs/search";
 var VAULT_DATABASE_FILENAME = "vault.db";
-var VAULT_DATABASE_VERSION = "1";
+var VAULT_DATABASE_VERSION = "2";
 async function writeVaultDatabase(projectRoot, input) {
   const silicaRoot = path3.join(projectRoot, ".silica");
   await fs2.ensureDir(silicaRoot);
@@ -241,7 +261,7 @@ function createVaultDatabaseSchema(db) {
     CREATE TABLE notes (
       slug TEXT PRIMARY KEY,
       file TEXT NOT NULL,
-      relative_file TEXT NOT NULL,
+      source_path TEXT NOT NULL,
       title TEXT NOT NULL,
       menu_label TEXT NOT NULL,
       description TEXT,
@@ -285,6 +305,14 @@ function createVaultDatabaseSchema(db) {
       PRIMARY KEY (strategy_key, alias, slug)
     );
 
+    CREATE TABLE asset_aliases (
+      strategy_key TEXT NOT NULL,
+      alias TEXT NOT NULL,
+      asset_path TEXT NOT NULL,
+      sort_key TEXT,
+      PRIMARY KEY (strategy_key, alias, asset_path)
+    );
+
     CREATE INDEX notes_prerender_idx ON notes(prerender, slug);
     CREATE INDEX notes_listed_sort_idx ON notes(listed, sort_key, slug);
     CREATE INDEX links_target_idx ON links(target_slug, kind, source_slug);
@@ -292,6 +320,8 @@ function createVaultDatabaseSchema(db) {
     CREATE INDEX note_tags_tag_idx ON note_tags(tag, slug);
     CREATE INDEX slug_aliases_lookup_idx
       ON slug_aliases(strategy_key, alias, sort_key, slug);
+    CREATE INDEX asset_aliases_lookup_idx
+      ON asset_aliases(strategy_key, alias, sort_key, asset_path);
   `);
 }
 function populateVaultDatabase(db, input) {
@@ -306,7 +336,7 @@ function populateVaultDatabase(db, input) {
     INSERT INTO notes (
       slug,
       file,
-      relative_file,
+      source_path,
       title,
       menu_label,
       description,
@@ -325,7 +355,7 @@ function populateVaultDatabase(db, input) {
     VALUES (
       @slug,
       @file,
-      @relativeFile,
+      @sourcePath,
       @title,
       @menuLabel,
       @description,
@@ -356,6 +386,15 @@ function populateVaultDatabase(db, input) {
     INSERT OR IGNORE INTO slug_aliases (strategy_key, alias, slug, sort_key)
     VALUES (?, ?, ?, ?)
   `);
+  const insertAssetAlias = db.prepare(`
+    INSERT OR IGNORE INTO asset_aliases (
+      strategy_key,
+      alias,
+      asset_path,
+      sort_key
+    )
+    VALUES (?, ?, ?, ?)
+  `);
   const insertAll = db.transaction(() => {
     insertMetadata.run("version", VAULT_DATABASE_VERSION);
     insertMetadata.run("generatedAt", input.manifest.generatedAt);
@@ -375,7 +414,7 @@ function populateVaultDatabase(db, input) {
       insertNote.run({
         slug: entry.slug,
         file: entry.file,
-        relativeFile: entry.relativeFile,
+        sourcePath: entry.sourcePath,
         title: entry.title,
         menuLabel: entry.menuLabel,
         description: entry.description,
@@ -423,6 +462,14 @@ function populateVaultDatabase(db, input) {
         );
       }
     }
+    for (const asset of input.assets) {
+      for (const [strategy, alias] of makeAssetAliases(
+        asset.sourcePath,
+        input.config.ordering
+      )) {
+        insertAssetAlias.run(strategy, alias, asset.assetPath, asset.assetPath);
+      }
+    }
   });
   insertAll();
   buildSearchTables(db, input.searchRecords);
@@ -447,6 +494,20 @@ function makeSlugAliases(slug) {
     alias
   ]);
 }
+function makeAssetAliases(sourcePath, ordering) {
+  const aliases = /* @__PURE__ */ new Map();
+  const normalized = normalizeAssetReference(sourcePath, ordering);
+  const basename = normalizeAssetReference(
+    path3.posix.basename(sourcePath),
+    ordering
+  );
+  if (normalized) aliases.set(`absolute:${normalized}`, normalized);
+  if (basename) aliases.set(`shortest:${basename}`, basename);
+  return [...aliases.entries()].map(([key, alias]) => [
+    key.split(":")[0] ?? "shortest",
+    alias
+  ]);
+}
 async function removeDatabaseFiles(databasePath) {
   await fs2.remove(databasePath);
   await removeDatabaseSidecars(databasePath);
@@ -470,18 +531,23 @@ async function precompute(options = {}) {
   const config = options.config ?? await loadConfig(projectRoot);
   const scan = await scanContent(projectRoot, config);
   const markdownFiles = filterPublished(scan.markdown, config);
+  const assetEntries = scan.assets.map(({ sourcePath, assetPath }) => ({
+    sourcePath,
+    assetPath
+  }));
   const allSlugs = markdownFiles.map((file) => file.slug);
   const wikilinkIndex = createWikiLinkResolutionIndex(
     allSlugs,
     config.ordering
   );
+  const assetIndex = createAssetResolutionIndex(assetEntries, config.ordering);
   const entries = [];
   const graphLinks = {};
   const brokenLinks = [];
   const searchRecords = [];
   const runtimeContentRoot = path4.join(projectRoot, ".silica/content");
   const relativeGitPaths = markdownFiles.map(
-    (file) => normalizeGitPath(path4.join(config.contentDir, file.relativePath))
+    (file) => normalizeGitPath(path4.join(config.contentDir, file.sourcePath))
   );
   const gitDatesByPath = await getGitDatesForFiles(
     projectRoot,
@@ -492,16 +558,18 @@ async function precompute(options = {}) {
   await writeRuntimeMarkdown(runtimeContentRoot, markdownFiles);
   const analyses = await analyzeMarkdownFiles(markdownFiles, config, allSlugs, {
     concurrency: options.analysisConcurrency,
-    wikilinkIndex
+    wikilinkIndex,
+    assetIndex,
+    assetEntries
   });
   for (const [index, file] of markdownFiles.entries()) {
     const gitDates = gitDatesByPath.get(
-      normalizeGitPath(path4.join(config.contentDir, file.relativePath))
+      normalizeGitPath(path4.join(config.contentDir, file.sourcePath))
     ) ?? {};
     const analysis = analyses[index];
-    const title = analysis.title ?? titleFromFilePath(file.relativePath, config.ordering);
+    const title = analysis.title ?? titleFromFilePath(file.sourcePath, config.ordering);
     const menuLabel = getMenuLabel(file.frontmatter, title);
-    const sortKey = config.ordering.numericPrefixes && hasNumericPrefixInPath(file.relativePath) ? numericPrefixSortKey(file.relativePath) : void 0;
+    const sortKey = config.ordering.numericPrefixes && hasNumericPrefixInPath(file.sourcePath) ? numericPrefixSortKey(file.sourcePath) : void 0;
     const entry = {
       slug: file.slug,
       title,
@@ -509,8 +577,8 @@ async function precompute(options = {}) {
       description: analysis.description,
       generatedDescription: analysis.generatedDescription,
       tags: analysis.tags,
-      file: normalizeGitPath(path4.join(".silica/content", file.relativePath)),
-      relativeFile: file.relativePath,
+      file: normalizeGitPath(path4.join(".silica/content", file.sourcePath)),
+      sourcePath: file.sourcePath,
       sortKey,
       created: stringifyDate(
         getDate(file.frontmatter.created) ?? getDate(file.frontmatter.date) ?? gitDates.created ?? file.stats.birthtime
@@ -549,7 +617,8 @@ async function precompute(options = {}) {
     renderHashes,
     cacheState,
     prerender,
-    searchRecords
+    searchRecords,
+    assets: assetEntries
   });
   await writeSitemapAndRobots(projectRoot, config, manifest);
   if (config.wikilinks.strict && brokenLinks.length > 0) {
@@ -569,17 +638,30 @@ ${message}`);
 async function analyzeMarkdownFiles(files, config, allSlugs, options) {
   const workerCount = getAnalysisWorkerCount(files.length, options.concurrency);
   if (workerCount <= 1) {
-    return analyzeMarkdownFilesSerial(files, config, options.wikilinkIndex);
+    return analyzeMarkdownFilesSerial(
+      files,
+      config,
+      options.wikilinkIndex,
+      options.assetIndex
+    );
   }
-  return analyzeMarkdownFilesParallel(files, config, allSlugs, workerCount);
+  return analyzeMarkdownFilesParallel(
+    files,
+    config,
+    allSlugs,
+    options.assetEntries,
+    workerCount
+  );
 }
-async function analyzeMarkdownFilesSerial(files, config, wikilinkIndex) {
+async function analyzeMarkdownFilesSerial(files, config, wikilinkIndex, assetIndex) {
   const analyses = [];
   for (const file of files) {
     analyses.push(
       await analyzeMarkdown(file.raw, {
         slug: asFullSlug(file.slug),
+        sourcePath: file.sourcePath,
         wikilinkIndex,
+        assetIndex,
         assetBaseUrl: "/silica",
         wikilinkStrategy: config.wikilinks.strategy,
         tags: config.tags,
@@ -589,7 +671,7 @@ async function analyzeMarkdownFilesSerial(files, config, wikilinkIndex) {
   }
   return analyses;
 }
-function analyzeMarkdownFilesParallel(files, config, allSlugs, workerCount) {
+function analyzeMarkdownFilesParallel(files, config, allSlugs, assetEntries, workerCount) {
   return new Promise((resolve, reject) => {
     const workerUrl = new URL("./precompute-worker.js", import.meta.url);
     const workers = [];
@@ -619,6 +701,7 @@ function analyzeMarkdownFilesParallel(files, config, allSlugs, workerCount) {
       const batch = files.slice(start, start + ANALYSIS_BATCH_SIZE).map((file, offset) => ({
         index: start + offset,
         slug: file.slug,
+        sourcePath: file.sourcePath,
         raw: file.raw
       }));
       nextIndex += batch.length;
@@ -631,6 +714,7 @@ function analyzeMarkdownFilesParallel(files, config, allSlugs, workerCount) {
       const worker = new Worker(workerUrl, {
         workerData: {
           allSlugs,
+          assetEntries,
           wikilinkStrategy: config.wikilinks.strategy,
           tags: config.tags,
           ordering: config.ordering
@@ -687,7 +771,7 @@ function getRequestedAnalysisConcurrency(requestedConcurrency, available) {
 async function writeRuntimeMarkdown(runtimeContentRoot, files) {
   await fs3.emptyDir(runtimeContentRoot);
   for (const file of files) {
-    const destination = path4.join(runtimeContentRoot, file.relativePath);
+    const destination = path4.join(runtimeContentRoot, file.sourcePath);
     await fs3.ensureDir(path4.dirname(destination));
     await fs3.writeFile(destination, file.raw);
   }
@@ -764,7 +848,7 @@ function makeRenderHashes(manifest, graph) {
         description: entry.description,
         generatedDescription: entry.generatedDescription,
         tags: entry.tags,
-        relativeFile: entry.relativeFile,
+        sourcePath: entry.sourcePath,
         sortKey: entry.sortKey,
         created: entry.created,
         modified: entry.modified,
@@ -974,11 +1058,11 @@ async function copyAssets(projectRoot, config, assets) {
   await fs3.emptyDir(destinationRoot);
   for (const asset of assets) {
     await fs3.ensureDir(
-      path4.dirname(path4.join(destinationRoot, asset.relativePath))
+      path4.dirname(path4.join(destinationRoot, asset.assetPath))
     );
     await fs3.copyFile(
       asset.absolutePath,
-      path4.join(destinationRoot, asset.relativePath)
+      path4.join(destinationRoot, asset.assetPath)
     );
   }
   await fs3.ensureDir(path4.join(projectRoot, ".silica/next/public"));
@@ -1039,6 +1123,7 @@ export {
   asFullSlug,
   asRelativeURL,
   asSimpleSlug,
+  createAssetResolutionIndex,
   createWikiLinkResolutionIndex,
   defineConfig,
   formatPropertyLabel,
@@ -1054,19 +1139,23 @@ export {
   isMarkdownFile,
   joinSegments,
   loadConfig,
+  normalizeAssetReference,
   normalizePath,
   normalizeSlug,
   pathToRoot,
   precompute,
   renderMarkdown,
   renderMarkdownHtml,
+  resolveAssetPath,
   resolveConfig,
   resolvePublicAssetPath,
   resolveRelative,
+  resolveRelativeAsset,
   resolveWikiLink,
   scanContent,
   simplifySlug,
   slugToHref,
+  slugifyAssetPath,
   slugifyFilePath,
   slugifySegment,
   tagToHref