docrev 0.8.1 → 0.8.5

package/lib/{undo.js → undo.ts}

@@ -4,22 +4,66 @@
  * Provides undo/redo functionality during interactive sessions
  */
 
+interface StackEntry {
+  state: string | object;
+  description: string;
+  timestamp: number;
+}
+
+interface HistoryEntry {
+  description: string;
+  current: boolean;
+  index: number;
+}
+
+interface StackInfo {
+  position: number;
+  size: number;
+  undoSteps: number;
+  redoSteps: number;
+}
+
+interface UndoStack {
+  push(state: string | object, description?: string): void;
+  undo(): StackEntry | null;
+  redo(): StackEntry | null;
+  current(): StackEntry | null;
+  canUndo(): boolean;
+  canRedo(): boolean;
+  info(): StackInfo;
+  history(limit?: number): HistoryEntry[];
+  clear(): void;
+  getStack(): StackEntry[];
+}
+
+interface DocumentChange {
+  text: string;
+  description: string;
+}
+
+interface DocumentSession {
+  getText(): string;
+  applyChange(newText: string, description: string): void;
+  undo(): DocumentChange | null;
+  redo(): DocumentChange | null;
+  canUndo(): boolean;
+  canRedo(): boolean;
+  info(): StackInfo;
+  history(limit?: number): HistoryEntry[];
+}
+
 /**
  * Create an undo stack
- * @param {number} maxSize - Maximum number of states to store
- * @returns {object} Undo stack controller
  */
-export function createUndoStack(maxSize = 50) {
-  const stack = [];
+export function createUndoStack(maxSize: number = 50): UndoStack {
+  const stack: StackEntry[] = [];
   let position = -1;
 
   return {
     /**
      * Push a new state onto the stack
-     * @param {any} state - State to save
-     * @param {string} description - Description of the change
      */
-    push(state, description = '') {
+    push(state: string | object, description: string = ''): void {
       // Remove any states after current position (for redo)
       if (position < stack.length - 1) {
         stack.splice(position + 1);
@@ -42,62 +86,56 @@ export function createUndoStack(maxSize = 50) {
 
     /**
      * Undo to previous state
-     * @returns {{state: any, description: string}|null}
      */
-    undo() {
+    undo(): StackEntry | null {
       if (position <= 0) {
         return null;
       }
 
       position--;
-      return stack[position];
+      return stack[position] || null;
     },
 
     /**
      * Redo to next state
-     * @returns {{state: any, description: string}|null}
      */
-    redo() {
+    redo(): StackEntry | null {
       if (position >= stack.length - 1) {
         return null;
       }
 
       position++;
-      return stack[position];
+      return stack[position] || null;
     },
 
     /**
      * Get current state
-     * @returns {{state: any, description: string}|null}
      */
-    current() {
+    current(): StackEntry | null {
       if (position < 0 || position >= stack.length) {
         return null;
       }
-      return stack[position];
+      return stack[position] || null;
     },
 
     /**
      * Check if undo is available
-     * @returns {boolean}
      */
-    canUndo() {
+    canUndo(): boolean {
       return position > 0;
     },
 
     /**
      * Check if redo is available
-     * @returns {boolean}
      */
-    canRedo() {
+    canRedo(): boolean {
       return position < stack.length - 1;
     },
 
     /**
      * Get stack info
-     * @returns {{position: number, size: number, undoSteps: number, redoSteps: number}}
      */
-    info() {
+    info(): StackInfo {
       return {
         position,
         size: stack.length,
@@ -108,10 +146,8 @@ export function createUndoStack(maxSize = 50) {
 
     /**
      * Get history of changes
-     * @param {number} limit - Max items to return
-     * @returns {Array<{description: string, current: boolean, index: number}>}
      */
-    history(limit = 10) {
+    history(limit: number = 10): HistoryEntry[] {
       const start = Math.max(0, position - Math.floor(limit / 2));
       const end = Math.min(stack.length, start + limit);
 
@@ -125,16 +161,15 @@ export function createUndoStack(maxSize = 50) {
     /**
      * Clear the stack
      */
-    clear() {
+    clear(): void {
       stack.length = 0;
       position = -1;
     },
 
     /**
      * Get the full stack (for debugging)
-     * @returns {Array}
      */
-    getStack() {
+    getStack(): StackEntry[] {
       return [...stack];
     },
   };
@@ -142,10 +177,8 @@ export function createUndoStack(maxSize = 50) {
 
 /**
  * Create a document session with undo support
- * @param {string} initialText - Initial document text
- * @returns {object} Session controller
  */
-export function createDocumentSession(initialText) {
+export function createDocumentSession(initialText: string): DocumentSession {
   const undoStack = createUndoStack();
 
   // Save initial state
@@ -154,31 +187,27 @@ export function createDocumentSession(initialText) {
   return {
     /**
      * Get current text
-     * @returns {string}
      */
-    getText() {
+    getText(): string {
       const current = undoStack.current();
-      return current ? current.state : initialText;
+      return current ? current.state as string : initialText;
     },
 
     /**
      * Apply a change
-     * @param {string} newText - New document text
-     * @param {string} description - What changed
      */
-    applyChange(newText, description) {
+    applyChange(newText: string, description: string): void {
       undoStack.push(newText, description);
     },
 
     /**
      * Undo last change
-     * @returns {{text: string, description: string}|null}
      */
-    undo() {
+    undo(): DocumentChange | null {
       const result = undoStack.undo();
       if (result) {
         return {
-          text: result.state,
+          text: result.state as string,
           description: result.description,
         };
       }
@@ -187,13 +216,12 @@ export function createDocumentSession(initialText) {
 
     /**
      * Redo last undone change
-     * @returns {{text: string, description: string}|null}
      */
-    redo() {
+    redo(): DocumentChange | null {
       const result = undoStack.redo();
       if (result) {
         return {
-          text: result.state,
+          text: result.state as string,
           description: result.description,
         };
       }
@@ -202,34 +230,29 @@ export function createDocumentSession(initialText) {
 
     /**
      * Check if undo is available
-     * @returns {boolean}
      */
-    canUndo() {
+    canUndo(): boolean {
       return undoStack.canUndo();
     },
 
     /**
      * Check if redo is available
-     * @returns {boolean}
      */
-    canRedo() {
+    canRedo(): boolean {
       return undoStack.canRedo();
     },
 
     /**
      * Get stack info
-     * @returns {object}
      */
-    info() {
+    info(): StackInfo {
       return undoStack.info();
     },
 
     /**
      * Get change history
-     * @param {number} limit
-     * @returns {Array}
      */
-    history(limit = 10) {
+    history(limit: number = 10): HistoryEntry[] {
       return undoStack.history(limit);
     },
   };

package/lib/utils.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared utility functions
+ */
+
+/**
+ * Count words in text (excluding markdown syntax)
+ * @param text - Markdown text
+ * @returns Word count
+ */
+export function countWords(text: string): number {
+  return text
+    .replace(/^---[\s\S]*?---/m, '') // Remove YAML frontmatter
+    .replace(/!\[.*?\]\(.*?\)/g, '') // Remove images
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Keep link text
+    .replace(/#+\s*/g, '') // Remove headers
+    .replace(/\*\*|__|[*_`]/g, '') // Remove formatting
+    .replace(/```[\s\S]*?```/g, '') // Remove code blocks
+    .replace(/\{[^}]+\}/g, '') // Remove CriticMarkup and attributes
+    .replace(/@\w+:\w+/g, '') // Remove cross-references
+    .replace(/@\w+/g, '') // Remove citations
+    .replace(/\|[^|]+\|/g, ' ') // Remove table cells
+    .replace(/[-=]{3,}/g, '') // Remove horizontal rules
+    .replace(/\n+/g, ' ') // Newlines to spaces
+    .replace(/\s+/g, ' ') // Collapse multiple spaces
+    .trim()
+    .split(/\s+/)
+    .filter(w => w.length > 0).length;
+}
+
+/**
+ * Normalize whitespace in text
+ * @param text - Input text
+ * @returns Normalized text
+ */
+export function normalizeWhitespace(text: string): string {
+  return text
+    .replace(/\r\n/g, '\n')
+    .replace(/\t/g, '    ')
+    .replace(/ +/g, ' ')
+    .trim();
+}

package/lib/{variables.js → variables.ts}

@@ -13,21 +13,40 @@
  */
 
 import * as fs from 'fs';
+import { countWords } from './utils.js';
+import type { Author } from './types.js';
 
 /**
  * Format date with simple pattern
- * @param {Date} date
- * @param {string} format - Pattern (YYYY, MM, DD, MMMM, MMM, D)
- * @returns {string}
  */
-function formatDate(date, format = 'YYYY-MM-DD') {
+function formatDate(date: Date, format: string = 'YYYY-MM-DD'): string {
   const months = [
-    'January', 'February', 'March', 'April', 'May', 'June',
-    'July', 'August', 'September', 'October', 'November', 'December'
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
   ];
   const monthsShort = [
-    'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
-    'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
+    'Jan',
+    'Feb',
+    'Mar',
+    'Apr',
+    'May',
+    'Jun',
+    'Jul',
+    'Aug',
+    'Sep',
+    'Oct',
+    'Nov',
+    'Dec',
   ];
 
   const year = date.getFullYear();
@@ -35,6 +54,8 @@ function formatDate(date, format = 'YYYY-MM-DD') {
   const day = date.getDate();
 
   // Use placeholders to avoid replacement conflicts (e.g., D in December)
+  const monthFull = months[month] || '';
+  const monthShort = monthsShort[month] || '';
   return format
     .replace('YYYY', '\x00YEAR\x00')
     .replace('MMMM', '\x00MONTHFULL\x00')
@@ -43,46 +64,22 @@ function formatDate(date, format = 'YYYY-MM-DD') {
     .replace('DD', '\x00DAYPAD\x00')
     .replace(/\bD\b/, '\x00DAY\x00')
     .replace('\x00YEAR\x00', year.toString())
-    .replace('\x00MONTHFULL\x00', months[month])
-    .replace('\x00MONTHSHORT\x00', monthsShort[month])
+    .replace('\x00MONTHFULL\x00', monthFull)
+    .replace('\x00MONTHSHORT\x00', monthShort)
     .replace('\x00MONTHNUM\x00', (month + 1).toString().padStart(2, '0'))
     .replace('\x00DAYPAD\x00', day.toString().padStart(2, '0'))
     .replace('\x00DAY\x00', day.toString());
 }
 
-/**
- * Count words in text (excluding markdown syntax)
- * @param {string} text
- * @returns {number}
- */
-function countWords(text) {
-  return text
-    .replace(/^---[\s\S]*?---/m, '') // Remove frontmatter
-    .replace(/!\[.*?\]\(.*?\)/g, '') // Remove images
-    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Keep link text
-    .replace(/#+\s*/g, '') // Remove headers
-    .replace(/\*\*|__|[*_`]/g, '') // Remove formatting
-    .replace(/```[\s\S]*?```/g, '') // Remove code blocks
-    .replace(/\{[^}]+\}/g, '') // Remove annotations
-    .replace(/@\w+:\w+/g, '') // Remove refs
-    .replace(/@\w+/g, '') // Remove citations
-    .replace(/\|[^|]+\|/g, ' ') // Remove tables
-    .replace(/\n+/g, ' ')
-    .trim()
-    .split(/\s+/)
-    .filter(w => w.length > 0).length;
-}
-
 /**
  * Get first author name from authors array
- * @param {Array|string} authors
- * @returns {string}
  */
-function getFirstAuthor(authors) {
-  if (!authors || authors.length === 0) return '';
+function getFirstAuthor(authors: Author[] | string | undefined): string {
+  if (!authors || (Array.isArray(authors) && authors.length === 0)) return '';
 
   const first = Array.isArray(authors) ? authors[0] : authors;
 
+  if (!first) return '';
   if (typeof first === 'string') return first;
   if (first.name) return first.name;
 
@@ -91,28 +88,41 @@ function getFirstAuthor(authors) {
 
 /**
  * Get all author names
- * @param {Array|string} authors
- * @returns {string}
  */
-function getAllAuthors(authors) {
+function getAllAuthors(authors: Author[] | string | undefined): string {
   if (!authors) return '';
   if (typeof authors === 'string') return authors;
 
   return authors
-    .map(a => typeof a === 'string' ? a : a.name)
+    .map((a) => (typeof a === 'string' ? a : (a.name || '')))
     .filter(Boolean)
     .join(', ');
 }
 
+/**
+ * Options for variable processing
+ */
+interface ProcessVariablesOptions {
+  sectionContents?: string[];
+}
+
+/**
+ * Config object (minimal subset needed for variables)
+ */
+interface Config {
+  version?: string;
+  title?: string;
+  authors?: Author[] | string;
+}
+
 /**
  * Process template variables in text
- * @param {string} text - Text with {{variable}} placeholders
- * @param {object} config - rev.yaml config
- * @param {object} options - Additional options
- * @param {string[]} options.sections - Section file contents for word count
- * @returns {string} Text with variables replaced
  */
-export function processVariables(text, config = {}, options = {}) {
+export function processVariables(
+  text: string,
+  config: Config = {},
+  options: ProcessVariablesOptions = {}
+): string {
   const now = new Date();
   let result = text;
 
@@ -155,19 +165,15 @@ export function processVariables(text, config = {}, options = {}) {
 
 /**
  * Check if text contains any template variables
- * @param {string} text
- * @returns {boolean}
  */
-export function hasVariables(text) {
+export function hasVariables(text: string): boolean {
   return /\{\{[^}]+\}\}/.test(text);
 }
 
 /**
  * List all variables found in text
- * @param {string} text
- * @returns {string[]}
  */
-export function findVariables(text) {
+export function findVariables(text: string): string[] {
   const matches = text.match(/\{\{([^}]+)\}\}/g) || [];
-  return [...new Set(matches.map(m => m.slice(2, -2)))];
+  return [...new Set(matches.map((m) => m.slice(2, -2)))];
 }