fossbook 0.2.14 → 0.2.16

package/lib/mod/github_cache.js

@@ -0,0 +1,130 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const { loadConfig } = require("./config");
+const { CACHE_SCHEMA_VERSION } = require("./image");
+
+function createGitHubCacheInfo(config, projectRoot = process.cwd()) {
+  const hash = crypto.createHash("sha256");
+  hash.update(
+    JSON.stringify({
+      schema: CACHE_SCHEMA_VERSION,
+      languages: (config.languageConfigs || [config]).map((languageConfig) => ({
+        imageOptimization: languageConfig.imageOptimization,
+        imageMaxWidth: languageConfig.imageMaxWidth,
+        imageMaxWidthOverride: languageConfig.imageMaxWidthOverride,
+        imageWebP: languageConfig.imageWebP,
+        imageResponsiveWidths: languageConfig.imageResponsiveWidths,
+      })),
+    }),
+  );
+
+  updateFile(
+    hash,
+    "package-lock.json",
+    path.join(projectRoot, "package-lock.json"),
+  );
+  updateDirectory(
+    hash,
+    "posts",
+    config.dev.postsdir,
+    (filePath) => {
+      const extension = path.extname(filePath).toLowerCase();
+      return extension === ".md" || extension === ".png";
+    },
+    (filePath) =>
+      path.extname(filePath).toLowerCase() === ".md"
+        ? Buffer.from(extractImageTransformMetadata(filePath))
+        : fs.readFileSync(filePath),
+  );
+  updateDirectory(
+    hash,
+    "static",
+    path.join(config.dev.staticDir, "images"),
+    (filePath) => path.extname(filePath).toLowerCase() === ".png",
+  );
+  updateDirectory(
+    hash,
+    "theme",
+    path.join(config.themePath, "assets"),
+    (filePath) => path.extname(filePath).toLowerCase() === ".png",
+  );
+
+  return {
+    cachePath: config.dev.cacheDir,
+    inputHash: hash.digest("hex"),
+    statusPath: path.join(config.dev.cacheDir, "image-cache-status.json"),
+  };
+}
+
+function writeGitHubCacheOutputs(configPath) {
+  const info = createGitHubCacheInfo(loadConfig(configPath));
+  if (!process.env.GITHUB_OUTPUT) {
+    throw new Error("GITHUB_OUTPUT is required");
+  }
+  fs.appendFileSync(
+    process.env.GITHUB_OUTPUT,
+    `cache-path=${info.cachePath}\n` +
+      `input-hash=${info.inputHash}\n` +
+      `status-path=${info.statusPath}\n`,
+  );
+  return info;
+}
+
+function updateDirectory(
+  hash,
+  label,
+  root,
+  includeFile,
+  readContents = (filePath) => fs.readFileSync(filePath),
+) {
+  if (!fs.existsSync(root)) return;
+
+  const files = [];
+  collectFiles(root, includeFile, files);
+  files.sort((left, right) => left.localeCompare(right));
+  for (const filePath of files) {
+    const relativePath = path.relative(root, filePath).replace(/\\/g, "/");
+    updateContents(hash, `${label}/${relativePath}`, readContents(filePath));
+  }
+}
+
+function collectFiles(directory, includeFile, files) {
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(entryPath, includeFile, files);
+    } else if (entry.isFile() && includeFile(entryPath)) {
+      files.push(entryPath);
+    }
+  }
+}
+
+function updateFile(hash, label, filePath) {
+  if (!fs.existsSync(filePath)) return;
+  updateContents(hash, label, fs.readFileSync(filePath));
+}
+
+function updateContents(hash, label, contents) {
+  hash.update(label);
+  hash.update("\0");
+  hash.update(contents);
+  hash.update("\0");
+}
+
+function extractImageTransformMetadata(filePath) {
+  const markdown = fs.readFileSync(filePath, "utf8");
+  const imagePattern = /!\[[^\]]*\]\(([^\s)]+)(?:\s+["']([^"']*)["'])?\)/g;
+  return JSON.stringify(
+    [...markdown.matchAll(imagePattern)].map((match) => ({
+      href: match[1],
+      publishWidth: match[2]?.match(/publish-width:(\d+)/)?.[1] || null,
+    })),
+  );
+}
+
+module.exports = {
+  createGitHubCacheInfo,
+  extractImageTransformMetadata,
+  writeGitHubCacheOutputs,
+};

package/lib/mod/image.js

@@ -0,0 +1,411 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const sharp = require("sharp");
+
+const CACHE_SCHEMA_VERSION = 4;
+const PNG_OPTIONS = { compressionLevel: 9, adaptiveFiltering: true };
+const WEBP_OPTIONS = { lossless: true, effort: 4 };
+const activeCachePaths = new Set();
+let cacheStats;
+
+function beginImageBuild() {
+  activeCachePaths.clear();
+  cacheStats = {
+    hits: 0,
+    misses: 0,
+    writes: 0,
+    regeneratedImages: new Set(),
+  };
+}
+
+async function pruneImageCache(config) {
+  const cacheDir = getImageCacheDir(config);
+  if (!fs.existsSync(cacheDir)) return;
+
+  await Promise.all(
+    fs.readdirSync(cacheDir).map((fileName) => {
+      const cachePath = path.join(cacheDir, fileName);
+      if (activeCachePaths.has(cachePath)) return Promise.resolve();
+      return fs.promises.rm(cachePath, { recursive: true, force: true });
+    }),
+  );
+}
+
+async function finishImageBuild(config) {
+  const stats = getImageCacheStats();
+  try {
+    await pruneImageCache(config);
+    const cacheRoot = getCacheRoot(config);
+    await fs.promises.mkdir(cacheRoot, { recursive: true });
+    await writeFileAtomically(
+      path.join(cacheRoot, "image-cache-status.json"),
+      JSON.stringify(stats, null, 2) + "\n",
+    );
+  } catch (error) {
+    console.warn(`Warning: Image cache finalization failed. ${error.message}`);
+  }
+  console.log(
+    `Image cache: ${stats.hits} hits, ${stats.misses} misses, ` +
+      `${stats.regeneratedImages} images regenerated.`,
+  );
+  return stats;
+}
+
+function getImageCacheStats() {
+  ensureCacheStats();
+  return {
+    hits: cacheStats.hits,
+    misses: cacheStats.misses,
+    writes: cacheStats.writes,
+    regeneratedImages: cacheStats.regeneratedImages.size,
+  };
+}
+
+async function publishImage(
+  sourcePath,
+  destinationPath,
+  config,
+  requestedMaxWidth,
+  generateWebP = true,
+) {
+  await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
+
+  if (
+    config.imageOptimization === false ||
+    path.extname(sourcePath).toLowerCase() !== ".png"
+  ) {
+    await fs.promises.copyFile(sourcePath, destinationPath);
+    return null;
+  }
+
+  const configuredMaxWidth =
+    Number.isInteger(config.imageMaxWidth) && config.imageMaxWidth > 0
+      ? config.imageMaxWidth
+      : 1400;
+  const maximumOverride =
+    Number.isInteger(config.imageMaxWidthOverride) &&
+    config.imageMaxWidthOverride > 0
+      ? config.imageMaxWidthOverride
+      : 1200;
+  const validRequestedWidth =
+    Number.isInteger(requestedMaxWidth) && requestedMaxWidth > 0;
+  const maxWidth = validRequestedWidth
+    ? Math.min(requestedMaxWidth, maximumOverride)
+    : configuredMaxWidth;
+  const source = await fs.promises.readFile(sourcePath);
+  let sourceMetadata;
+  try {
+    sourceMetadata = await sharp(source).metadata();
+  } catch {
+    await fs.promises.copyFile(sourcePath, destinationPath);
+    return null;
+  }
+  const cacheDir = getImageCacheDir(config);
+  const sourceHash = crypto.createHash("sha256").update(source).digest("hex");
+  const sourceWidth = sourceMetadata.autoOrient?.width ?? sourceMetadata.width;
+  const fallback = await publishPng(
+    sourcePath,
+    source,
+    sourceWidth,
+    sourceHash,
+    destinationPath,
+    cacheDir,
+    maxWidth,
+  );
+
+  if (!generateWebP || config.imageWebP === false) {
+    return { fallback, webp: [] };
+  }
+
+  const responsiveWidths = Array.isArray(config.imageResponsiveWidths)
+    ? config.imageResponsiveWidths
+    : [600, 800, 1000];
+  const effectiveMaxWidth = Math.min(sourceWidth, maxWidth);
+  const widths = [...new Set([...responsiveWidths, effectiveMaxWidth])]
+    .filter((width) => Number.isInteger(width) && width > 0)
+    .filter((width) => width <= effectiveMaxWidth)
+    .sort((left, right) => left - right);
+  const parsedDestination = path.parse(destinationPath);
+  const webp = [];
+
+  for (const width of widths) {
+    const suffix = width === effectiveMaxWidth ? "" : `-${width}`;
+    const fileName = `${parsedDestination.name}${suffix}.webp`;
+    const outputPath = path.join(parsedDestination.dir, fileName);
+    const published = await publishWebP(
+      sourcePath,
+      source,
+      sourceHash,
+      outputPath,
+      cacheDir,
+      width,
+    );
+    if (published) webp.push({ fileName, width });
+  }
+
+  return { fallback, webp };
+}
+
+async function publishPng(
+  sourcePath,
+  source,
+  sourceWidth,
+  sourceHash,
+  destinationPath,
+  cacheDir,
+  maxWidth,
+) {
+  const outputWidth = Math.min(sourceWidth, maxWidth);
+  const cachePath = getCachePath(
+    cacheDir,
+    sourceHash,
+    "png",
+    maxWidth,
+    PNG_OPTIONS,
+  );
+  activeCachePaths.add(cachePath);
+  activeCachePaths.add(getManifestPath(cachePath));
+
+  if (await useCachedEntry(cachePath, "png", outputWidth)) {
+    await fs.promises.copyFile(cachePath, destinationPath);
+    return {
+      fileName: path.basename(destinationPath),
+      width: outputWidth,
+    };
+  }
+
+  recordCacheMiss(sourcePath);
+  let temporaryPath;
+
+  try {
+    await fs.promises.mkdir(cacheDir, { recursive: true });
+    temporaryPath = createTemporaryPath(cachePath);
+    await sharp(source)
+      .rotate()
+      .resize({ width: maxWidth, withoutEnlargement: true })
+      .png(PNG_OPTIONS)
+      .toFile(temporaryPath);
+
+    const optimizedSize = (await fs.promises.stat(temporaryPath)).size;
+    if (sourceWidth <= maxWidth && optimizedSize >= source.length) {
+      await fs.promises.rm(temporaryPath, { force: true });
+      await writeFileAtomically(cachePath, source);
+    } else {
+      await fs.promises.rename(temporaryPath, cachePath);
+    }
+    await writeCacheManifest(cachePath, "png", outputWidth);
+    cacheStats.writes += 1;
+  } catch (error) {
+    if (temporaryPath) await fs.promises.rm(temporaryPath, { force: true });
+    console.warn(
+      `Warning: PNG cache processing failed for ${sourcePath}; publishing the source image. ${error.message}`,
+    );
+    await fs.promises.copyFile(sourcePath, destinationPath);
+    return {
+      fileName: path.basename(destinationPath),
+      width: sourceWidth,
+    };
+  }
+
+  await fs.promises.copyFile(cachePath, destinationPath);
+  return {
+    fileName: path.basename(destinationPath),
+    width: outputWidth,
+  };
+}
+
+async function publishWebP(
+  sourcePath,
+  source,
+  sourceHash,
+  destinationPath,
+  cacheDir,
+  width,
+) {
+  const cachePath = getCachePath(
+    cacheDir,
+    sourceHash,
+    "webp",
+    width,
+    WEBP_OPTIONS,
+  );
+  activeCachePaths.add(cachePath);
+  activeCachePaths.add(getManifestPath(cachePath));
+
+  if (!(await useCachedEntry(cachePath, "webp", width))) {
+    recordCacheMiss(sourcePath);
+    let temporaryPath;
+    try {
+      await fs.promises.mkdir(cacheDir, { recursive: true });
+      temporaryPath = createTemporaryPath(cachePath);
+      await sharp(source)
+        .rotate()
+        .resize({ width, withoutEnlargement: true })
+        .webp(WEBP_OPTIONS)
+        .toFile(temporaryPath);
+      await fs.promises.rename(temporaryPath, cachePath);
+      await writeCacheManifest(cachePath, "webp", width);
+      cacheStats.writes += 1;
+    } catch (error) {
+      if (temporaryPath) await fs.promises.rm(temporaryPath, { force: true });
+      console.warn(
+        `Warning: WebP cache processing failed for ${sourcePath}; publishing only the PNG fallback. ${error.message}`,
+      );
+      return false;
+    }
+  }
+
+  await fs.promises.copyFile(cachePath, destinationPath);
+  return true;
+}
+
+async function useCachedEntry(cachePath, format, width) {
+  ensureCacheStats();
+  const manifestPath = getManifestPath(cachePath);
+  if (!fs.existsSync(cachePath) || !fs.existsSync(manifestPath)) {
+    await Promise.all([
+      fs.promises.rm(cachePath, { recursive: true, force: true }),
+      fs.promises.rm(manifestPath, { recursive: true, force: true }),
+    ]);
+    return false;
+  }
+
+  try {
+    const [contents, manifestContents] = await Promise.all([
+      fs.promises.readFile(cachePath),
+      fs.promises.readFile(manifestPath, "utf8"),
+    ]);
+    const manifest = JSON.parse(manifestContents);
+    const digest = crypto.createHash("sha256").update(contents).digest("hex");
+    if (
+      manifest.schema === CACHE_SCHEMA_VERSION &&
+      manifest.format === format &&
+      manifest.width === width &&
+      manifest.size === contents.length &&
+      manifest.sha256 === digest
+    ) {
+      cacheStats.hits += 1;
+      return true;
+    }
+  } catch {
+    // Invalid cache entries are removed and regenerated below.
+  }
+
+  await fs.promises.rm(cachePath, { recursive: true, force: true });
+  await fs.promises.rm(manifestPath, { recursive: true, force: true });
+  return false;
+}
+
+async function writeCacheManifest(cachePath, format, width) {
+  const contents = await fs.promises.readFile(cachePath);
+  await writeFileAtomically(
+    getManifestPath(cachePath),
+    JSON.stringify({
+      schema: CACHE_SCHEMA_VERSION,
+      format,
+      width,
+      size: contents.length,
+      sha256: crypto.createHash("sha256").update(contents).digest("hex"),
+    }),
+  );
+}
+
+function getManifestPath(cachePath) {
+  return `${cachePath}.json`;
+}
+
+function getCachePath(cacheDir, sourceHash, format, width, options) {
+  const cacheKey = createCacheKey(sourceHash, format, width, options);
+  return path.join(cacheDir, `${cacheKey}.${format}`);
+}
+
+function createCacheKey(
+  sourceHash,
+  format,
+  width,
+  options,
+  encoderVersions = getEncoderVersions(format),
+) {
+  return crypto
+    .createHash("sha256")
+    .update(
+      JSON.stringify({
+        schema: CACHE_SCHEMA_VERSION,
+        sourceHash,
+        format,
+        width,
+        rotate: true,
+        withoutEnlargement: true,
+        options,
+        encoderVersions,
+      }),
+    )
+    .digest("hex");
+}
+
+function getEncoderVersions(format) {
+  return format === "webp"
+    ? {
+        sharp: sharp.versions.sharp,
+        vips: sharp.versions.vips,
+        webp: sharp.versions.webp,
+      }
+    : {
+        sharp: sharp.versions.sharp,
+        vips: sharp.versions.vips,
+        png: sharp.versions.png,
+      };
+}
+
+function createTemporaryPath(cachePath) {
+  return `${cachePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+}
+
+async function writeFileAtomically(destinationPath, contents) {
+  await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
+  const temporaryPath = createTemporaryPath(destinationPath);
+  try {
+    await fs.promises.writeFile(temporaryPath, contents);
+    try {
+      await fs.promises.rename(temporaryPath, destinationPath);
+    } catch (error) {
+      if (error.code !== "EEXIST" && error.code !== "EPERM") throw error;
+      await fs.promises.rm(destinationPath, { force: true });
+      await fs.promises.rename(temporaryPath, destinationPath);
+    }
+  } catch (error) {
+    await fs.promises.rm(temporaryPath, { force: true });
+    throw error;
+  }
+}
+
+function recordCacheMiss(sourcePath) {
+  ensureCacheStats();
+  cacheStats.misses += 1;
+  cacheStats.regeneratedImages.add(sourcePath);
+}
+
+function ensureCacheStats() {
+  if (!cacheStats) beginImageBuild();
+}
+
+function getCacheRoot(config) {
+  return (
+    config.dev.cacheDir || path.resolve(config.cacheDir || ".fossbook-cache")
+  );
+}
+
+function getImageCacheDir(config) {
+  return path.join(getCacheRoot(config), "images");
+}
+
+module.exports = {
+  CACHE_SCHEMA_VERSION,
+  beginImageBuild,
+  createCacheKey,
+  finishImageBuild,
+  getImageCacheStats,
+  pruneImageCache,
+  publishImage,
+};