@riebeckite/core 0.0.21 → 0.0.22

package/dist/index.js

@@ -1515,9 +1515,9 @@ import remarkDirective from "remark-directive";
 import remarkFrontmatter from "remark-frontmatter";
 import remarkGfm from "remark-gfm";
 import remarkMath from "remark-math";
-import remarkParse from "remark-parse";
+import remarkParse2 from "remark-parse";
 import remarkRehype from "remark-rehype";
-import { unified } from "unified";
+import { unified as unified2 } from "unified";
 import { matter as matter2 } from "vfile-matter";
 
 // src/content/content_dependency_tracker.ts
@@ -1896,6 +1896,117 @@ function extractFrontmatter(markdown) {
   return vfile.data.matter ?? {};
 }
 
+// src/content/markdown_image.ts
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+function extractMarkdownImages(markdown, sourceSlug) {
+  const tree = unified().use(remarkParse).parse(markdown);
+  const definitions = /* @__PURE__ */ new Map();
+  const references = [];
+  const urls = [];
+  visitMarkdownNodes(tree, (node) => {
+    if (node.type === "definition" && typeof node.url === "string") {
+      const identifier = normalizeIdentifier(node.identifier);
+      if (identifier) definitions.set(identifier, node.url);
+    }
+    if (node.type === "image" && typeof node.url === "string") {
+      urls.push(node.url);
+    }
+    if (node.type === "imageReference") {
+      const identifier = normalizeIdentifier(node.identifier);
+      if (identifier) references.push(identifier);
+    }
+  });
+  for (const reference of references) {
+    const url = definitions.get(reference);
+    if (url) urls.push(url);
+  }
+  return uniqueImages(
+    urls.map((url) => resolveMarkdownImage(url, sourceSlug)).filter((image) => image !== null)
+  );
+}
+function normalizeMarkdownImages(sourceSlug) {
+  return () => (tree) => {
+    const definitions = /* @__PURE__ */ new Map();
+    const references = /* @__PURE__ */ new Set();
+    visitMarkdownNodes(tree, (node) => {
+      if (node.type === "definition" && typeof node.url === "string") {
+        const identifier = normalizeIdentifier(node.identifier);
+        if (identifier) definitions.set(identifier, node);
+      }
+      if (node.type === "image" && typeof node.url === "string") {
+        const image = resolveMarkdownImage(node.url, sourceSlug);
+        if (image) node.url = image.url;
+      }
+      if (node.type === "imageReference") {
+        const identifier = normalizeIdentifier(node.identifier);
+        if (identifier) references.add(identifier);
+      }
+    });
+    for (const identifier of references) {
+      const definition = definitions.get(identifier);
+      if (!definition || typeof definition.url !== "string") continue;
+      const image = resolveMarkdownImage(definition.url, sourceSlug);
+      if (image) definition.url = image.url;
+    }
+  };
+}
+function resolveMarkdownImage(input, sourceSlug) {
+  if (input.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(input)) {
+    return null;
+  }
+  const [pathAndQuery, hash4 = ""] = splitOnce(input, "#");
+  const [rawPath, query = ""] = splitOnce(pathAndQuery, "?");
+  const decodedPath = decodeUriPath(rawPath);
+  if (!decodedPath || !isImagePath(decodedPath)) return null;
+  const path6 = resolveContentAssetPath(sourceSlug, decodedPath);
+  if (!path6) return null;
+  const encodedPath = path6.split("/").map(encodeURIComponent).join("/");
+  const suffix = `${query ? `?${query}` : ""}${hash4 ? `#${hash4}` : ""}`;
+  return { path: path6, url: `/${encodedPath}${suffix}` };
+}
+function resolveContentAssetPath(sourceSlug, targetPath) {
+  const sourceDirectory = sourceSlug.includes("/") ? sourceSlug.slice(0, sourceSlug.lastIndexOf("/")) : "";
+  const parts = [
+    ...targetPath.startsWith("/") ? [] : sourceDirectory.split("/"),
+    ...normalizeContentPath(targetPath).replace(/^\/+/, "").split("/")
+  ];
+  const normalized = [];
+  for (const part of parts) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      if (normalized.length === 0) return null;
+      normalized.pop();
+      continue;
+    }
+    normalized.push(part);
+  }
+  return normalized.length > 0 ? normalized.join("/").normalize("NFC") : null;
+}
+function visitMarkdownNodes(node, visitor) {
+  const markdownNode = node;
+  visitor(markdownNode);
+  for (const child of markdownNode.children ?? [])
+    visitMarkdownNodes(child, visitor);
+}
+function normalizeIdentifier(value) {
+  return typeof value === "string" ? value.toLowerCase() : null;
+}
+function decodeUriPath(path6) {
+  try {
+    return decodeURI(path6);
+  } catch {
+    return null;
+  }
+}
+function splitOnce(value, separator) {
+  const index = value.indexOf(separator);
+  return index < 0 ? [value] : [value.slice(0, index), value.slice(index + 1)];
+}
+function uniqueImages(images) {
+  return [...new Map(images.map((image) => [image.path, image])).values()];
+}
+
 // src/plugin/plugin_cache.ts
 import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
 import fs3 from "node:fs/promises";
@@ -2178,9 +2289,9 @@ var Pipeline = class {
         this.options.onPersistentContentCacheResult?.("bypass");
       }
     }
-    const processor = unified();
+    const processor = unified2();
     const plugins = this.resolvePlugins();
-    this.use(processor, remarkParse);
+    this.use(processor, remarkParse2);
     this.use(processor, remarkDirective);
     this.use(processor, remarkFrontmatter, ["yaml", "toml"]);
     this.use(processor, function loadFrontmatter() {
@@ -2220,6 +2331,9 @@ var Pipeline = class {
       ...markdownPipelineContext,
       recordLinkResolution: dependencyTracker ? (id, value) => dependencyTracker.recordLinkResolution(id, value) : void 0
     });
+    if (context.sourceSlug) {
+      this.use(processor, normalizeMarkdownImages(context.sourceSlug));
+    }
     this.use(processor, remarkRehype, { allowDangerousHtml: true });
     this.use(processor, rehypeRaw);
     for (const plugin of plugins) {
@@ -2464,9 +2578,9 @@ function visitMarkdownLinkNodes(node, visitor) {
 function normalizeMarkdownLinkUrl(url, context) {
   if (!context.sourceSlug) return null;
   if (!isMarkdownContentLink(url)) return null;
-  const [pathAndQuery, hash4 = ""] = splitOnce(url, "#");
-  const [rawPath, query = ""] = splitOnce(pathAndQuery, "?");
-  const decodedPath = decodeUriPath(rawPath);
+  const [pathAndQuery, hash4 = ""] = splitOnce2(url, "#");
+  const [rawPath, query = ""] = splitOnce2(pathAndQuery, "?");
+  const decodedPath = decodeUriPath2(rawPath);
   if (!decodedPath?.toLowerCase().endsWith(".md")) return null;
   const resolvedSlug = resolveRelativeMarkdownSlug(
     context.sourceSlug,
@@ -2527,14 +2641,14 @@ function resolveRelativeMarkdownSlug(sourceSlug, targetPath) {
   }
   return normalizedParts.join("/").replace(/\.md$/i, "");
 }
-function decodeUriPath(path6) {
+function decodeUriPath2(path6) {
   try {
     return decodeURI(path6);
   } catch {
     return null;
   }
 }
-function splitOnce(value, separator) {
+function splitOnce2(value, separator) {
   const index = value.indexOf(separator);
   if (index < 0) return [value];
   return [value.slice(0, index), value.slice(index + separator.length)];
@@ -2857,6 +2971,13 @@ var PluginRuntime = class {
   collectGeneratedOutputs() {
     return this.generatedOutputs.all();
   }
+  emitCoreAsset(path6, content) {
+    this.generatedOutputs.sinkFor("core").emitAsset({
+      path: path6,
+      content,
+      dependencies: [{ type: "file", path: path6 }]
+    });
+  }
   async resolvePage(pathname, manifest, contentIndex) {
     const matches = [];
     const requestedPathname = normalizePagePath(pathname);
@@ -4008,9 +4129,14 @@ function readOptionalStableId(value) {
 var ManifestBuilder = class {
   createEntry(slug, markdown, processed, contentIndex, location, publishing) {
     const links = extractContentLinks(markdown, contentIndex);
-    const assets = links.filter(
-      (link) => (link.kind === "image" || link.kind === "attachment") && link.slug !== null
-    ).map((link) => ({ path: link.slug }));
+    const assets = [
+      ...links.filter(
+        (link) => (link.kind === "image" || link.kind === "attachment") && link.slug !== null
+      ).map((link) => ({ path: link.slug })),
+      ...extractMarkdownImages(markdown, slug).map((image) => ({
+        path: image.path
+      }))
+    ];
     const contentId = resolveContentStableId(processed.frontmatter);
     return {
       slug,
@@ -4139,6 +4265,11 @@ function determineOutputChanges(input) {
     (input.previousState?.outputs ?? []).map((output) => [output.path, output])
   );
   const changedContent = collectChangedContent(input);
+  const changedFiles = /* @__PURE__ */ new Set([
+    ...input.changeSet.added,
+    ...input.changeSet.changed,
+    ...input.changeSet.removed
+  ]);
   const changedTags = collectChangedTags(
     input.previousState,
     input.manifest,
@@ -4152,7 +4283,13 @@ function determineOutputChanges(input) {
   const affected = /* @__PURE__ */ new Map();
   const unchanged = [];
   for (const output of current) {
-    if (isOutputAffected(output, changedContent, changedTags, changedFolders)) {
+    if (isOutputAffected(
+      output,
+      changedContent,
+      changedTags,
+      changedFolders,
+      changedFiles
+    )) {
       affected.set(output.path, output);
     } else {
       unchanged.push(output);
@@ -4225,7 +4362,7 @@ function contentOutput(entry, dependencies) {
     dependencies: [{ type: "content", slug: entry.slug }, ...dependencies]
   };
 }
-function isOutputAffected(output, changedContent, changedTags, changedFolders) {
+function isOutputAffected(output, changedContent, changedTags, changedFolders, changedFiles) {
   for (const dependency of output.dependencies) {
     if (dependency.type === "unknown") return true;
     if (dependency.type === "global") return changedContent.size > 0;
@@ -4237,6 +4374,9 @@ function isOutputAffected(output, changedContent, changedTags, changedFolders) {
     if (dependency.type === "folder" && changedFolders.has(dependency.folder)) {
       return true;
     }
+    if (dependency.type === "file" && changedFiles.has(dependency.path)) {
+      return true;
+    }
   }
   return false;
 }
@@ -4592,6 +4732,7 @@ var ContentManager = class {
           ...await this.pluginRuntime.collectDiagnostics(contentIndex)
         ];
         await this.pluginRuntime.runBuildEnd(manifest, contentIndex);
+        await this.emitPublicImageAssets(manifest);
         manifest.generatedOutputs = this.pluginRuntime.collectGeneratedOutputs();
         const pluginPageOutputs = await this.pluginRuntime.getPageOutputs(
           manifest,
@@ -4834,6 +4975,21 @@ var ContentManager = class {
     this.isBuildTime = true;
     this.pluginRuntime.enableBuildTime();
   }
+  async emitPublicImageAssets(manifest) {
+    const imagePaths = new Set(
+      manifest.publicEntries.flatMap(
+        (entry) => entry.assets.map((asset) => normalizeContentPath(asset.path)).filter(isImagePath)
+      )
+    );
+    const entriesByPath = new Map(
+      (await this.source.scan()).map((entry) => [entry.path, entry])
+    );
+    for (const path6 of imagePaths) {
+      const entry = entriesByPath.get(path6);
+      if (entry)
+        this.pluginRuntime.emitCoreAsset(path6, await this.source.read(entry));
+    }
+  }
   observability() {
     return this.pipelineOptions.observability ?? noopObservability;
   }

package/dist/src/content/content_manager.d.ts

@@ -80,6 +80,7 @@ export declare class ContentManager {
     private ensureRoutableSlugs;
     private resolveRoutableSlugs;
     private enableBuildTime;
+    private emitPublicImageAssets;
     private observability;
 }
 declare module "../pipeline" {

package/dist/src/content/markdown_image.d.ts

@@ -0,0 +1,8 @@
+import type { Node } from "unist";
+type MarkdownImage = {
+    readonly path: string;
+    readonly url: string;
+};
+export declare function extractMarkdownImages(markdown: string, sourceSlug: string): readonly MarkdownImage[];
+export declare function normalizeMarkdownImages(sourceSlug: string): () => (tree: Node) => void;
+export {};

package/dist/src/plugin/plugin_runtime.d.ts

@@ -2,7 +2,7 @@ import type { OutputDescriptor } from "../content/output_dependency.js";
 import type { PipelineOptions } from "../pipeline.js";
 import type { ContentLocationInput, ContentManifest, ContentManifestEntry, ContentPublicLocation, PluginPageRoute } from "../types/content_manifest.js";
 import type { Diagnostic } from "../types/diagnostic.js";
-import type { GeneratedOutput } from "../types/generated_output.js";
+import type { GeneratedOutput, GeneratedOutputContent } from "../types/generated_output.js";
 import type { OutputDependency } from "../types/output_dependency.js";
 import { type PluginClientEntry } from "../types/plugin_asset.js";
 import type { ResolvedPluginPage } from "../types/plugin_page.js";
@@ -58,6 +58,7 @@ export declare class PluginRuntime {
     collectClientEntries(): PluginClientEntry[];
     /** Returns registered outputs sorted by path for a deterministic build. */
     collectGeneratedOutputs(): GeneratedOutput[];
+    emitCoreAsset(path: string, content: GeneratedOutputContent): void;
     resolvePage(pathname: string, manifest: ContentManifest, contentIndex: Map<string, string>): Promise<ResolvedPluginPage | null>;
     getPagePaths(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<readonly string[]>;
     getPageRoutes(manifest: ContentManifest, contentIndex: Map<string, string>): Promise<readonly PluginPageRoute[]>;

package/dist/src/types/output_dependency.d.ts

@@ -7,6 +7,9 @@ export type OutputDependency = {
 } | {
     readonly type: "folder";
     readonly folder: string;
+} | {
+    readonly type: "file";
+    readonly path: string;
 } | {
     readonly type: "global";
 } | {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/core",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
   },
   "devDependencies": {
     "tsx": "^4.22.4",
-    "@riebeckite/test": "0.0.21"
+    "@riebeckite/test": "0.0.22"
   },
   "repository": {
     "type": "git",