@seanmozeik/markdown-display 0.3.5 → 0.4.1

package/src/lib/elements/text.ts

@@ -0,0 +1,237 @@
+import { hyphenateSync } from 'hyphen/en';
+
+// Src/lib/elements/text.ts
+import { getTextColor } from '../../ui/themes/semantic';
+import { visibleLength } from '../ansi';
+
+interface TextConfig {
+  width: number;
+  hyphenation: boolean;
+  locale?: string;
+}
+
+interface WrapOptions {
+  hyphenation: boolean;
+  locale: string;
+}
+
+const SOFT_HYPHEN = '\u00AD';
+const SOFT_HYPHEN_REGEX = /\u00AD/gu;
+
+// ANSI escape character - used to build regex dynamically to satisfy linter
+const ESC = '\u001B';
+
+// Matches ANSI-styled content: \u001B[...m (content) \u001B[0m
+const ANSI_STYLED_BLOCK = new RegExp(`${ESC}\\[[0-9;]*m[^${ESC}]*${ESC}\\[0m`, 'gu');
+
+// Marker for preserving ANSI blocks during splitting (uses NUL which won't appear in text)
+const NUL = '\u0000';
+const MARKER_REGEX = new RegExp(`${NUL}ANSI(\\d+)${NUL}`, 'gu');
+
+const NARROW_WRAP_WIDTH = 50;
+
+/**
+ * Split text into words while keeping ANSI-styled content as atomic units.
+ * This prevents inline code backgrounds from bleeding when text wraps.
+ */
+const splitPreservingAnsi = (text: string): string[] => {
+  const styledBlocks: string[] = [];
+  const markedText = text.replace(ANSI_STYLED_BLOCK, (match) => {
+    styledBlocks.push(match);
+    return `${NUL}ANSI${styledBlocks.length - 1}${NUL}`;
+  });
+
+  const parts = markedText.split(/\s+/u);
+
+  return parts.map((part) =>
+    part.replace(MARKER_REGEX, (_, idx) => styledBlocks[Number(idx)] ?? ''),
+  );
+};
+
+const stripSoftHyphens = (text: string): string => {
+  return text.replace(SOFT_HYPHEN_REGEX, '');
+};
+
+const hyphenateText = (text: string): string => {
+  return hyphenateSync(text);
+};
+
+/**
+ * Hyphenate text while preserving ANSI-styled blocks (like inline code).
+ * Only plain text segments get hyphenated; styled blocks pass through unchanged.
+ */
+const hyphenatePreservingAnsi = (text: string): string => {
+  // Split into segments: [plain, styled, plain, styled, ...]
+  const segments: string[] = [];
+  let lastIndex = 0;
+
+  // Reset regex state
+  ANSI_STYLED_BLOCK.lastIndex = 0;
+
+  for (
+    let match = ANSI_STYLED_BLOCK.exec(text);
+    match !== null;
+    match = ANSI_STYLED_BLOCK.exec(text)
+  ) {
+    // Plain text before this styled block
+    if (match.index > lastIndex) {
+      segments.push(hyphenateText(text.slice(lastIndex, match.index)));
+    }
+    // The styled block itself (unchanged)
+    segments.push(match[0]);
+    lastIndex = match.index + match[0].length;
+  }
+
+  // Remaining plain text after last styled block
+  if (lastIndex < text.length) {
+    segments.push(hyphenateText(text.slice(lastIndex)));
+  }
+
+  return segments.join('');
+};
+
+const findSoftHyphenPositions = (text: string): number[] => {
+  const positions: number[] = [];
+  let idx = text.indexOf(SOFT_HYPHEN);
+  while (idx !== -1) {
+    positions.push(idx);
+    idx = text.indexOf(SOFT_HYPHEN, idx + 1);
+  }
+  return positions;
+};
+
+/**
+ * Find the best soft hyphen break point that fits within maxWidth.
+ * Returns the position, or -1 if no suitable break exists.
+ */
+const findBestBreakPoint = (text: string, maxWidth: number): number => {
+  const positions = findSoftHyphenPositions(text);
+  let best = -1;
+  for (const pos of positions) {
+    const beforeBreak = text.slice(0, pos);
+    // +1 for the visible hyphen we'll add
+    if (visibleLength(stripSoftHyphens(beforeBreak)) + 1 <= maxWidth) {
+      best = pos;
+    }
+  }
+  return best;
+};
+
+/**
+ * Try to split a word at a syllable boundary to fill remaining line space.
+ * Returns [partThatFits, remainder] if a good break point exists, or null if not.
+ */
+const trySplitWordToFill = (
+  word: string,
+  remainingSpace: number,
+  width: number,
+): [string, string] | null => {
+  // More aggressive hyphenation for narrow widths
+  // Narrow (< 50): fill even with 2 chars
+  // Wide (>= 50): need at least 3 chars to be worth it
+  const minFragment = width < NARROW_WRAP_WIDTH ? 2 : 3;
+  if (remainingSpace < minFragment) {
+    return null;
+  }
+
+  const breakAt = findBestBreakPoint(word, remainingSpace);
+  if (breakAt <= 0) {
+    return null;
+  }
+
+  return [`${stripSoftHyphens(word.slice(0, breakAt))}-`, word.slice(breakAt + 1)];
+};
+
+const breakWord = (word: string, width: number): string => {
+  const lines: string[] = [];
+  let remaining = word;
+
+  while (visibleLength(remaining) > width) {
+    const breakAt = findBestBreakPoint(remaining, width);
+
+    if (breakAt > 0) {
+      lines.push(`${stripSoftHyphens(remaining.slice(0, breakAt))}-`);
+      remaining = remaining.slice(breakAt + 1);
+    } else {
+      lines.push(stripSoftHyphens(remaining.slice(0, width)));
+      remaining = remaining.slice(width);
+    }
+  }
+
+  if (remaining) {
+    lines.push(stripSoftHyphens(remaining));
+  }
+
+  return lines.join('\n');
+};
+
+const wrapText = (text: string, width: number, options?: WrapOptions): string => {
+  const shouldHyphenate = options?.hyphenation ?? false;
+
+  const wrapSingleLine = (line: string): string => {
+    // Hyphenate only non-ANSI text to protect inline code from being split
+    const processedLine = shouldHyphenate ? hyphenatePreservingAnsi(line) : line;
+
+    // Use ANSI-aware split to keep styled content (like inline code) atomic
+    const words = splitPreservingAnsi(processedLine);
+    const lines: string[] = [];
+    let currentLine = '';
+
+    for (const word of words) {
+      const testLine = currentLine ? `${currentLine} ${word}` : word;
+
+      if (visibleLength(testLine) <= width) {
+        // Word fits - strip soft hyphens since we don't need to break here
+        const cleanWord = stripSoftHyphens(word);
+        currentLine = currentLine ? `${currentLine} ${cleanWord}` : cleanWord;
+      } else if (currentLine) {
+        // Word doesn't fit - try to split it to fill current line
+        // Reserve one column for the space before the wrapped word fragment
+        const remainingSpace = width - visibleLength(currentLine) - 1;
+        const split = shouldHyphenate ? trySplitWordToFill(word, remainingSpace, width) : null;
+
+        if (split) {
+          // Fill current line with first part of word
+          const [firstPart, remainder] = split;
+          lines.push(`${stripSoftHyphens(currentLine)} ${firstPart}`);
+          // Continue with remainder (may need further breaking)
+          currentLine = breakWord(remainder, width);
+        } else {
+          // Can't split usefully - push current line and start fresh
+          lines.push(stripSoftHyphens(currentLine));
+          currentLine = breakWord(word, width);
+        }
+      } else {
+        // Word alone is too long - break it
+        const broken = breakWord(word, width);
+        const brokenLines = broken.split('\n');
+        lines.push(...brokenLines.slice(0, -1));
+        currentLine = brokenLines.at(-1) ?? '';
+      }
+    }
+
+    if (currentLine) {
+      // Strip any remaining soft hyphens from the last line
+      lines.push(stripSoftHyphens(currentLine));
+    }
+
+    return lines.join('\n');
+  };
+
+  // Preserve explicit line breaks (e.g. Markdown <br> / hard breaks)
+  return text
+    .split('\n')
+    .map((line) => wrapSingleLine(line))
+    .join('\n');
+};
+
+const renderText = (text: string, config: TextConfig): string => {
+  const wrapped = wrapText(text, config.width, {
+    hyphenation: config.hyphenation,
+    locale: config.locale ?? 'en-us',
+  });
+  const textColor = getTextColor();
+  return `${textColor(wrapped)}\n`;
+};
+
+export { renderText, wrapText };

package/src/lib/languages.ts

@@ -0,0 +1,123 @@
+// Src/lib/languages.ts
+
+interface LanguageInfo {
+  icon: string;
+  label: string;
+  color: string;
+}
+
+// Nerd Font icons for programming languages (from nvim-web-devicons)
+// Reference: icons.lua - replace __ICON_X__ placeholders with icons from that file
+const LANGUAGES: Record<string, LanguageInfo> = {
+  bash: { color: '#89E051', icon: '', label: 'bash' },
+  c: { color: '#599EFF', icon: '', label: 'c' },
+  clojure: { color: '#8DC149', icon: '', label: 'clj' },
+  cmake: { color: '#DCE3EB', icon: '', label: 'cmake' },
+  cpp: { color: '#519ABA', icon: '', label: 'cpp' },
+  csharp: { color: '#596706', icon: '󰌛', label: 'cs' },
+  css: { color: '#663399', icon: '', label: 'css' },
+  csv: { color: '#89E051', icon: '', label: 'csv' },
+  diff: { color: '#41535B', icon: '', label: 'diff' },
+  dockerfile: { color: '#458EE6', icon: '󰡨', label: 'docker' },
+  elixir: { color: '#A074C4', icon: '', label: 'ex' },
+  erlang: { color: '#B83998', icon: '', label: 'erl' },
+  go: { color: '#00ADD8', icon: '', label: 'go' },
+  graphql: { color: '#E535AB', icon: '', label: 'gql' },
+  haskell: { color: '#A074C4', icon: '', label: 'hs' },
+  html: { color: '#E44D26', icon: '', label: 'html' },
+  java: { color: '#CC3E44', icon: '', label: 'java' },
+  javascript: { color: '#CBCB41', icon: '', label: 'js' },
+  json: { color: '#CBCB41', icon: '', label: 'json' },
+  julia: { color: '#A270BA', icon: '', label: 'jl' },
+  kotlin: { color: '#7F52FF', icon: '', label: 'kt' },
+  lua: { color: '#51A0CF', icon: '', label: 'lua' },
+  makefile: { color: '#6D8086', icon: '', label: 'make' },
+  markdown: { color: '#DDDDDD', icon: '', label: 'md' },
+  nim: { color: '#F3D400', icon: '', label: 'nim' },
+  ocaml: { color: '#E37933', icon: '', label: 'ml' },
+  perl: { color: '#519ABA', icon: '', label: 'pl' },
+  php: { color: '#A074C4', icon: '', label: 'php' },
+  prisma: { color: '#5A67D8', icon: '', label: 'prisma' },
+  python: { color: '#FFBC03', icon: '', label: 'py' },
+  r: { color: '#2266BA', icon: '󰟔', label: 'r' },
+  ruby: { color: '#701516', icon: '', label: 'rb' },
+  rust: { color: '#DEA584', icon: '', label: 'rs' },
+  scala: { color: '#CC3E44', icon: '', label: 'scala' },
+  scss: { color: '#F55385', icon: '', label: 'scss' },
+  shell: { color: '#4D5A5E', icon: '', label: 'sh' },
+  sql: { color: '#DAD8D8', icon: '', label: 'sql' },
+  svelte: { color: '#FF3E00', icon: '', label: 'svelte' },
+  swift: { color: '#E37933', icon: '', label: 'swift' },
+  tex: { color: '#3D6117', icon: '', label: 'tex' },
+  toml: { color: '#9C4221', icon: '', label: 'toml' },
+  typescript: { color: '#519ABA', icon: '', label: 'ts' },
+  vim: { color: '#019833', icon: '', label: 'vim' },
+  vue: { color: '#8DC149', icon: '', label: 'vue' },
+  xml: { color: '#E37933', icon: '󰗀', label: 'xml' },
+  yaml: { color: '#6D8086', icon: '', label: 'yaml' },
+  zig: { color: '#F69A1B', icon: '', label: 'zig' },
+};
+
+// Aliases for common short names and variants
+const LANG_ALIASES: Record<string, string> = {
+  cc: 'cpp',
+  cjs: 'javascript',
+  cs: 'csharp',
+  cxx: 'cpp',
+  erl: 'erlang',
+  ex: 'elixir',
+  exs: 'elixir',
+  h: 'c',
+  hpp: 'cpp',
+  hs: 'haskell',
+  jl: 'julia',
+  js: 'javascript',
+  kt: 'kotlin',
+  md: 'markdown',
+  mjs: 'javascript',
+  ml: 'ocaml',
+  pl: 'perl',
+  py: 'python',
+  rb: 'ruby',
+  rs: 'rust',
+  sh: 'bash',
+  shell: 'bash',
+  ts: 'typescript',
+  yml: 'yaml',
+};
+
+const normalizeLang = (lang: string): string => {
+  const lower = lang.toLowerCase();
+  return LANG_ALIASES[lower] ?? lower;
+};
+
+const getLanguageLabel = (lang: string, nerdFontsEnabled: boolean): string => {
+  const normalized = normalizeLang(lang);
+  const info = LANGUAGES[normalized];
+  if (nerdFontsEnabled && info !== undefined && info.icon.length > 0) {
+    return info.icon;
+  }
+  return normalized;
+};
+
+const resolveNerdFonts = (configValue: 'auto' | boolean): boolean =>
+  configValue === 'auto' ? false : configValue;
+
+// Terminals known to typically have nerd fonts installed
+const NERD_FONT_TERMINALS = ['WezTerm', 'kitty', 'Alacritty'];
+
+const supportsNerdFonts = (): boolean => {
+  // Explicit override via env var
+  if (Bun.env['NERD_FONTS'] === '1' || Bun.env['NERD_FONTS'] === 'true') {
+    return true;
+  }
+  if (Bun.env['NERD_FONTS'] === '0' || Bun.env['NERD_FONTS'] === 'false') {
+    return false;
+  }
+
+  // Auto-detect based on terminal
+  const term = Bun.env['TERM_PROGRAM'] ?? '';
+  return NERD_FONT_TERMINALS.some((t) => term.includes(t));
+};
+
+export { getLanguageLabel, LANGUAGES, normalizeLang, resolveNerdFonts, supportsNerdFonts };

package/src/lib/layout.ts

@@ -0,0 +1,67 @@
+// Src/lib/layout.ts
+
+interface LayoutConfig {
+  /** 0 = disabled, 80-120 = constrain and center */
+  maxWidth: number;
+  /** Enable responsive padding */
+  padding: boolean;
+}
+
+interface LayoutResult {
+  contentWidth: number;
+  sidePadding: number;
+}
+
+const TERMINAL_EDGE_PADDING = 2;
+const NARROW_CONTENT_THRESHOLD = 60;
+const MEDIUM_CONTENT_THRESHOLD = 100;
+const NARROW_SIDE_PADDING = 1;
+const MEDIUM_SIDE_PADDING = 2;
+const WIDE_SIDE_PADDING = 3;
+
+const sidePaddingForWidth = (contentWidth: number): number => {
+  if (contentWidth < NARROW_CONTENT_THRESHOLD) {
+    return NARROW_SIDE_PADDING;
+  }
+  if (contentWidth <= MEDIUM_CONTENT_THRESHOLD) {
+    return MEDIUM_SIDE_PADDING;
+  }
+  return WIDE_SIDE_PADDING;
+};
+
+const calculateLayout = (
+  terminalWidth: number,
+  defaultContentWidth: number,
+  config: LayoutConfig,
+): LayoutResult => {
+  const { maxWidth, padding } = config;
+
+  if (maxWidth > 0) {
+    const contentWidth = Math.min(maxWidth, terminalWidth - TERMINAL_EDGE_PADDING);
+    const sidePadding = Math.floor((terminalWidth - contentWidth) / 2);
+    return { contentWidth, sidePadding };
+  }
+
+  if (!padding) {
+    return { contentWidth: defaultContentWidth, sidePadding: 0 };
+  }
+
+  const sidePadding = sidePaddingForWidth(defaultContentWidth);
+
+  return { contentWidth: defaultContentWidth - sidePadding * 2, sidePadding };
+};
+
+const applyPadding = (content: string, sidePadding: number): string => {
+  if (sidePadding === 0) {
+    return content;
+  }
+
+  const paddingStr = ' '.repeat(sidePadding);
+  return content
+    .split('\n')
+    .map((line) => `${paddingStr}${line}`)
+    .join('\n');
+};
+
+export type { LayoutConfig, LayoutResult };
+export { applyPadding, calculateLayout };

package/src/lib/pager.ts

@@ -0,0 +1,121 @@
+// Src/lib/pager.ts
+import { Effect, Schema } from 'effect';
+
+import { stripAnsi } from './ansi';
+
+class PagerPipeError extends Schema.TaggedErrorClass<PagerPipeError>()('PagerPipeError', {
+  cause: Schema.Unknown,
+}) {}
+
+enum PagingMode {
+  Always = 'always',
+  QuitIfOneScreen = 'quit-if-one-screen',
+  Never = 'never',
+}
+
+interface PagerConfig {
+  command: string;
+  args: string[];
+}
+
+interface PagingContext {
+  stdoutTTY: boolean;
+  stdinTTY: boolean;
+  lines: number;
+  height: number;
+  noPager?: boolean;
+  forceAlways?: boolean;
+}
+
+export const shouldUsePager = (ctx: PagingContext): PagingMode => {
+  if (ctx.noPager === true || !ctx.stdoutTTY) {
+    return PagingMode.Never;
+  }
+  if (ctx.forceAlways === true) {
+    return PagingMode.Always;
+  }
+  if (ctx.lines <= ctx.height) {
+    return PagingMode.Never;
+  }
+  return PagingMode.QuitIfOneScreen;
+};
+
+export const getPagerCommand = (
+  config: PagerConfig,
+): { command: string; args: string[]; env: Record<string, string> } => {
+  // Priority: config > MD_PAGER > PAGER > less (bat pattern)
+  const command = config.command || (Bun.env['MD_PAGER'] ?? Bun.env['PAGER'] ?? 'less');
+
+  // For less, inject smart defaults if no args configured
+  let { args } = config;
+  if (command === 'less' && args.length === 0) {
+    // Raw control chars (nerd fonts), quit-if-one-screen, quit-on-interrupt, no-init
+    args = ['-r', '-F', '-K', '-X'];
+  }
+
+  return {
+    args,
+    command,
+    env: {
+      LESSCHARSET: 'utf8',
+      // Display Unicode PUA chars (nerd fonts) as-is, not escaped
+      LESSUTFBINFMT: '*d',
+    },
+  };
+};
+
+export const countLines = (content: string, width?: number): number => {
+  if (content.length === 0) {
+    return 1;
+  }
+
+  const lines = content.split('\n');
+  if (width === undefined || width === 0) {
+    return lines.length;
+  }
+
+  let total = 0;
+  for (const line of lines) {
+    const visibleLength = stripAnsi(line).length;
+    total += Math.max(1, Math.ceil(visibleLength / width));
+  }
+  return total;
+};
+
+export const pipeToLess = Effect.fn('md.pipe-to-less')(function* pipeToLessGen(
+  content: string,
+  config: PagerConfig,
+) {
+  const { command, args, env } = getPagerCommand(config);
+
+  const proc = Bun.spawn([command, ...args], {
+    env: { ...process.env, ...env },
+    stderr: 'inherit',
+    stdin: 'pipe',
+    stdout: 'inherit',
+  });
+
+  yield* Effect.tryPromise({
+    catch: (cause) => new PagerPipeError({ cause }),
+    try: () => Promise.resolve(proc.stdin.write(content)),
+  });
+  yield* Effect.tryPromise({
+    catch: (cause) => new PagerPipeError({ cause }),
+    try: () => Promise.resolve(proc.stdin.end()),
+  });
+
+  yield* Effect.tryPromise({
+    catch: (cause) => new PagerPipeError({ cause }),
+    try: () => proc.exited,
+  });
+});
+
+export const shouldUseColor = (): boolean => {
+  // Respect NO_COLOR standard (bat pattern)
+  if (Bun.env['NO_COLOR'] !== undefined) {
+    return false;
+  }
+  return process.stdout.isTTY;
+};
+
+export { PagerPipeError, PagingMode };