@kenjura/ursa 0.10.0 → 0.32.0

package/src/helper/contentHash.js

@@ -0,0 +1,71 @@
+import { createHash } from 'crypto';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+
+const URSA_DIR = '.ursa';
+const HASH_CACHE_FILE = 'content-hashes.json';
+
+/**
+ * Get the path to the .ursa directory for a given source directory
+ */
+export function getUrsaDir(sourceDir) {
+  return join(sourceDir, URSA_DIR);
+}
+
+/**
+ * Generate a short hash of content
+ */
+export function hashContent(content) {
+  return createHash('md5').update(content).digest('hex').substring(0, 12);
+}
+
+/**
+ * Load the hash cache from disk (.ursa folder in source directory)
+ */
+export async function loadHashCache(sourceDir) {
+  const cachePath = join(getUrsaDir(sourceDir), HASH_CACHE_FILE);
+  try {
+    if (existsSync(cachePath)) {
+      const data = await readFile(cachePath, 'utf8');
+      return new Map(Object.entries(JSON.parse(data)));
+    }
+  } catch (e) {
+    console.warn('Could not load hash cache:', e.message);
+  }
+  return new Map();
+}
+
+/**
+ * Save the hash cache to disk (.ursa folder in source directory)
+ */
+export async function saveHashCache(sourceDir, hashMap) {
+  const ursaDir = getUrsaDir(sourceDir);
+  const cachePath = join(ursaDir, HASH_CACHE_FILE);
+  try {
+    await mkdir(ursaDir, { recursive: true });
+    const obj = Object.fromEntries(hashMap);
+    await writeFile(cachePath, JSON.stringify(obj, null, 2));
+    console.log(`Saved ${hashMap.size} hashes to ${cachePath}`);
+  } catch (e) {
+    console.warn('Could not save hash cache:', e.message);
+  }
+}
+
+/**
+ * Check if a file needs regeneration based on content hash
+ */
+export function needsRegeneration(filePath, content, hashCache) {
+  const newHash = hashContent(content);
+  const oldHash = hashCache.get(filePath);
+  return newHash !== oldHash;
+}
+
+/**
+ * Update the hash for a file in the cache
+ */
+export function updateHash(filePath, content, hashCache) {
+  const hash = hashContent(content);
+  hashCache.set(filePath, hash);
+  return hash;
+}

package/src/helper/findStyleCss.js

@@ -0,0 +1,26 @@
+import { join, dirname, resolve } from "path";
+import { existsSync } from "fs";
+
+/**
+ * Recursively search for style.css or _style.css up the directory tree.
+ * Returns the contents of the first found file, or null if not found.
+ * @param {string} startDir - Directory to start searching from
+ * @param {string[]} [names=["style.css", "_style.css"]] - Filenames to look for
+ * @param {string} [baseDir] - Stop searching when this directory is reached
+ * @returns {Promise<string|null>} CSS contents or null
+ */
+export async function findStyleCss(startDir, names = ["style-ursa.css", "style.css", "_style.css"], baseDir = null) {
+  let dir = resolve(startDir);
+  baseDir = baseDir ? resolve(baseDir) : dir.split(/[\\/]/)[0] === '' ? '/' : dir.split(/[\\/]/)[0];
+  while (true) {
+    for (const name of names) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate)) {
+        return (await import('fs/promises')).readFile(candidate, "utf8");
+      }
+    }
+    if (dir === baseDir || dir === dirname(dir)) break;
+    dir = dirname(dir);
+  }
+  return null;
+}

package/src/helper/linkValidator.js

@@ -0,0 +1,246 @@
+import { extname, dirname, join, normalize, posix } from "path";
+
+/**
+ * Build a set of valid internal paths from the list of source files
+ * @param {string[]} sourceFiles - Array of source file paths
+ * @param {string} source - Source directory path
+ * @returns {Set<string>} Set of valid internal paths (without extension, lowercased)
+ */
+export function buildValidPaths(sourceFiles, source) {
+  const validPaths = new Set();
+  
+  for (const file of sourceFiles) {
+    // Get the path relative to source, without extension
+    const ext = extname(file);
+    let relativePath = file.replace(source, "").replace(ext, "");
+    
+    // Normalize: ensure leading slash, lowercase for comparison
+    if (!relativePath.startsWith("/")) {
+      relativePath = "/" + relativePath;
+    }
+    
+    // Add both with and without trailing slash for directories
+    validPaths.add(relativePath.toLowerCase());
+    validPaths.add((relativePath + ".html").toLowerCase());
+    
+    // Also add /index.html variant for directory indexes
+    if (relativePath.endsWith("/index")) {
+      const dirPath = relativePath.replace(/\/index$/, "");
+      validPaths.add(dirPath.toLowerCase());
+      validPaths.add((dirPath + "/").toLowerCase());
+      validPaths.add((dirPath + "/index.html").toLowerCase());
+    }
+  }
+  
+  // Add root
+  validPaths.add("/");
+  validPaths.add("/index.html");
+  
+  return validPaths;
+}
+
+/**
+ * Check if a link is an internal link (not external)
+ * @param {string} href - The href value
+ * @returns {boolean}
+ */
+function isInternalLink(href) {
+  if (!href) return false;
+  
+  // External links start with http://, https://, //, mailto:, tel:, etc.
+  if (href.match(/^(https?:)?\/\/|^mailto:|^tel:|^javascript:|^#/i)) {
+    return false;
+  }
+  
+  // Data URLs
+  if (href.startsWith("data:")) {
+    return false;
+  }
+  
+  return true;
+}
+
+/**
+ * Check if a link is relative (starts with ./ or ../ or doesn't start with /)
+ * @param {string} href - The href value
+ * @returns {boolean}
+ */
+function isRelativeLink(href) {
+  if (!href) return false;
+  return href.startsWith('./') || href.startsWith('../') || !href.startsWith('/');
+}
+
+/**
+ * Resolve a relative href to an absolute path based on the current document's path
+ * @param {string} href - The relative href
+ * @param {string} currentDocPath - The current document's URL path (e.g., "/character/index.html")
+ * @returns {string} Absolute path
+ */
+function resolveRelativePath(href, currentDocPath) {
+  // Get the directory of the current document
+  const currentDir = posix.dirname(currentDocPath);
+  
+  // Join and normalize
+  const resolved = posix.normalize(posix.join(currentDir, href));
+  
+  return resolved;
+}
+
+/**
+ * Normalize an href for comparison against valid paths
+ * @param {string} href - The href to normalize
+ * @param {string} currentDocPath - The current document's URL path (for relative link resolution)
+ * @returns {string} Normalized path
+ */
+function normalizeHref(href, currentDocPath = null) {
+  // Remove hash fragments
+  let normalized = href.split("#")[0];
+  
+  // Remove query strings
+  normalized = normalized.split("?")[0];
+  
+  // Resolve relative links if we have the current doc path
+  if (currentDocPath && isRelativeLink(normalized)) {
+    normalized = resolveRelativePath(normalized, currentDocPath);
+  }
+  
+  // Ensure leading slash for absolute paths
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  
+  // Decode URI components
+  try {
+    normalized = decodeURIComponent(normalized);
+  } catch (e) {
+    // Ignore decode errors
+  }
+  
+  return normalized.toLowerCase();
+}
+
+/**
+ * Resolve an href to a valid path, trying .html and /index.html extensions.
+ * Returns { resolvedHref, inactive, debug } where:
+ * - resolvedHref is the corrected href (with .html extension if needed)
+ * - inactive is true if the link doesn't resolve to a valid path
+ * - debug contains information about what was tried
+ * 
+ * @param {string} href - The original href
+ * @param {Set<string>} validPaths - Set of valid internal paths (lowercased)
+ * @param {string} currentDocPath - The current document's URL path (for relative link resolution)
+ * @returns {{ resolvedHref: string, inactive: boolean, debug: string }}
+ */
+function resolveHref(href, validPaths, currentDocPath = null) {
+  const debugTries = [];
+  
+  // Get hash fragment if present (to preserve it)
+  const hashIndex = href.indexOf('#');
+  const hash = hashIndex >= 0 ? href.substring(hashIndex) : '';
+  const hrefWithoutHash = hashIndex >= 0 ? href.substring(0, hashIndex) : href;
+  
+  // Normalize for checking (resolve relative paths if currentDocPath provided)
+  const normalized = normalizeHref(hrefWithoutHash, currentDocPath);
+  
+  // Calculate the resolved absolute href (for updating the link)
+  const isRelative = isRelativeLink(hrefWithoutHash);
+  const absoluteHref = isRelative && currentDocPath 
+    ? resolveRelativePath(hrefWithoutHash, currentDocPath)
+    : hrefWithoutHash;
+  
+  // If exact match exists, return resolved absolute path
+  if (validPaths.has(normalized)) {
+    debugTries.push(`${normalized} → ✓ (exact)`);
+    return { resolvedHref: absoluteHref + hash, inactive: false, debug: debugTries.join(' | ') };
+  }
+  
+  // Check if the href already has an extension
+  const ext = extname(hrefWithoutHash);
+  if (ext) {
+    // Has extension but doesn't exist
+    debugTries.push(`${normalized} → ✗`);
+    return { resolvedHref: absoluteHref + hash, inactive: true, debug: debugTries.join(' | ') };
+  }
+  
+  // No extension - try .html first
+  const htmlPath = normalized + '.html';
+  debugTries.push(`${htmlPath} → ${validPaths.has(htmlPath) ? '✓' : '✗'}`);
+  if (validPaths.has(htmlPath)) {
+    // Construct the resolved href as absolute path with .html
+    const resolvedHref = absoluteHref + '.html' + hash;
+    return { resolvedHref, inactive: false, debug: debugTries.join(' | ') };
+  }
+  
+  // Try /index.html
+  const indexPath = normalized.endsWith('/') 
+    ? normalized + 'index.html' 
+    : normalized + '/index.html';
+  debugTries.push(`${indexPath} → ${validPaths.has(indexPath) ? '✓' : '✗'}`);
+  if (validPaths.has(indexPath)) {
+    // Construct the resolved href as absolute path with /index.html
+    const resolvedHref = (absoluteHref.endsWith('/') 
+      ? absoluteHref + 'index.html' 
+      : absoluteHref + '/index.html') + hash;
+    return { resolvedHref, inactive: false, debug: debugTries.join(' | ') };
+  }
+  
+  // Neither exists - mark as inactive, keep absolute href
+  return { resolvedHref: absoluteHref + hash, inactive: true, debug: debugTries.join(' | ') };
+}
+
+/**
+ * Process HTML to resolve internal links and add class="inactive" to broken links.
+ * This both:
+ * 1. Resolves relative links to absolute paths
+ * 2. Resolves extensionless links to .html (e.g., /foo/bar -> /foo/bar.html)
+ * 3. Marks broken links with the "inactive" class
+ * 
+ * @param {string} html - The HTML content
+ * @param {Set<string>} validPaths - Set of valid internal paths
+ * @param {string} currentDocPath - The current document's URL path (e.g., "/character/index.html")
+ * @param {boolean} includeDebug - Whether to include debug info in link text
+ * @returns {string} Processed HTML with resolved links and inactive class on broken links
+ */
+export function markInactiveLinks(html, validPaths, currentDocPath = '/', includeDebug = false) {
+  // Match anchor tags with href attribute
+  // This regex captures: everything before href, the href value, everything after, and the link text
+  return html.replace(/<a\s+([^>]*?)href=["']([^"']+)["']([^>]*)>([^<]*)<\/a>/gi, (match, before, href, after, text) => {
+    // Skip external links
+    if (!isInternalLink(href)) {
+      return match;
+    }
+    
+    // Resolve the href (passing current doc path for relative link resolution)
+    const { resolvedHref, inactive, debug } = resolveHref(href, validPaths, currentDocPath);
+    
+    // Build the class attribute
+    let newBefore = before;
+    let newAfter = after;
+    
+    if (inactive) {
+      // Check if class already exists in before or after
+      const classInBefore = before.match(/class=["']([^"']*)["']/i);
+      const classInAfter = after.match(/class=["']([^"']*)["']/i);
+      
+      if (classInBefore) {
+        const existingClass = classInBefore[1];
+        if (!existingClass.includes('inactive')) {
+          newBefore = before.replace(classInBefore[0], `class="${existingClass} inactive"`);
+        }
+      } else if (classInAfter) {
+        const existingClass = classInAfter[1];
+        if (!existingClass.includes('inactive')) {
+          newAfter = after.replace(classInAfter[0], `class="${existingClass} inactive"`);
+        }
+      } else {
+        // Add class attribute
+        newBefore = `class="inactive" ${before}`;
+      }
+    }
+    
+    // Add debug text if requested
+    const debugText = includeDebug ? ` [DEBUG: ${debug}]` : '';
+    
+    return `<a ${newBefore}href="${resolvedHref}"${newAfter}>${text}${debugText}</a>`;
+  });
+}

package/src/helper/metadataExtractor.js

@@ -3,6 +3,9 @@ import { parse } from "yaml";
 export function extractMetadata(rawBody) {
   const frontMatter = matchFrontMatter(rawBody);
   if (frontMatter === null) return null;
+  
+  // Don't try to parse empty or whitespace-only content
+  if (frontMatter.trim().length === 0) return null;
 
   const parsedYml = parse(frontMatter);
   return parsedYml;
@@ -16,15 +19,23 @@ export function extractRawMetadata(rawBody) {
 }
 
 function matchFrontMatter(str) {
-  const match = str.match(/---(.*?)---/s);
-  if (Array.isArray(match) && match.length > 1) {
-    return match[1];
-  } else return null;
+  // Only match YAML front matter at the start of the file
+  // Must have --- at line start, content, then closing --- also at line start
+  // The (?=\n|$) ensures the closing --- is followed by newline or end of string
+  const match = str.match(/^---\n([\s\S]+?)\n---(?=\n|$)/);
+  if (!match || match.length < 2) return null;
+  
+  // Return null if the captured content is empty or only whitespace
+  const content = match[1].trim();
+  return content.length > 0 ? match[1] : null;
 }
 
 function matchAllFrontMatter(str) {
-  const match = str.match(/---(.*?)---\n+/s);
-  if (Array.isArray(match) && match.length > 0) {
-    return match[0];
-  } else return null;
+  // Only match YAML front matter at the start of the file
+  const match = str.match(/^---\n([\s\S]+?)\n---(?=\n|$)/);
+  if (!match || match.length < 2) return null;
+  
+  // Check if there's actual content between the delimiters
+  const content = match[1].trim();
+  return content.length > 0 ? match[0] + '\n' : null;
 }

package/src/helper/whitelistFilter.js

@@ -0,0 +1,66 @@
+import { readFile } from 'fs/promises';
+import { resolve, relative } from 'path';
+import { existsSync } from 'fs';
+
+/**
+ * Creates a filter function based on a whitelist file
+ * @param {string} whitelistPath - Path to the whitelist file
+ * @param {string} sourceRoot - Root source directory for relative path matching
+ * @returns {Function} Filter function that returns true if file should be included
+ */
+export async function createWhitelistFilter(whitelistPath, sourceRoot) {
+  if (!whitelistPath || !existsSync(whitelistPath)) {
+    return () => true; // No whitelist = include all files
+  }
+
+  try {
+    const whitelistContent = await readFile(whitelistPath, 'utf8');
+    const patterns = whitelistContent
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line && !line.startsWith('#')); // Remove empty lines and comments
+
+    if (patterns.length === 0) {
+      return () => true; // Empty whitelist = include all files
+    }
+
+    return (filePath) => {
+      const absolutePath = resolve(filePath);
+      const relativePath = relative(sourceRoot, absolutePath);
+      
+      return patterns.some(pattern => {
+        // Full absolute path match
+        if (pattern.startsWith('/') && absolutePath === pattern) {
+          return true;
+        }
+        
+        // Relative path match (from source root)
+        if (relativePath === pattern || relativePath.includes(pattern)) {
+          return true;
+        }
+        
+        // Directory match (pattern ends with /)
+        if (pattern.endsWith('/')) {
+          const dirPattern = pattern.slice(0, -1);
+          return relativePath.startsWith(dirPattern + '/') || relativePath === dirPattern;
+        }
+        
+        // Filename match
+        const fileName = absolutePath.split('/').pop();
+        if (fileName === pattern) {
+          return true;
+        }
+        
+        // Partial path match (anywhere in the path)
+        if (absolutePath.includes(pattern) || relativePath.includes(pattern)) {
+          return true;
+        }
+        
+        return false;
+      });
+    };
+  } catch (error) {
+    console.warn(`Warning: Could not read whitelist file ${whitelistPath}:`, error.message);
+    return () => true; // Fallback to include all files
+  }
+}

package/src/helper/wikitextHelper.js

@@ -1,11 +1,14 @@
+import { getImageTag } from './WikiImage.js';
+
 let instance = {};
 
 export function wikiToHtml({ wikitext, articleName, args } = {}) {
   if (!args) args = { db: "noDB", noSection: true, noTOC: true };
   if (!wikitext) return "nothing to render";
 
-  const linkbase = ("/" + args.db + "/").replace(/\/\//g, "/");
-  const imageroot = ("/" + args.db + "/img/").replace(/\/\//g, "/");
+  const db = args.db || "noDB";
+  const linkbase = ("/" + db + "/").replace(/\/\//g, "/");
+  const imageroot = ("/" + db + "/img/").replace(/\/\//g, "/");
 
   const allArticles = args.allArticles || [];
 
@@ -330,7 +333,7 @@ export function wikiToHtml({ wikitext, articleName, args } = {}) {
       case "IFRAME":
         return '<iframe src="' + articleName + '"' + getArg(0) + "></iframe>";
       case "IMAGE":
-        return WikiImage.getImageTag({
+        return getImageTag({
           name: articleName,
           args: args,
           imgUrl: imageroot + articleName,