@open-press/cli 0.8.0 → 1.1.0

package/template/core/engine/react/style-discovery.mjs

@@ -1,142 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { documentRelativePath } from "../runtime/path-utils.mjs";
-
-// Style discovery — only used to find per-section CSS files for the
-// section-folders preset. MDX content discovery lives in `sources/mdx-resolver`.
-// This module exists because section-scoped CSS (`[data-section-id]`) needs
-// to know which section slugs exist before the source descriptor pass.
-
-const COMPONENT_EXT = ".tsx";
-
-export async function discoverSectionStyles(root = ".", config = {}) {
-  const workspaceRoot = path.resolve(root);
-  const documentRoot = config.paths?.documentRoot ?? path.join(workspaceRoot, "document");
-  const componentsRoot = config.paths?.componentsDir ?? path.join(documentRoot, "components");
-  const sectionsRoot = config.paths?.chaptersDir ?? config.paths?.sourceDir ?? path.join(documentRoot, "chapters");
-  const globalComponents = await discoverComponents(componentsRoot, documentRoot, "global");
-  const sections = await discoverSections(documentRoot, sectionsRoot);
-
-  return {
-    root: workspaceRoot,
-    documentRoot,
-    globalComponents,
-    sections,
-    // Back-compat: `chapters` alias for callers that still expect the old shape.
-    chapters: sections,
-  };
-}
-
-async function discoverSections(documentRoot, sectionsDir) {
-  const entries = await readDirectoryEntries(sectionsDir);
-  const sectionDirs = entries.filter((entry) => entry.isDirectory()).sort(compareSectionDirectories);
-
-  const sections = [];
-  for (const entry of sectionDirs) {
-    const sectionPath = path.join(sectionsDir, entry.name);
-    const contentFiles = await discoverContentFiles(path.join(sectionPath, "content"), documentRoot);
-    const styleFiles = await discoverStyleFiles(path.join(sectionPath, "styles"), documentRoot);
-
-    sections.push({
-      directoryName: entry.name,
-      slug: sectionSlugFromDirectory(entry.name),
-      absolutePath: sectionPath,
-      documentPath: documentRelativePath(sectionPath, documentRoot),
-      contentFiles,
-      styleFiles,
-    });
-  }
-
-  return sections;
-}
-
-async function discoverComponents(componentsDir, documentRoot, scope) {
-  const entries = await readDirectoryEntries(componentsDir);
-  const components = [];
-
-  for (const entry of entries) {
-    if (entry.isFile() && path.extname(entry.name) === COMPONENT_EXT) {
-      const absolutePath = path.join(componentsDir, entry.name);
-      components.push(componentRecord(path.basename(entry.name, COMPONENT_EXT), absolutePath, documentRoot, scope));
-      continue;
-    }
-
-    if (entry.isDirectory()) {
-      const indexPath = path.join(componentsDir, entry.name, `index${COMPONENT_EXT}`);
-      if (await fileExists(indexPath)) {
-        components.push(componentRecord(entry.name, indexPath, documentRoot, scope));
-      }
-    }
-  }
-
-  return components.sort((a, b) => a.name.localeCompare(b.name) || a.documentPath.localeCompare(b.documentPath));
-}
-
-async function discoverContentFiles(contentDir, documentRoot) {
-  return discoverFilesByExtension(contentDir, documentRoot, ".mdx");
-}
-
-async function discoverStyleFiles(stylesDir, documentRoot) {
-  return discoverFilesByExtension(stylesDir, documentRoot, ".css");
-}
-
-async function discoverFilesByExtension(directory, documentRoot, extension) {
-  const entries = await readDirectoryEntries(directory);
-  return entries
-    .filter((entry) => entry.isFile() && path.extname(entry.name) === extension)
-    .sort((a, b) => a.name.localeCompare(b.name))
-    .map((entry) => pathRecord(path.join(directory, entry.name), documentRoot));
-}
-
-function componentRecord(name, absolutePath, documentRoot, scope) {
-  return {
-    name,
-    scope,
-    ...pathRecord(absolutePath, documentRoot),
-  };
-}
-
-function pathRecord(absolutePath, documentRoot) {
-  return {
-    absolutePath,
-    documentPath: documentRelativePath(absolutePath, documentRoot),
-  };
-}
-
-function compareSectionDirectories(a, b) {
-  const left = sectionSortKey(a.name);
-  const right = sectionSortKey(b.name);
-  if (left.order !== right.order) return left.order - right.order;
-  return left.name.localeCompare(right.name);
-}
-
-function sectionSortKey(directoryName) {
-  const match = directoryName.match(/^(\d+)[-_]?(.*)$/);
-  if (!match) {
-    return { order: Number.POSITIVE_INFINITY, name: directoryName };
-  }
-  return { order: Number.parseInt(match[1], 10), name: match[2] || directoryName };
-}
-
-function sectionSlugFromDirectory(directoryName) {
-  return directoryName.replace(/^\d+[-_]?/, "");
-}
-
-async function readDirectoryEntries(directory) {
-  try {
-    return await fs.readdir(directory, { withFileTypes: true });
-  } catch (error) {
-    if (error?.code === "ENOENT") return [];
-    throw error;
-  }
-}
-
-async function fileExists(filePath) {
-  try {
-    const stat = await fs.stat(filePath);
-    return stat.isFile();
-  } catch (error) {
-    if (error?.code === "ENOENT") return false;
-    throw error;
-  }
-}

package/template/core/engine/runtime/config.d.mts

@@ -1,40 +0,0 @@
-export interface ResolvedConfig {
-  root: string;
-  configPath: string;
-  title: string;
-  documentDir: string;
-  sourceDir: string;
-  mediaDir: string;
-  themeDir: string;
-  designDoc: string;
-  componentsDir: string;
-  publicDir: string;
-  outputDir: string;
-  pdf: {
-    filename: string;
-  };
-  deploy: {
-    adapter: string;
-    source: string;
-    projectName: string | null;
-    commitDirty: boolean;
-    requiresConfirmation: boolean;
-  };
-  paths: {
-    documentRoot: string;
-    sourceDir: string;
-    mediaDir: string;
-    themeDir: string;
-    designDoc: string;
-    componentsDir: string;
-    publicDir: string;
-    outputDir: string;
-    pdf: string;
-    deploySource: string;
-    deployMetadata: string;
-  };
-}
-
-export function loadConfig(root?: string): Promise<ResolvedConfig>;
-export function normalizeConfig(root: string, userConfig?: Record<string, unknown>, configPath?: string): ResolvedConfig;
-export function publicPdfHref(config: ResolvedConfig): string;

package/template/core/engine/runtime/config.mjs

@@ -1,175 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-
-const DEFAULT_CONFIG = {
-  title: "OpenPress Document",
-  subtitle: "",
-  organization: "",
-  workspaceLabel: "",
-  documentDir: ".",
-  sourceDir: "content",
-  mediaDir: "media",
-  themeDir: "theme",
-  designDoc: "design.md",
-  componentsDir: "components",
-  publicDir: "public/openpress",
-  outputDir: "dist",
-  captionNumbering: {
-    figure: "Figure",
-    table: "Table",
-    separator: " ",
-  },
-  pdf: {
-    filename: "document.pdf",
-  },
-  deploy: {
-    adapter: "cloudflare-pages",
-    source: ".deploy/openpress",
-    projectName: null,
-    commitDirty: false,
-    requiresConfirmation: true,
-  },
-};
-
-export async function loadConfig(root = ".") {
-  const workspaceRoot = path.resolve(root);
-  const configPath = path.join(workspaceRoot, "openpress.config.mjs");
-  const rootConfig = await readUserConfig(configPath);
-  const { config, sourceConfigPath } = await resolveUserConfig(workspaceRoot, rootConfig, configPath);
-  return normalizeConfig(workspaceRoot, config, sourceConfigPath);
-}
-
-export function normalizeConfig(root, userConfig = {}, configPath = path.join(root, "openpress.config.mjs")) {
-  const config = {
-    root: path.resolve(root),
-    configPath,
-    title: stringValue(userConfig.title, DEFAULT_CONFIG.title),
-    subtitle: optionalStringValue(userConfig.subtitle, DEFAULT_CONFIG.subtitle) ?? "",
-    organization: optionalStringValue(userConfig.organization, DEFAULT_CONFIG.organization) ?? "",
-    workspaceLabel: optionalStringValue(userConfig.workspaceLabel, DEFAULT_CONFIG.workspaceLabel) ?? "",
-    documentDir: documentPathValue(userConfig.documentDir, DEFAULT_CONFIG.documentDir),
-    sourceDir: relativePathValue(userConfig.sourceDir, DEFAULT_CONFIG.sourceDir),
-    mediaDir: relativePathValue(userConfig.mediaDir, DEFAULT_CONFIG.mediaDir),
-    themeDir: relativePathValue(userConfig.themeDir, DEFAULT_CONFIG.themeDir),
-    designDoc: relativePathValue(userConfig.designDoc, DEFAULT_CONFIG.designDoc),
-    componentsDir: relativePathValue(userConfig.componentsDir, DEFAULT_CONFIG.componentsDir),
-    publicDir: relativePathValue(userConfig.publicDir, DEFAULT_CONFIG.publicDir),
-    outputDir: relativePathValue(userConfig.outputDir, DEFAULT_CONFIG.outputDir),
-    captionNumbering: captionNumberingValue(userConfig.captionNumbering, DEFAULT_CONFIG.captionNumbering),
-    pdf: {
-      filename: fileNameValue(userConfig.pdf?.filename, DEFAULT_CONFIG.pdf.filename),
-    },
-    deploy: {
-      adapter: stringValue(userConfig.deploy?.adapter, DEFAULT_CONFIG.deploy.adapter),
-      source: relativePathValue(userConfig.deploy?.source, DEFAULT_CONFIG.deploy.source),
-      projectName: optionalStringValue(userConfig.deploy?.projectName, DEFAULT_CONFIG.deploy.projectName),
-      commitDirty: booleanValue(userConfig.deploy?.commitDirty, DEFAULT_CONFIG.deploy.commitDirty),
-      requiresConfirmation: booleanValue(userConfig.deploy?.requiresConfirmation, DEFAULT_CONFIG.deploy.requiresConfirmation),
-    },
-  };
-
-  const documentRoot = config.documentDir === "." ? config.root : path.join(config.root, config.documentDir);
-  config.paths = {
-    documentRoot,
-    sourceDir: path.join(documentRoot, config.sourceDir),
-    mediaDir: path.join(documentRoot, config.mediaDir),
-    themeDir: path.join(documentRoot, config.themeDir),
-    designDoc: path.join(documentRoot, config.designDoc),
-    componentsDir: path.join(documentRoot, config.componentsDir),
-    publicDir: path.join(config.root, config.publicDir),
-    outputDir: path.join(config.root, config.outputDir),
-    pdf: path.join(config.root, config.outputDir, config.pdf.filename),
-    deploySource: path.join(config.root, config.deploy.source),
-    deployMetadata: path.join(config.root, config.deploy.source, "openpress", "deploy.json"),
-  };
-
-  return config;
-}
-
-export function publicPdfHref(config) {
-  return `/${config.pdf.filename}`;
-}
-
-async function readUserConfig(configPath) {
-  try {
-    const stat = await fs.stat(configPath);
-    const configUrl = `${pathToFileURL(configPath).href}?mtime=${stat.mtimeMs}`;
-    const mod = await import(configUrl);
-    return mod.default ?? {};
-  } catch (error) {
-    if (error?.code === "ENOENT") return {};
-    throw error;
-  }
-}
-
-async function resolveUserConfig(root, rootConfig, configPath) {
-  const documentConfigPath = configPathValue(rootConfig.config ?? rootConfig.documentConfig);
-  if (!documentConfigPath) {
-    return { config: rootConfig, sourceConfigPath: configPath };
-  }
-
-  const sourceConfigPath = path.resolve(root, documentConfigPath);
-  const documentConfig = await readUserConfig(sourceConfigPath);
-  return {
-    config: { ...documentConfig, ...rootConfig },
-    sourceConfigPath,
-  };
-}
-
-function stringValue(value, fallback) {
-  return typeof value === "string" && value.trim() ? value.trim() : fallback;
-}
-
-function optionalStringValue(value, fallback) {
-  if (value === null) return null;
-  if (typeof value === "string" && value.trim()) return value.trim();
-  return fallback;
-}
-
-function captionNumberingValue(value, fallback) {
-  const input = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-  return {
-    figure: optionalStringValue(input.figure, fallback.figure) ?? fallback.figure,
-    table: optionalStringValue(input.table, fallback.table) ?? fallback.table,
-    separator: typeof input.separator === "string" ? input.separator : fallback.separator,
-  };
-}
-
-function booleanValue(value, fallback) {
-  return typeof value === "boolean" ? value : fallback;
-}
-
-function fileNameValue(value, fallback) {
-  const fileName = stringValue(value, fallback);
-  if (fileName.includes("/") || fileName.includes("\\") || fileName === "." || fileName === "..") {
-    throw new Error(`OpenPress config pdf.filename must be a file name, got: ${fileName}`);
-  }
-  return fileName;
-}
-
-function configPathValue(value) {
-  if (typeof value !== "string" || !value.trim()) return null;
-  return relativePathValue(value, null);
-}
-
-function documentPathValue(value, fallback) {
-  const raw = stringValue(value, fallback).replaceAll("\\", "/");
-  if (path.isAbsolute(raw)) throw new Error(`OpenPress config paths must be relative, got: ${raw}`);
-  const normalized = path.posix.normalize(raw).replace(/^\.\//, "");
-  if (normalized === ".") return ".";
-  if (!normalized || normalized === ".." || normalized.startsWith("../")) {
-    throw new Error(`OpenPress config path escapes workspace: ${raw}`);
-  }
-  return normalized;
-}
-
-function relativePathValue(value, fallback) {
-  const raw = stringValue(value, fallback).replaceAll("\\", "/");
-  if (path.isAbsolute(raw)) throw new Error(`OpenPress config paths must be relative, got: ${raw}`);
-  const normalized = path.posix.normalize(raw).replace(/^\.\//, "");
-  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) {
-    throw new Error(`OpenPress config path escapes workspace: ${raw}`);
-  }
-  return normalized;
-}

package/template/core/engine/runtime/file-utils.mjs

@@ -1,106 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { loadConfig } from "./config.mjs";
-import { readKatexCss } from "../output/katex-assets.mjs";
-
-const CONTENT_CSS_LAYERS = [
-  "base/page-contract.css",
-  "base/typography.css",
-  "page-surfaces/cover.css",
-  { path: "page-surfaces/chapter-opener.css", optional: true },
-  "page-surfaces/back-cover.css",
-  "page-surfaces/toc.css",
-  "shell/reader-controls.css",
-  "base/print.css",
-];
-
-export async function copyDirectory(src, dst) {
-  await fs.rm(dst, { recursive: true, force: true });
-  await fs.mkdir(path.dirname(dst), { recursive: true });
-  await fs.cp(src, dst, { recursive: true });
-}
-
-export async function writeContentCss(root, targetDir, config) {
-  config ??= await loadConfig(root);
-  const css = await buildContentCss(root, config);
-  await fs.mkdir(targetDir, { recursive: true });
-  await fs.writeFile(path.join(targetDir, "content.css"), css, "utf8");
-}
-
-export async function buildContentCss(root, config) {
-  config ??= await loadConfig(root);
-  const contentAssetsDir = config.paths.themeDir;
-  const parts = [];
-  for (const layer of CONTENT_CSS_LAYERS) {
-    const relativePath = typeof layer === "string" ? layer : layer.path;
-    const cssPath = path.join(contentAssetsDir, relativePath);
-    let css;
-    try {
-      css = await fs.readFile(cssPath, "utf8");
-    } catch (error) {
-      if (typeof layer !== "string" && layer.optional && error.code === "ENOENT") continue;
-      throw error;
-    }
-    parts.push(`/* === ${relativePath} === */\n`);
-    parts.push(css.trimEnd());
-    parts.push("\n\n");
-  }
-  parts.push("/* === engine/katex.css === */\n");
-  parts.push((await readKatexCss()).trimEnd());
-  parts.push("\n\n");
-  return parts.join("");
-}
-
-export async function writeComponentsCss(root, targetDir, config) {
-  config ??= await loadConfig(root);
-  const css = await buildComponentsCss(root, config);
-  await fs.mkdir(targetDir, { recursive: true });
-  await fs.writeFile(path.join(targetDir, "components.css"), css, "utf8");
-}
-
-export async function buildComponentsCss(root, config) {
-  config ??= await loadConfig(root);
-  const parts = [];
-  await appendCssDirectory(parts, path.join(config.paths.themeDir, "patterns"), "theme/patterns");
-  await appendComponentScopedCss(parts, config.paths.componentsDir);
-  return parts.join("");
-}
-
-async function appendCssDirectory(parts, directory, labelPrefix) {
-  let entries;
-  try {
-    entries = await fs.readdir(directory);
-  } catch {
-    return;
-  }
-  for (const name of entries.filter((entry) => entry.endsWith(".css")).sort()) {
-    parts.push(`/* === ${labelPrefix}/${name} === */\n`);
-    parts.push((await fs.readFile(path.join(directory, name), "utf8")).trimEnd());
-    parts.push("\n\n");
-  }
-}
-
-async function appendComponentScopedCss(parts, componentsDir) {
-  let entries;
-  try {
-    entries = await fs.readdir(componentsDir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-
-  for (const entry of entries.filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
-    const cssPath = path.join(componentsDir, entry.name, "style.css");
-    let css;
-    try {
-      css = await fs.readFile(cssPath, "utf8");
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        continue;
-      }
-      throw error;
-    }
-    parts.push(`/* === components/${entry.name}/style.css === */\n`);
-    parts.push(css.trimEnd());
-    parts.push("\n\n");
-  }
-}

package/template/core/engine/runtime/file-walk.mjs

@@ -1,22 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-export async function walkFiles(directory, visit) {
-  let entries;
-  try {
-    entries = await fs.readdir(directory, { withFileTypes: true });
-  } catch (error) {
-    if (error?.code === "ENOENT") return;
-    throw error;
-  }
-
-  for (const entry of entries) {
-    if (entry.name.startsWith(".")) continue;
-    const absolutePath = path.join(directory, entry.name);
-    if (entry.isDirectory()) {
-      await walkFiles(absolutePath, visit);
-    } else if (entry.isFile()) {
-      await visit(absolutePath);
-    }
-  }
-}