@versini/ui-styles 8.5.0 → 9.0.0

package/dist/cli/assets/fileScanner-Cis4RFj5.js

@@ -0,0 +1,93 @@
+import fs from "node:fs";
+import path from "node:path";
+const DEFAULT_EXTENSIONS = ["js", "jsx", "ts", "tsx"];
+const DEFAULT_IGNORE = [
+  "node_modules",
+  "dist",
+  "build",
+  ".git",
+  "coverage",
+  ".next",
+  ".rslib",
+  "tmp",
+  "__tests__"
+];
+const EXCLUDED_FILE_PATTERNS = [
+  /\.stories\.[jt]sx?$/,
+  /\.test\.[jt]sx?$/,
+  /\.spec\.[jt]sx?$/
+];
+function shouldIgnore(filePath, ignorePatterns) {
+  const parts = filePath.split(path.sep);
+  return parts.some((part) => ignorePatterns.includes(part));
+}
+function hasAllowedExtension(filePath, extensions) {
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+  return extensions.includes(ext);
+}
+function isExcludedFile(fileName) {
+  return EXCLUDED_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
+}
+function scanDirectory(dirPath, rootPath, options, results) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    const relativePath = path.relative(rootPath, fullPath);
+    if (shouldIgnore(relativePath, options.ignore)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      scanDirectory(fullPath, rootPath, options, results);
+    } else if (entry.isFile() && hasAllowedExtension(entry.name, options.extensions) && !isExcludedFile(entry.name)) {
+      try {
+        const content = fs.readFileSync(fullPath, "utf-8");
+        results.push({
+          absolutePath: fullPath,
+          relativePath,
+          content
+        });
+      } catch {
+      }
+    }
+  }
+}
+function scanFiles(targetPath, options) {
+  const resolvedPath = path.resolve(targetPath);
+  const fullOptions = {
+    extensions: options?.extensions || DEFAULT_EXTENSIONS,
+    ignore: options?.ignore || DEFAULT_IGNORE
+  };
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`Path does not exist: ${resolvedPath}`);
+  }
+  const stats = fs.statSync(resolvedPath);
+  const results = [];
+  if (stats.isFile()) {
+    if (hasAllowedExtension(resolvedPath, fullOptions.extensions)) {
+      const content = fs.readFileSync(resolvedPath, "utf-8");
+      results.push({
+        absolutePath: resolvedPath,
+        relativePath: path.basename(resolvedPath),
+        content
+      });
+    }
+  } else if (stats.isDirectory()) {
+    scanDirectory(resolvedPath, resolvedPath, fullOptions, results);
+  }
+  return results;
+}
+function getDefaultScanOptions() {
+  return {
+    extensions: [...DEFAULT_EXTENSIONS],
+    ignore: [...DEFAULT_IGNORE]
+  };
+}
+export {
+  getDefaultScanOptions as g,
+  scanFiles as s
+};

package/dist/cli/ui-doctor.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import fs, { readFileSync, existsSync } from "node:fs";
-import path, { dirname, resolve } from "node:path";
+import { s as scanFiles, g as getDefaultScanOptions } from "./assets/fileScanner-Cis4RFj5.js";
+import { readFileSync, existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 const TAILWIND_COLOR_PALETTES = [
   "red",
@@ -106,93 +107,6 @@ function findColorClasses(content) {
   }
   return allMatches;
 }
-const DEFAULT_EXTENSIONS = ["js", "jsx", "ts", "tsx"];
-const DEFAULT_IGNORE = [
-  "node_modules",
-  "dist",
-  "build",
-  ".git",
-  "coverage",
-  ".next",
-  ".rslib",
-  "tmp",
-  "__tests__"
-];
-const EXCLUDED_FILE_PATTERNS = [
-  /\.stories\.[jt]sx?$/,
-  /\.test\.[jt]sx?$/,
-  /\.spec\.[jt]sx?$/
-];
-function shouldIgnore(filePath, ignorePatterns) {
-  const parts = filePath.split(path.sep);
-  return parts.some((part) => ignorePatterns.includes(part));
-}
-function hasAllowedExtension(filePath, extensions) {
-  const ext = path.extname(filePath).slice(1).toLowerCase();
-  return extensions.includes(ext);
-}
-function isExcludedFile(fileName) {
-  return EXCLUDED_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
-}
-function scanDirectory(dirPath, rootPath, options, results) {
-  let entries;
-  try {
-    entries = fs.readdirSync(dirPath, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry.name);
-    const relativePath = path.relative(rootPath, fullPath);
-    if (shouldIgnore(relativePath, options.ignore)) {
-      continue;
-    }
-    if (entry.isDirectory()) {
-      scanDirectory(fullPath, rootPath, options, results);
-    } else if (entry.isFile() && hasAllowedExtension(entry.name, options.extensions) && !isExcludedFile(entry.name)) {
-      try {
-        const content = fs.readFileSync(fullPath, "utf-8");
-        results.push({
-          absolutePath: fullPath,
-          relativePath,
-          content
-        });
-      } catch {
-      }
-    }
-  }
-}
-function scanFiles(targetPath, options) {
-  const resolvedPath = path.resolve(targetPath);
-  const fullOptions = {
-    extensions: options?.extensions || DEFAULT_EXTENSIONS,
-    ignore: options?.ignore || DEFAULT_IGNORE
-  };
-  if (!fs.existsSync(resolvedPath)) {
-    throw new Error(`Path does not exist: ${resolvedPath}`);
-  }
-  const stats = fs.statSync(resolvedPath);
-  const results = [];
-  if (stats.isFile()) {
-    if (hasAllowedExtension(resolvedPath, fullOptions.extensions)) {
-      const content = fs.readFileSync(resolvedPath, "utf-8");
-      results.push({
-        absolutePath: resolvedPath,
-        relativePath: path.basename(resolvedPath),
-        content
-      });
-    }
-  } else if (stats.isDirectory()) {
-    scanDirectory(resolvedPath, resolvedPath, fullOptions, results);
-  }
-  return results;
-}
-function getDefaultScanOptions() {
-  return {
-    extensions: [...DEFAULT_EXTENSIONS],
-    ignore: [...DEFAULT_IGNORE]
-  };
-}
 const colors = {
   reset: "\x1B[0m",
   bright: "\x1B[1m",

package/dist/cli/ui-plume-migrate.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+import { s as scanFiles, g as getDefaultScanOptions } from "./assets/fileScanner-Cis4RFj5.js";
+import fs from "node:fs";
+import "node:path";
+const PROSE_ELEMENT_MODIFIERS = [
+  "headings",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "p",
+  "a",
+  "blockquote",
+  "figure",
+  "figcaption",
+  "strong",
+  "em",
+  "kbd",
+  "code",
+  "pre",
+  "ol",
+  "ul",
+  "li",
+  "table",
+  "thead",
+  "tr",
+  "th",
+  "td",
+  "img",
+  "video",
+  "hr",
+  "lead"
+];
+function migrateContent(content) {
+  const matches = [];
+  let migratedContent = content;
+  const lines = content.split("\n");
+  const processedLines = [];
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    let line = lines[lineIndex];
+    const lineNumber = lineIndex + 1;
+    line = replaceWithTracking(
+      line,
+      /--tw-prose-/g,
+      "--tw-plume-",
+      lineNumber,
+      matches
+    );
+    line = replaceWithTracking(
+      line,
+      /\bnot-prose\b/g,
+      "not-plume",
+      lineNumber,
+      matches
+    );
+    for (const modifier of PROSE_ELEMENT_MODIFIERS) {
+      const pattern = new RegExp(`\\bprose-${modifier}:`, "g");
+      line = replaceWithTracking(
+        line,
+        pattern,
+        `plume-${modifier}:`,
+        lineNumber,
+        matches
+      );
+    }
+    line = replaceWithTracking(
+      line,
+      /\bprose-dark\b/g,
+      "plume-dark",
+      lineNumber,
+      matches
+    );
+    line = replaceWithTracking(
+      line,
+      /\bprose-lighter\b/g,
+      "plume-lighter",
+      lineNumber,
+      matches
+    );
+    line = replaceWithTracking(
+      line,
+      /\bprose-light\b/g,
+      "plume-light",
+      lineNumber,
+      matches
+    );
+    line = replaceWithTracking(
+      line,
+      /(?<![-\w])prose(?!-\w)/g,
+      "plume",
+      lineNumber,
+      matches
+    );
+    processedLines.push(line);
+  }
+  migratedContent = processedLines.join("\n");
+  return {
+    originalContent: content,
+    migratedContent,
+    matches,
+    hasChanges: matches.length > 0
+  };
+}
+function replaceWithTracking(line, pattern, replacement, lineNumber, matches) {
+  const regex = new RegExp(pattern.source, pattern.flags);
+  let match = regex.exec(line);
+  while (match !== null) {
+    matches.push({
+      original: match[0],
+      replacement,
+      line: lineNumber,
+      column: match.index + 1
+    });
+    match = regex.exec(line);
+  }
+  const result = line.replace(pattern, replacement);
+  return result;
+}
+function migrateFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const result = migrateContent(content);
+  return {
+    ...result,
+    filePath
+  };
+}
+function migrateFileInPlace(filePath) {
+  const result = migrateFile(filePath);
+  if (result.hasChanges) {
+    fs.writeFileSync(filePath, result.migratedContent, "utf-8");
+  }
+  return result;
+}
+function needsMigration(content) {
+  const patterns = [
+    /--tw-prose-/,
+    /\bnot-prose\b/,
+    /\bprose-dark\b/,
+    /\bprose-light\b/,
+    /\bprose-lighter\b/,
+    /(?<![-\w])prose(?!-\w)/
+  ];
+  for (const modifier of PROSE_ELEMENT_MODIFIERS) {
+    patterns.push(new RegExp(`\\bprose-${modifier}:`));
+  }
+  return patterns.some((pattern) => pattern.test(content));
+}
+const VERSION = "1.0.0";
+const colors = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m"
+};
+function parseArgs(args) {
+  const defaults = getDefaultScanOptions();
+  const options = {
+    path: ".",
+    extensions: [...defaults.extensions, "mdx", "md", "jsx"],
+    ignore: defaults.ignore,
+    dryRun: false,
+    help: false,
+    version: false
+  };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    switch (arg) {
+      case "-h":
+      case "--help":
+        options.help = true;
+        break;
+      case "-v":
+      case "--version":
+        options.version = true;
+        break;
+      case "--dry-run":
+        options.dryRun = true;
+        break;
+      case "-p":
+      case "--path":
+        i++;
+        if (i < args.length) {
+          options.path = args[i];
+        }
+        break;
+      case "-e":
+      case "--extensions":
+        i++;
+        if (i < args.length) {
+          options.extensions = args[i].split(",").map((e) => e.trim());
+        }
+        break;
+      case "-i":
+      case "--ignore":
+        i++;
+        if (i < args.length) {
+          options.ignore = args[i].split(",").map((p) => p.trim());
+        }
+        break;
+      default:
+        if (!arg.startsWith("-")) {
+          options.path = arg;
+        }
+        break;
+    }
+    i++;
+  }
+  return options;
+}
+function printHelp() {
+  console.log(`
+${colors.cyan}${colors.bright}ui-plume-migrate${colors.reset} v${VERSION}
+
+A CLI tool to migrate from "prose" to "plume" typography prefix.
+
+This tool automatically replaces all prose patterns with plume patterns:
+  - CSS variables: --tw-prose-* → --tw-plume-*
+  - Base class: prose → plume
+  - Color variants: prose-dark, prose-light, prose-lighter → plume-*
+  - Not-prose: not-prose → not-plume
+  - Element variants: prose-h1:, prose-p:, etc. → plume-*:
+
+${colors.bright}Usage:${colors.reset}
+  ui-plume-migrate [path] [options]
+
+${colors.bright}Arguments:${colors.reset}
+  path                      Path to scan (default: current directory)
+
+${colors.bright}Options:${colors.reset}
+  -p, --path <path>         Path to scan (alternative to positional argument)
+  -e, --extensions <ext>    Comma-separated file extensions
+                            (default: js,jsx,ts,tsx,mdx,md)
+  -i, --ignore <patterns>   Comma-separated patterns to ignore
+                            (default: node_modules,dist,build,.git)
+  --dry-run                 Show what would change without making modifications
+  -h, --help                Show this help message
+  -v, --version             Show version number
+
+${colors.bright}Examples:${colors.reset}
+  ui-plume-migrate                     Migrate current directory
+  ui-plume-migrate ./src               Migrate the src directory
+  ui-plume-migrate ./src --dry-run     Preview changes without modifying files
+  ui-plume-migrate -e tsx,ts           Only process TypeScript files
+`);
+}
+function printVersion() {
+  console.log(`ui-plume-migrate v${VERSION}`);
+}
+function printResults(results, dryRun, duration) {
+  const filesWithChanges = results.filter((r) => r.hasChanges);
+  const totalMatches = filesWithChanges.reduce(
+    (sum, r) => sum + r.matches.length,
+    0
+  );
+  console.log("");
+  if (filesWithChanges.length === 0) {
+    console.log(
+      `${colors.green}✓${colors.reset} No prose patterns found that need migration!`
+    );
+    console.log(
+      `${colors.dim}  Scanned ${results.length} files in ${duration}ms${colors.reset}`
+    );
+    console.log("");
+    return;
+  }
+  const actionWord = dryRun ? "Would migrate" : "Migrated";
+  for (const result of filesWithChanges) {
+    console.log(
+      `${colors.cyan}${result.filePath}${colors.reset} (${result.matches.length} changes)`
+    );
+    const matchesByType = /* @__PURE__ */ new Map();
+    for (const match of result.matches) {
+      const key = `${match.original} → ${match.replacement}`;
+      matchesByType.set(key, (matchesByType.get(key) || 0) + 1);
+    }
+    for (const [change, count] of matchesByType) {
+      console.log(
+        `  ${colors.dim}${change}${colors.reset} ${colors.yellow}(${count}x)${colors.reset}`
+      );
+    }
+    console.log("");
+  }
+  console.log(`${colors.dim}${"─".repeat(50)}${colors.reset}`);
+  const fileWord = filesWithChanges.length === 1 ? "file" : "files";
+  const changeWord = totalMatches === 1 ? "change" : "changes";
+  if (dryRun) {
+    console.log(
+      `${colors.yellow}${colors.bright}Dry run:${colors.reset} ${totalMatches} ${changeWord} in ${filesWithChanges.length} ${fileWord} would be made`
+    );
+    console.log(
+      `${colors.dim}Run without --dry-run to apply changes${colors.reset}`
+    );
+  } else {
+    console.log(
+      `${colors.green}${colors.bright}${actionWord}:${colors.reset} ${totalMatches} ${changeWord} in ${filesWithChanges.length} ${fileWord}`
+    );
+  }
+  console.log(
+    `${colors.dim}Scanned ${results.length} files in ${duration}ms${colors.reset}`
+  );
+  console.log("");
+}
+function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+  if (options.help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (options.version) {
+    printVersion();
+    process.exit(0);
+  }
+  console.log("");
+  console.log(
+    `${colors.cyan}${colors.bright}ui-plume-migrate${colors.reset} - Migrating prose → plume...`
+  );
+  if (options.dryRun) {
+    console.log(
+      `${colors.yellow}(dry run - no files will be modified)${colors.reset}`
+    );
+  }
+  const startTime = Date.now();
+  let files;
+  try {
+    files = scanFiles(options.path, {
+      extensions: options.extensions,
+      ignore: options.ignore
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${colors.red}Error:${colors.reset} ${message}`);
+    process.exit(1);
+  }
+  const results = [];
+  for (const file of files) {
+    if (!needsMigration(file.content)) {
+      results.push({
+        filePath: file.relativePath,
+        originalContent: file.content,
+        migratedContent: file.content,
+        matches: [],
+        hasChanges: false
+      });
+      continue;
+    }
+    if (options.dryRun) {
+      const { migrateContent: migrateContent2 } = require("./proseMigrator");
+      const migrationResult = migrateContent2(file.content);
+      results.push({
+        ...migrationResult,
+        filePath: file.relativePath
+      });
+    } else {
+      const result = migrateFileInPlace(file.absolutePath);
+      results.push({
+        ...result,
+        filePath: file.relativePath
+      });
+    }
+  }
+  const duration = Date.now() - startTime;
+  printResults(results, options.dryRun, duration);
+  const hasChanges = results.some((r) => r.hasChanges);
+  if (options.dryRun && hasChanges) {
+    process.exit(1);
+  }
+}
+main();

package/dist/index.js

@@ -1,5 +1,5 @@
 /*!
-  @versini/ui-styles v8.5.0
+  @versini/ui-styles v9.0.0
   © 2026 gizmette.com
 */
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@versini/ui-styles",
-	"version": "8.5.0",
+	"version": "9.0.0",
 	"license": "MIT",
 	"author": "Arno Versini",
 	"publishConfig": {
@@ -15,7 +15,8 @@
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"bin": {
-		"ui-doctor": "dist/cli/ui-doctor.js"
+		"ui-doctor": "dist/cli/ui-doctor.js",
+		"ui-plume-migrate": "dist/cli/ui-plume-migrate.js"
 	},
 	"files": [
 		"dist",
@@ -41,7 +42,7 @@
 	},
 	"dependencies": {
 		"@tailwindcss/container-queries": "0.1.1",
-		"@versini/ui-typography": "1.0.0",
+		"@versini/ui-typography": "2.0.0",
 		"culori": "4.0.2",
 		"fs-extra": "11.3.3",
 		"tailwindcss": "4.1.18"
@@ -49,5 +50,5 @@
 	"devDependencies": {
 		"rollup-plugin-copy": "3.5.0"
 	},
-	"gitHead": "6f0ba5933ab114566dc2065b20ca9ffb14c5aba4"
+	"gitHead": "ace8376be408d1f21ced7ba7a3259891476690e4"
 }