@seanmozeik/markdown-display 0.3.5 → 0.4.0

package/src/cli.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env bun
+
+const hasArg = (name: string): boolean => process.argv.includes(name);
+
+const wantsRaw = (): boolean => hasArg('--raw') || hasArg('-r');
+
+const isFlagValue = (args: readonly string[], index: number): boolean => {
+  const previous = args[index - 1];
+  return previous === '--theme' || previous === '-t' || previous === '--width' || previous === '-w';
+};
+
+const rawInputFiles = (): string[] =>
+  process.argv.slice(2).filter((arg, index, args) => {
+    if (arg === '--raw' || arg === '-r') {
+      return false;
+    }
+    if (arg.startsWith('-')) {
+      return false;
+    }
+    return !isFlagValue(args, index);
+  });
+
+const runRaw = async (): Promise<void> => {
+  const files = rawInputFiles();
+  const chunks: string[] = [];
+
+  if (files.length === 0) {
+    chunks.push(await Bun.stdin.text());
+  } else {
+    chunks.push(...(await Promise.all(files.map((path) => Bun.file(path).text()))));
+  }
+
+  console.log(chunks.join('\n'));
+};
+
+const runCli = async (): Promise<void> => {
+  if (wantsRaw()) {
+    await runRaw();
+    return;
+  }
+
+  const { runCliApp } = await import('./cli-app');
+  runCliApp();
+};
+
+const formatBootstrapError = (error: unknown): string => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+
+const isMain = (): boolean => {
+  return import.meta.filename === Bun.main;
+};
+
+if (isMain()) {
+  await runCli().catch((error: unknown) => {
+    console.error(formatBootstrapError(error));
+    process.exitCode = 1;
+  });
+}
+
+export { runCli };

package/src/config/errors.ts

@@ -0,0 +1,6 @@
+import { Schema } from 'effect';
+
+export class ConfigParseError extends Schema.TaggedErrorClass<ConfigParseError>()(
+  'ConfigParseError',
+  { cause: Schema.Unknown, path: Schema.String },
+) {}

package/src/config/index.ts

@@ -0,0 +1,183 @@
+import { Effect } from 'effect';
+
+import defaultToml from '../lib/default-config.toml';
+import { configTomlPath } from '../paths';
+import { ConfigParseError } from './errors';
+import { ConfigReadError } from './read-error';
+
+interface MdConfig {
+  theme: string;
+  width: 'auto' | number;
+  truecolor: 'auto' | boolean;
+  nerd_fonts: 'auto' | boolean;
+  display: { padding: boolean; maxWidth: number };
+  code: { wrap: boolean; continuation: string };
+  text: { hyphenation: boolean; locale: string };
+  links: { osc8: 'auto' | boolean; show_urls: boolean };
+  pager: { command: string; args: string[] };
+}
+
+const isPlainRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const baseConfigRecord = isPlainRecord(defaultToml) ? defaultToml : {};
+
+const deepMerge = (
+  target: Record<string, unknown>,
+  source: Record<string, unknown>,
+): Record<string, unknown> => {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (isPlainRecord(sourceVal) && isPlainRecord(targetVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else if (sourceVal !== undefined) {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+};
+
+const parseTomlConfig = Effect.fn('config.parse-toml')(function* parseTomlConfigGen(
+  text: string,
+  path: string,
+) {
+  const parsed = yield* Effect.try({
+    catch: (cause) => new ConfigParseError({ cause, path }),
+    try: () => Bun.TOML.parse(text),
+  });
+  if (!isPlainRecord(parsed)) {
+    return yield* new ConfigParseError({ cause: `${path} must be a TOML table`, path });
+  }
+  return parsed;
+});
+
+const readBoolean = (value: unknown, fallback: boolean): boolean =>
+  typeof value === 'boolean' ? value : fallback;
+
+const readString = (value: unknown, fallback: string): string =>
+  typeof value === 'string' ? value : fallback;
+
+const readWidth = (value: unknown, fallback: MdConfig['width']): MdConfig['width'] =>
+  value === 'auto' || typeof value === 'number' ? value : fallback;
+
+const isTriState = (value: unknown): value is 'auto' | boolean =>
+  value === 'auto' || typeof value === 'boolean';
+
+const readTriState = (value: unknown, fallback: 'auto' | boolean): 'auto' | boolean =>
+  isTriState(value) ? value : fallback;
+
+const readNumber = (value: unknown, fallback: number): number =>
+  typeof value === 'number' ? value : fallback;
+
+const readStringList = (value: unknown, fallback: string[]): string[] =>
+  Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === 'string')
+    : fallback;
+
+const recordField = (
+  merged: Record<string, unknown>,
+  base: Record<string, unknown>,
+  key: string,
+): Record<string, unknown> => {
+  if (isPlainRecord(merged[key])) {
+    return merged[key];
+  }
+  if (isPlainRecord(base[key])) {
+    return base[key];
+  }
+  return {};
+};
+
+const readMaxWidth = (merged: Record<string, unknown>, base: Record<string, unknown>): number => {
+  const mergedDisplay = recordField(merged, base, 'display');
+  const baseDisplay = isPlainRecord(base['display']) ? base['display'] : {};
+  return readNumber(mergedDisplay['maxWidth'], readNumber(baseDisplay['maxWidth'], 0));
+};
+
+const buildMdConfig = (merged: Record<string, unknown>): MdConfig => {
+  const base = baseConfigRecord;
+  const mergedCode = recordField(merged, base, 'code');
+  const baseCode = recordField(base, base, 'code');
+  const mergedDisplay = recordField(merged, base, 'display');
+  const baseDisplay = recordField(base, base, 'display');
+  const mergedLinks = recordField(merged, base, 'links');
+  const baseLinks = recordField(base, base, 'links');
+  const mergedPager = recordField(merged, base, 'pager');
+  const basePager = recordField(base, base, 'pager');
+  const mergedText = recordField(merged, base, 'text');
+  const baseText = recordField(base, base, 'text');
+
+  return {
+    code: {
+      continuation: readString(
+        mergedCode['continuation'],
+        readString(baseCode['continuation'], '→'),
+      ),
+      wrap: readBoolean(mergedCode['wrap'], readBoolean(baseCode['wrap'], true)),
+    },
+    display: {
+      maxWidth: readMaxWidth(merged, base),
+      padding: readBoolean(mergedDisplay['padding'], readBoolean(baseDisplay['padding'], true)),
+    },
+    links: {
+      osc8: readTriState(mergedLinks['osc8'], readTriState(baseLinks['osc8'], 'auto')),
+      show_urls: readBoolean(mergedLinks['show_urls'], readBoolean(baseLinks['show_urls'], false)),
+    },
+    nerd_fonts: readTriState(merged['nerd_fonts'], readTriState(base['nerd_fonts'], 'auto')),
+    pager: {
+      args: readStringList(mergedPager['args'], readStringList(basePager['args'], [])),
+      command: readString(mergedPager['command'], readString(basePager['command'], 'less')),
+    },
+    text: {
+      hyphenation: readBoolean(
+        mergedText['hyphenation'],
+        readBoolean(baseText['hyphenation'], true),
+      ),
+      locale: readString(mergedText['locale'], readString(baseText['locale'], 'en-us')),
+    },
+    theme: readString(merged['theme'], readString(base['theme'], 'catppuccin-frappe')),
+    truecolor: readTriState(merged['truecolor'], readTriState(base['truecolor'], 'auto')),
+    width: readWidth(merged['width'], readWidth(base['width'], 'auto')),
+  };
+};
+
+const normalizeConfig = (raw: Record<string, unknown>): MdConfig =>
+  buildMdConfig(deepMerge(baseConfigRecord, raw));
+
+const DEFAULT_CONFIG: MdConfig = normalizeConfig({});
+
+const loadConfigFile = Effect.fn('config.load-file')(function* loadConfigFileGen(
+  configPath: string,
+) {
+  const file = Bun.file(configPath);
+  const exists = yield* Effect.tryPromise({
+    catch: (cause) => new ConfigReadError({ cause, path: configPath }),
+    try: () => file.exists(),
+  });
+  if (!exists) {
+    return DEFAULT_CONFIG;
+  }
+  const text = yield* Effect.tryPromise({
+    catch: (cause) => new ConfigReadError({ cause, path: configPath }),
+    try: () => file.text(),
+  });
+  const parsed = yield* parseTomlConfig(text, configPath);
+  return normalizeConfig(parsed);
+});
+
+/**
+ * Loads `~/.config/md/config.toml` when present; otherwise defaults.
+ */
+const loadUserConfig = Effect.fn('config.load')(function* loadUserConfig() {
+  const path = configTomlPath();
+  const config = yield* loadConfigFile(path);
+  yield* Effect.annotateCurrentSpan({ path });
+  return config;
+});
+
+export type { MdConfig };
+export type { ConfigParseError } from './errors';
+export type { ConfigReadError } from './read-error';
+export { DEFAULT_CONFIG, loadConfigFile, loadUserConfig };

package/src/config/read-error.ts

@@ -0,0 +1,6 @@
+import { Schema } from 'effect';
+
+export class ConfigReadError extends Schema.TaggedErrorClass<ConfigReadError>()('ConfigReadError', {
+  cause: Schema.Unknown,
+  path: Schema.String,
+}) {}

package/src/constants.ts

@@ -0,0 +1,2 @@
+/** Directory name under `~/.config` (override with `MD_CONFIG_HOME`). */
+export const CONFIG_DIR_NAME = 'md';

package/src/index.ts

@@ -0,0 +1,51 @@
+import type { Effect } from 'effect';
+
+import { DEFAULT_CONFIG } from './config';
+import type { MarkdownParseError } from './lib/parser';
+import { render } from './lib/render';
+
+export { CONFIG_DIR_NAME } from './constants';
+export { configRoot, configTomlPath, expandHome } from './paths';
+export {
+  DEFAULT_CONFIG,
+  loadConfigFile,
+  loadUserConfig,
+  type MdConfig,
+  type ConfigParseError,
+  type ConfigReadError,
+} from './config';
+export type {
+  MdAppError,
+  FileNotFoundError,
+  InvalidThemeError,
+  StdinReadError,
+} from './app/errors';
+export { formatMdAppError, isMdAppError } from './app/format-error';
+export { showHelp, showVersion } from './app/cli-info';
+export { runMd, type MdCliOptions } from './app/run-md';
+export { app, program, runnableProgram, runtimeLayer } from './cli-app';
+export { render } from './lib/render';
+export {
+  CODE_BLOCK_HIGHLIGHT_CONCURRENCY,
+  renderCodeBlocksParallel,
+  type CodeBlockRef,
+} from './lib/render-code-blocks';
+export { clearHighlightCache, highlightCode, stripItalicAnsi } from './lib/shiki';
+export type { Config } from './lib/config';
+export type { MarkdownParseError } from './lib/parser';
+
+/**
+ * Convenience function to render markdown with default configuration.
+ * For advanced usage, use the Effect-based `render()` function with custom config.
+ *
+ * @example
+ * ```ts
+ * import { renderMarkdown } from '@seanmozeik/markdown-display';
+ * import { Effect } from 'effect';
+ *
+ * const program = renderMarkdown('# Hello World');
+ * Effect.runSync(program);
+ * ```
+ */
+export const renderMarkdown = (markdown: string): Effect.Effect<string, MarkdownParseError> =>
+  render(markdown, DEFAULT_CONFIG);

package/src/lib/ansi.ts

@@ -0,0 +1,24 @@
+// Src/lib/ansi.ts
+
+/**
+ * ANSI / invisible character handling for terminal width and stripping.
+ * Broader escape patterns adapted from claudewatch/src/render/measure.ts.
+ */
+
+const ESC = '\u001B';
+const BEL = '\u0007';
+const ANSI_PATTERN = new RegExp(
+  `${ESC}\\[[0-9;]*m|${ESC}\\].*?${BEL}|${ESC}\\[[\\d;]*[A-Za-z]`,
+  'gu',
+);
+
+const ZERO_WIDTH_PATTERN = /[\u0300-\u036F\u200B\u200C\uFEFF\u202A-\u202E]|\u200D/gu;
+
+const SOFT_HYPHEN_REGEX = /\u00AD/gu;
+
+export const stripAnsi = (str: string): string => str.replace(ANSI_PATTERN, '');
+
+export const stripInvisible = (str: string): string =>
+  stripAnsi(str).replace(SOFT_HYPHEN_REGEX, '').replace(ZERO_WIDTH_PATTERN, '');
+
+export const visibleLength = (str: string): number => Bun.stringWidth(stripInvisible(str));

package/src/lib/config.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `../config` instead. */
+export { DEFAULT_CONFIG, loadConfigFile as loadConfig, type MdConfig as Config } from '../config';

package/src/lib/default-config.toml

@@ -0,0 +1,25 @@
+# src/lib/default-config.toml
+theme = "frappe"
+width = "auto"
+truecolor = "auto" # "auto" | true | false
+nerd_fonts = "auto" # "auto" | true | false
+
+[display]
+padding = true # responsive padding based on terminal width
+maxWidth = 0 # 0 = full width, 80-120 = constrain & center
+
+[code]
+wrap = true
+continuation = "→"
+
+[text]
+hyphenation = true
+locale = "en-us"
+
+[links]
+osc8 = "auto"
+show_urls = false
+
+[pager]
+command = ""
+args = ["-r", "-F", "-K", "-X"]

package/src/lib/elements/blockquote.ts

@@ -0,0 +1,34 @@
+// Src/lib/elements/blockquote.ts
+import { getMutedColor, getSubtleColor } from '../../ui/themes/semantic';
+import { wrapText } from './text';
+
+interface BlockquoteConfig {
+  width: number;
+  hyphenation?: boolean;
+}
+
+const NEWLINE_NOT_DOUBLE = /\n(?!\n)/gu;
+const COLLAPSE_SPACES = / +/gu;
+
+export const renderBlockquote = (text: string, config?: BlockquoteConfig, depth = 1): string => {
+  const prefixRaw = '│ '.repeat(depth);
+  const prefix = getSubtleColor()(prefixRaw);
+  const prefixWidth = prefixRaw.length;
+  const innerWidth =
+    config?.width !== undefined && config.width > 0 ? config.width - prefixWidth : 0;
+
+  const content =
+    innerWidth > 0
+      ? wrapText(
+          text.replaceAll(NEWLINE_NOT_DOUBLE, ' ').replaceAll(COLLAPSE_SPACES, ' '),
+          innerWidth,
+          { hyphenation: config?.hyphenation ?? true, locale: 'en-us' },
+        )
+      : text;
+
+  const mutedColor = getMutedColor();
+  return content
+    .split('\n')
+    .map((line) => `${prefix}${mutedColor(line)}`)
+    .join('\n');
+};