resuml 1.3.1 → 1.4.2

package/dist/index.d.cts

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { R as ResumeSchema } from './themeLoader-C7CBqNiC.cjs';
+export { l as loadResumeFiles, a as loadTheme, p as processResumeData } from './themeLoader-C7CBqNiC.cjs';
+
+interface ThemeConfig {
+    sections?: {
+        order?: string[];
+        exclude?: string[];
+    };
+    layout?: {
+        style?: string;
+    };
+    styling?: Record<string, string | number>;
+    labels?: Record<string, string>;
+}
+/**
+ * Render a resume using the specified theme
+ * @param themeName Name of the theme to use
+ * @param resumeData Resume data to render
+ * @param themeConfig Theme configuration
+ * @param inlineCss Optional CSS to include in the HTML
+ * @param language Language code for localization
+ * @returns Object containing the rendered HTML
+ */
+declare function renderTheme(themeName: string, resumeData: ResumeSchema, themeConfig?: ThemeConfig, inlineCss?: string, language?: string): Promise<{
+    htmlOutput: string;
+}>;
+/**
+ * Injects CSS into HTML content
+ * @param html HTML content
+ * @param css CSS to inject
+ * @returns HTML with injected CSS
+ */
+declare function injectCss(html: string, css?: string): string;
+
+declare const themeRender_injectCss: typeof injectCss;
+declare const themeRender_renderTheme: typeof renderTheme;
+declare namespace themeRender {
+  export { themeRender_injectCss as injectCss, themeRender_renderTheme as renderTheme };
+}
+
+type AtsCheckCategory = 'contact' | 'content' | 'structure' | 'keywords';
+type AtsCheckWeight = 'high' | 'medium' | 'low';
+type AtsRating = 'excellent' | 'good' | 'needs-work' | 'poor';
+interface AtsCheck {
+    id: string;
+    category: AtsCheckCategory;
+    weight: AtsCheckWeight;
+    passed: boolean;
+    score: number;
+    message: string;
+    suggestion?: string;
+}
+interface AtsKeywordMatch {
+    matched: string[];
+    missing: string[];
+    matchPercentage: number;
+}
+interface AtsResult {
+    score: number;
+    rating: AtsRating;
+    checks: AtsCheck[];
+    keywords?: AtsKeywordMatch;
+    summary: string;
+}
+interface AtsOptions {
+    language?: string;
+    jobDescription?: string;
+    threshold?: number;
+}
+
+/**
+ * Run ATS analysis on a resume.
+ *
+ * Performs deterministic, offline checks:
+ * 1. Generic best-practice checks (contact, content, structure)
+ * 2. Optional job-description keyword matching
+ *
+ * @param resume - Validated resume data
+ * @param options - ATS analysis options
+ * @returns Full ATS analysis result with score, checks, and suggestions
+ */
+declare function analyzeAts(resume: ResumeSchema, options?: AtsOptions): AtsResult;
+
+declare const program: Command;
+
+export { type AtsOptions, type AtsResult, analyzeAts, program, themeRender };

package/dist/{loadResume-BFCirLAW.d.ts → themeLoader-C7CBqNiC.d.cts}

@@ -356,4 +356,17 @@ declare function loadResumeFiles(inputPath?: string): Promise<{
     yamlContents: string[];
 }>;
 
-export { type ResumeSchema as R, loadResumeFiles as l, processResumeData as p };
+interface ThemeModule {
+    render: (resume: Record<string, unknown>, options?: Record<string, unknown>) => string | Promise<string>;
+}
+/**
+ * Load a theme module by name
+ * @param themeName The name of the theme to load
+ * @param options Optional settings (autoInstall: boolean)
+ * @returns The loaded theme module
+ */
+declare function loadTheme(themeName: string, options?: {
+    autoInstall?: boolean;
+}): ThemeModule;
+
+export { type ResumeSchema as R, type ThemeModule as T, loadTheme as a, loadResumeFiles as l, processResumeData as p };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "resuml",
-  "version": "1.3.1",
-  "description": "Resume as Code — Generate beautiful resumes from YAML with JSON Resume theme support, validation, PDF export, and a live dev server.",
+  "version": "1.4.2",
+  "description": "Generate JSON resumes from YAML with theme support",
+  "type": "module",
   "main": "./dist/api.js",
   "exports": {
     ".": {
@@ -11,7 +12,7 @@
     "./cli": "./dist/index.js"
   },
   "bin": {
-    "resuml": "./bin/resuml.cjs"
+    "resuml": "./bin/resuml"
   },
   "files": [
     "bin",
@@ -21,80 +22,85 @@
     "src/types"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && npm run build:builder",
+    "build:builder": "node scripts/build-builder.js",
+    "dev:builder": "node scripts/dev-server.js",
     "prepublishOnly": "npm run generate:types && npm run build",
-    "generate:types": "node scripts/generate-types.js",
+    "generate:types": "node scripts/generate-types.cjs",
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint": "eslint src --ext .ts",
+    "lint": "eslint src api --ext .ts,.tsx",
+    "lint:fix": "eslint src api --ext .ts,.tsx --fix",
+    "typecheck": "tsc --noEmit",
     "format": "prettier --write .",
+    "format:check": "prettier --check .",
     "release": "semantic-release",
     "prepare": "husky"
   },
   "dependencies": {
-    "@jsonresume/schema": "^1.2.1",
-    "ajv": "^8.18.0",
-    "chalk": "^5.6.2",
+    "@jsonresume/schema": "^1.0.0",
+    "ajv": "^8.12.0",
+    "chalk": "^5.3.0",
     "commander": "^11.1.0",
-    "js-yaml": "^4.1.1",
+    "js-yaml": "^4.1.0",
+    "jsonresume-theme-stackoverflow": "^2.1.0",
     "lodash.merge": "^4.6.2",
-    "yaml": "^2.8.2"
+    "lucide-react": "^1.7.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "tar": "^7.5.13",
+    "yaml": "^2.3.4",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@codemirror/commands": "^6.10.3",
+    "@codemirror/lang-yaml": "^6.1.3",
+    "@codemirror/language": "^6.12.3",
+    "@codemirror/search": "^6.6.0",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/view": "^6.41.0",
     "@commitlint/cli": "^19.8.1",
     "@commitlint/config-conventional": "^19.8.1",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^11.0.6",
-    "@semantic-release/npm": "^13.1.4",
-    "@semantic-release/release-notes-generator": "^14.1.0",
+    "@semantic-release/github": "^11.0.3",
+    "@semantic-release/npm": "^13.1.5",
+    "@semantic-release/release-notes-generator": "^14.0.3",
     "@types/js-yaml": "^4.0.9",
     "@types/lodash.merge": "^4.6.9",
-    "@types/node": "^20.19.33",
-    "@typescript-eslint/eslint-plugin": "^8.55.0",
-    "@typescript-eslint/parser": "^8.55.0",
-    "eslint": "^8.57.1",
-    "eslint-config-prettier": "^9.1.2",
+    "@types/node": "^20.11.19",
+    "@types/pako": "^2.0.4",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@typescript-eslint/eslint-plugin": "^8.33.0",
+    "@typescript-eslint/parser": "^8.33.0",
+    "@vercel/node": "^5.7.2",
+    "codemirror": "^6.0.2",
+    "esbuild": "^0.28.0",
+    "eslint": "^8.0.0",
+    "eslint-config-prettier": "^9.0.0",
     "husky": "^9.1.7",
     "json-schema-to-typescript": "^15.0.4",
-    "prettier": "^3.8.1",
+    "pako": "^2.1.0",
+    "playwright": "^1.52.0",
+    "prettier": "^3.0.0",
     "semantic-release": "^25.0.3",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
-  },
-  "peerDependencies": {
-    "puppeteer": ">=20.0.0"
-  },
-  "peerDependenciesMeta": {
-    "puppeteer": {
-      "optional": true
-    }
+    "tsup": "^8.0.2",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.2"
   },
   "engines": {
     "node": ">=20.0.0"
   },
-  "homepage": "https://phoinixi.github.io/resuml/",
+  "license": "ISC",
+  "author": "phoinixi",
   "repository": {
     "type": "git",
-    "url": "https://github.com/phoinixi/resuml.git"
+    "url": "https://github.com/phoinixi/resuml"
   },
-  "license": "ISC",
-  "author": "phoinixi",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
-  },
-  "keywords": [
-    "resume",
-    "yaml",
-    "cli",
-    "json-resume",
-    "pdf",
-    "resume-builder",
-    "resume-generator",
-    "cv",
-    "career"
-  ]
+  }
 }

package/scripts/build-builder.js

@@ -0,0 +1,25 @@
+import { build } from 'esbuild';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+await build({
+  entryPoints: [resolve(__dirname, '../src/builder/index.tsx')],
+  bundle: true,
+  minify: true,
+  treeShaking: true,
+  format: 'esm',
+  target: 'es2022',
+  outfile: resolve(__dirname, '../docs/app/main.js'),
+  jsx: 'automatic',
+  define: {
+    'process.env.NODE_ENV': '"production"',
+  },
+  loader: {
+    '.ts': 'ts',
+    '.tsx': 'tsx',
+  },
+});
+
+console.log('✅ Builder built to docs/app/main.js');

package/scripts/bundle-themes.js

@@ -0,0 +1,233 @@
+/**
+ * Theme Bundling Script
+ *
+ * Discovers jsonresume-theme packages from npm, installs them,
+ * and bundles each into a browser-compatible ES module.
+ *
+ * Output:
+ *   docs/themes/{name}.js       — bundled theme module
+ *   docs/themes/manifest.json   — theme metadata registry
+ *
+ * Usage:
+ *   node scripts/bundle-themes.js              # Bundle popular themes
+ *   node scripts/bundle-themes.js --all        # Discover + bundle all from npm
+ *   node scripts/bundle-themes.js --themes elegant,even,kendall  # Specific themes
+ */
+
+import { build } from 'esbuild';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const THEMES_DIR = resolve(__dirname, '../docs/themes');
+
+// Popular themes that are known to work in the browser
+const POPULAR_THEMES = [
+  'stackoverflow',
+  'elegant',
+  'even',
+  'kendall',
+  'flat',
+  'macchiato',
+  'class',
+  'paper',
+  'spartan',
+  'short',
+  'caffeine',
+  'onepage',
+  'kwan',
+  'autumn',
+  'relaxed',
+  'compact',
+];
+
+async function discoverThemes() {
+  const themes = [];
+  let from = 0;
+  const size = 250;
+
+  console.log('🔍 Discovering themes from npm...');
+
+  // npm search API has pagination, fetch up to 1000
+  for (let page = 0; page < 4; page++) {
+    const url = `https://registry.npmjs.org/-/v1/search?text=jsonresume-theme&size=${size}&from=${from}`;
+    const res = await fetch(url);
+    if (!res.ok) break;
+    const data = await res.json();
+
+    for (const pkg of data.objects) {
+      const name = pkg.package.name;
+      if (!name.startsWith('jsonresume-theme-')) continue;
+      const shortName = name.replace('jsonresume-theme-', '');
+
+      // Skip themes with 0 downloads or very old
+      if (pkg.score?.detail?.popularity === 0) continue;
+
+      themes.push({
+        name: shortName,
+        packageName: name,
+        description: pkg.package.description || '',
+        version: pkg.package.version,
+      });
+    }
+
+    if (data.objects.length < size) break;
+    from += size;
+  }
+
+  console.log(`   Found ${themes.length} themes`);
+  return themes;
+}
+
+async function bundleTheme(shortName, packageName) {
+  const entryContent = `
+    import theme from '${packageName}';
+    export const render = theme.render || theme.default?.render;
+    export const pdfRenderOptions = theme.pdfRenderOptions || theme.default?.pdfRenderOptions;
+  `;
+
+  const entryFile = resolve(THEMES_DIR, `_entry_${shortName}.js`);
+  writeFileSync(entryFile, entryContent);
+
+  try {
+    await build({
+      entryPoints: [entryFile],
+      bundle: true,
+      minify: true,
+      format: 'esm',
+      target: 'es2022',
+      platform: 'browser',
+      outfile: resolve(THEMES_DIR, `${shortName}.js`),
+      define: {
+        'process.env.NODE_ENV': '"production"',
+        'global': 'globalThis',
+      },
+      // Polyfill Node.js built-ins as no-ops for browser
+      alias: {
+        'path': resolve(__dirname, 'shims/path.js'),
+        'fs': resolve(__dirname, 'shims/fs.js'),
+      },
+      logLevel: 'silent',
+    });
+
+    // Clean up entry file
+    execSync(`rm -f "${entryFile}"`);
+    return true;
+  } catch (e) {
+    execSync(`rm -f "${entryFile}"`);
+    return false;
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const doAll = args.includes('--all');
+  const themesArg = args.find(a => a.startsWith('--themes='));
+  const specificThemes = themesArg ? themesArg.split('=')[1].split(',') : null;
+
+  mkdirSync(THEMES_DIR, { recursive: true });
+
+  // Create shims directory
+  const shimsDir = resolve(__dirname, 'shims');
+  mkdirSync(shimsDir, { recursive: true });
+  writeFileSync(resolve(shimsDir, 'path.js'), `
+    export const join = (...parts) => parts.join('/');
+    export const resolve = (...parts) => parts.join('/');
+    export const dirname = (p) => p.split('/').slice(0, -1).join('/');
+    export const basename = (p) => p.split('/').pop();
+    export const extname = (p) => { const m = p.match(/\\.[^.]+$/); return m ? m[0] : ''; };
+    export default { join, resolve, dirname, basename, extname };
+  `);
+  writeFileSync(resolve(shimsDir, 'fs.js'), `
+    export const readFileSync = () => '';
+    export const existsSync = () => false;
+    export default { readFileSync, existsSync };
+  `);
+
+  let themes;
+  if (specificThemes) {
+    themes = specificThemes.map(name => ({
+      name,
+      packageName: `jsonresume-theme-${name}`,
+      description: '',
+      version: '',
+    }));
+  } else if (doAll) {
+    themes = await discoverThemes();
+  } else {
+    themes = POPULAR_THEMES.map(name => ({
+      name,
+      packageName: `jsonresume-theme-${name}`,
+      description: '',
+      version: '',
+    }));
+  }
+
+  console.log(`📦 Bundling ${themes.length} themes...\n`);
+
+  const manifest = [];
+
+  for (const theme of themes) {
+    process.stdout.write(`  ${theme.name}... `);
+
+    // Install the theme
+    try {
+      execSync(`npm install --no-save ${theme.packageName} 2>/dev/null`, {
+        cwd: resolve(__dirname, '..'),
+        timeout: 30000,
+      });
+    } catch {
+      console.log('❌ install failed');
+      continue;
+    }
+
+    // Try to get description from installed package
+    try {
+      const pkgPath = resolve(__dirname, `../node_modules/${theme.packageName}/package.json`);
+      if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        theme.description = theme.description || pkg.description || '';
+        theme.version = theme.version || pkg.version || '';
+      }
+    } catch {}
+
+    // Bundle it
+    const success = await bundleTheme(theme.name, theme.packageName);
+
+    if (success) {
+      const outFile = resolve(THEMES_DIR, `${theme.name}.js`);
+      const stat = existsSync(outFile) ? readFileSync(outFile).length : 0;
+      manifest.push({
+        name: theme.name,
+        displayName: theme.name.charAt(0).toUpperCase() + theme.name.slice(1).replace(/-/g, ' '),
+        description: theme.description,
+        browserCompatible: true,
+        fileSize: stat,
+      });
+      console.log(`✅ (${(stat / 1024).toFixed(0)}KB)`);
+    } else {
+      manifest.push({
+        name: theme.name,
+        displayName: theme.name.charAt(0).toUpperCase() + theme.name.slice(1).replace(/-/g, ' '),
+        description: theme.description,
+        browserCompatible: false,
+        fileSize: 0,
+      });
+      console.log('⚠️  browser incompatible');
+    }
+  }
+
+  // Write manifest
+  writeFileSync(resolve(THEMES_DIR, 'manifest.json'), JSON.stringify(manifest, null, 2));
+
+  const successful = manifest.filter(t => t.browserCompatible).length;
+  console.log(`\n✅ Done! ${successful}/${manifest.length} themes bundled for the browser`);
+  console.log(`📁 Output: docs/themes/`);
+
+  // Clean up shims
+  execSync(`rm -rf "${shimsDir}"`);
+}
+
+main().catch(console.error);