@signiphi/pdf-signer 0.1.1

package/scripts/analyze-bundle.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+/**
+ * Bundle Size Analysis Script
+ * 
+ * Analyzes the built bundle sizes and generates a detailed report.
+ * Compares against defined budgets and warns if exceeded.
+ * 
+ * Usage:
+ *   node scripts/analyze-bundle.js
+ *   node scripts/analyze-bundle.js --format=json
+ *   node scripts/analyze-bundle.js --check-budgets
+ */
+
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+
+// Bundle size budgets (in bytes)
+const BUDGETS = {
+  'index.mjs': { raw: 200 * 1024, gzip: 60 * 1024 },
+  'core/index.mjs': { raw: 50 * 1024, gzip: 15 * 1024 },
+  'components/index.mjs': { raw: 120 * 1024, gzip: 35 * 1024 },
+  'hooks/index.mjs': { raw: 80 * 1024, gzip: 25 * 1024 },
+  'types/index.mjs': { raw: 5 * 1024, gzip: 2 * 1024 },
+  'utils/index.mjs': { raw: 100 * 1024, gzip: 30 * 1024 },
+};
+
+/**
+ * Get file size in different compression formats
+ */
+function getFileSizes(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  const content = fs.readFileSync(filePath);
+  const raw = content.length;
+  const gzipped = zlib.gzipSync(content, { level: 9 }).length;
+  const brotli = zlib.brotliCompressSync(content).length;
+
+  return { raw, gzipped, brotli };
+}
+
+/**
+ * Format bytes to human-readable string
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}
+
+/**
+ * Check if size exceeds budget
+ */
+function checkBudget(filePath, sizes) {
+  const budget = BUDGETS[filePath];
+  if (!budget) return { withinBudget: true };
+
+  const rawExceeded = sizes.raw > budget.raw;
+  const gzipExceeded = sizes.gzipped > budget.gzip;
+
+  return {
+    withinBudget: !rawExceeded && !gzipExceeded,
+    rawExceeded,
+    gzipExceeded,
+    rawPercent: (sizes.raw / budget.raw * 100).toFixed(1),
+    gzipPercent: (sizes.gzipped / budget.gzip * 100).toFixed(1),
+  };
+}
+
+/**
+ * Analyze all bundle files
+ */
+function analyzeBundles() {
+  const distDir = path.join(__dirname, '..', 'dist');
+  const files = [
+    'index.mjs',
+    'index.js',
+    'core/index.mjs',
+    'core/index.js',
+    'components/index.mjs',
+    'components/index.js',
+    'hooks/index.mjs',
+    'hooks/index.js',
+    'types/index.mjs',
+    'types/index.js',
+    'utils/index.mjs',
+    'utils/index.js',
+  ];
+
+  const results = [];
+  let totalRaw = 0;
+  let totalGzipped = 0;
+  let totalBrotli = 0;
+  let budgetViolations = 0;
+
+  for (const file of files) {
+    const filePath = path.join(distDir, file);
+    const sizes = getFileSizes(filePath);
+
+    if (!sizes) {
+      console.warn(`⚠️  File not found: ${file}`);
+      continue;
+    }
+
+    const budgetCheck = checkBudget(file, sizes);
+
+    results.push({
+      file,
+      sizes,
+      budgetCheck,
+    });
+
+    totalRaw += sizes.raw;
+    totalGzipped += sizes.gzipped;
+    totalBrotli += sizes.brotli;
+
+    if (!budgetCheck.withinBudget) {
+      budgetViolations++;
+    }
+  }
+
+  return {
+    results,
+    totals: {
+      raw: totalRaw,
+      gzipped: totalGzipped,
+      brotli: totalBrotli,
+    },
+    budgetViolations,
+  };
+}
+
+/**
+ * Generate markdown report
+ */
+function generateMarkdownReport(analysis) {
+  const lines = [];
+
+  lines.push('# Bundle Size Analysis Report');
+  lines.push('');
+  lines.push(`**Generated:** ${new Date().toISOString()}`);
+  lines.push('');
+
+  // Summary
+  lines.push('## Summary');
+  lines.push('');
+  lines.push(`- **Total Raw Size:** ${formatBytes(analysis.totals.raw)}`);
+  lines.push(`- **Total Gzipped:** ${formatBytes(analysis.totals.gzipped)}`);
+  lines.push(`- **Total Brotli:** ${formatBytes(analysis.totals.brotli)}`);
+  lines.push(`- **Budget Violations:** ${analysis.budgetViolations}`);
+  lines.push('');
+
+  // Detailed results
+  lines.push('## Entry Points');
+  lines.push('');
+
+  for (const result of analysis.results) {
+    const { file, sizes, budgetCheck } = result;
+    const icon = budgetCheck.withinBudget ? '✅' : '❌';
+
+    lines.push(`### ${icon} \`${file}\``);
+    lines.push('');
+    lines.push('| Format | Size | Budget Status |');
+    lines.push('|--------|------|---------------|');
+    lines.push(`| Raw | ${formatBytes(sizes.raw)} | ${budgetCheck.rawPercent ? `${budgetCheck.rawPercent}% of budget` : 'N/A'} |`);
+    lines.push(`| Gzipped | ${formatBytes(sizes.gzipped)} | ${budgetCheck.gzipPercent ? `${budgetCheck.gzipPercent}% of budget` : 'N/A'} |`);
+    lines.push(`| Brotli | ${formatBytes(sizes.brotli)} | - |`);
+    lines.push('');
+
+    if (!budgetCheck.withinBudget) {
+      lines.push('**⚠️ Budget Exceeded:**');
+      if (budgetCheck.rawExceeded) {
+        lines.push(`- Raw size exceeds budget (${budgetCheck.rawPercent}%)`);
+      }
+      if (budgetCheck.gzipExceeded) {
+        lines.push(`- Gzipped size exceeds budget (${budgetCheck.gzipPercent}%)`);
+      }
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate JSON report
+ */
+function generateJsonReport(analysis) {
+  return JSON.stringify(analysis, null, 2);
+}
+
+/**
+ * Generate console report
+ */
+function generateConsoleReport(analysis) {
+  console.log('\n╔════════════════════════════════════════════════╗');
+  console.log('║         Bundle Size Analysis Report           ║');
+  console.log('╚════════════════════════════════════════════════╝\n');
+
+  console.log('📦 Total Sizes:');
+  console.log(`   Raw:     ${formatBytes(analysis.totals.raw)}`);
+  console.log(`   Gzipped: ${formatBytes(analysis.totals.gzipped)}`);
+  console.log(`   Brotli:  ${formatBytes(analysis.totals.brotli)}`);
+  console.log('');
+
+  console.log('📊 Entry Points:\n');
+
+  for (const result of analysis.results) {
+    const { file, sizes, budgetCheck } = result;
+    const icon = budgetCheck.withinBudget ? '✅' : '❌';
+
+    console.log(`${icon} ${file}`);
+    console.log(`   Raw:     ${formatBytes(sizes.raw).padEnd(12)} ${budgetCheck.rawPercent ? `(${budgetCheck.rawPercent}% of budget)` : ''}`);
+    console.log(`   Gzipped: ${formatBytes(sizes.gzipped).padEnd(12)} ${budgetCheck.gzipPercent ? `(${budgetCheck.gzipPercent}% of budget)` : ''}`);
+    console.log(`   Brotli:  ${formatBytes(sizes.brotli)}`);
+
+    if (!budgetCheck.withinBudget) {
+      console.log('   ⚠️  Budget exceeded!');
+    }
+    console.log('');
+  }
+
+  if (analysis.budgetViolations > 0) {
+    console.log(`⚠️  ${analysis.budgetViolations} budget violation(s) detected!\n`);
+    process.exit(1);
+  } else {
+    console.log('✅ All bundles within budget limits!\n');
+  }
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const args = process.argv.slice(2);
+  const format = args.find(arg => arg.startsWith('--format='))?.split('=')[1] || 'console';
+  const checkBudgets = args.includes('--check-budgets');
+
+  console.log('🔍 Analyzing bundle sizes...\n');
+
+  const analysis = analyzeBundles();
+
+  switch (format) {
+    case 'json':
+      console.log(generateJsonReport(analysis));
+      break;
+    case 'markdown':
+      console.log(generateMarkdownReport(analysis));
+      break;
+    case 'console':
+    default:
+      generateConsoleReport(analysis);
+      break;
+  }
+
+  if (checkBudgets && analysis.budgetViolations > 0) {
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { analyzeBundles, generateMarkdownReport, generateJsonReport };
+

package/scripts/copy-utils.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+
+/**
+ * Shared utilities for copying PDF.js files
+ * Used by both postinstall.js and setup.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Get the pdfjs-dist version from package.json
+ */
+function getPdfjsVersion() {
+  try {
+    const packageJsonPath = path.join(__dirname, '../package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return packageJson.dependencies['pdfjs-dist'];
+  } catch (error) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Get the saved version from target directory
+ */
+function getSavedVersion(targetDir) {
+  try {
+    const versionFile = path.join(targetDir, '.version');
+    if (fs.existsSync(versionFile)) {
+      return fs.readFileSync(versionFile, 'utf8').trim();
+    }
+  } catch (error) {
+    // Ignore
+  }
+  return null;
+}
+
+/**
+ * Copy a directory recursively
+ */
+function copyDirectory(src, dest) {
+  if (!fs.existsSync(src)) {
+    return false;
+  }
+
+  fs.mkdirSync(dest, { recursive: true });
+  
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+  
+  return true;
+}
+
+/**
+ * Find the pdfjs-dist package directory
+ */
+function findPdfjsDistPath() {
+  // Try require.resolve first (most reliable)
+  try {
+    const pdfjsPackagePath = require.resolve('pdfjs-dist/package.json');
+    return path.dirname(pdfjsPackagePath);
+  } catch (e) {
+    // Fallback to path searching
+  }
+  
+  // Start from our package's node_modules
+  let currentDir = __dirname;
+  
+  // Go up to our package root
+  currentDir = path.join(currentDir, '..');
+  
+  // Common locations to check
+  const searchPaths = [
+    // In the same node_modules (peer)
+    path.join(currentDir, '..', 'pdfjs-dist'),
+    // In our node_modules
+    path.join(currentDir, 'node_modules', 'pdfjs-dist'),
+    // In parent project's node_modules
+    path.join(currentDir, '..', '..', 'pdfjs-dist'),
+    // In parent project's node_modules (one more level up for monorepos)
+    path.join(currentDir, '..', '..', '..', 'pdfjs-dist'),
+    // Try from process.cwd() (user's project root)
+    path.join(process.cwd(), 'node_modules', 'pdfjs-dist'),
+  ];
+  
+  for (const searchPath of searchPaths) {
+    if (fs.existsSync(searchPath)) {
+      return searchPath;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Find the user's project root and public directory
+ */
+function findPublicDirectory() {
+  // Try process.cwd() first (where user ran npm install)
+  let projectRoot = process.cwd();
+  
+  // Verify it's a project root (has package.json or node_modules)
+  if (!fs.existsSync(path.join(projectRoot, 'package.json')) && 
+      !fs.existsSync(path.join(projectRoot, 'node_modules'))) {
+    // Fallback: navigate up from our package location
+    let currentDir = path.join(__dirname, '..');
+    let searchDir = currentDir;
+    
+    for (let i = 0; i < 5; i++) {
+      const parentDir = path.dirname(searchDir);
+      const nodeModulesDir = path.join(parentDir, 'node_modules');
+      const ourPackageDir = path.join(nodeModulesDir, '@signiphi', 'pdf-signer');
+      
+      if (fs.existsSync(nodeModulesDir) && fs.existsSync(ourPackageDir)) {
+        projectRoot = parentDir;
+        break;
+      }
+      
+      searchDir = parentDir;
+    }
+  }
+  
+  // Common public directory patterns
+  const publicDirCandidates = [
+    path.join(projectRoot, 'public'),
+    path.join(projectRoot, 'static'),
+    path.join(projectRoot, 'dist', 'public'),
+    path.join(projectRoot, 'src', 'public'),
+  ];
+  
+  for (const candidate of publicDirCandidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  
+  // Default to public directory (will be created if it doesn't exist)
+  return path.join(projectRoot, 'public');
+}
+
+/**
+ * Copy PDF.js files to target directory
+ * @param {string} targetDir - Target directory (e.g., public/pdfjs)
+ * @param {boolean} force - Force overwrite even if up to date
+ * @returns {boolean} Success status
+ */
+function copyPdfJsFiles(targetDir, force = false) {
+  // Find pdfjs-dist - try require.resolve first (most reliable)
+  let pdfjsPath = null;
+  try {
+    const pdfjsPackagePath = require.resolve('pdfjs-dist/package.json');
+    pdfjsPath = path.dirname(pdfjsPackagePath);
+  } catch (e) {
+    // Fallback to path searching
+    pdfjsPath = findPdfjsDistPath();
+  }
+  
+  if (!pdfjsPath || !fs.existsSync(pdfjsPath)) {
+    throw new Error('pdfjs-dist package not found. Make sure it is installed.');
+  }
+  
+  // Check if already up to date
+  if (!force) {
+    const currentVersion = getPdfjsVersion();
+    const savedVersion = getSavedVersion(targetDir);
+    
+    if (currentVersion === savedVersion && fs.existsSync(targetDir)) {
+      return false; // Already up to date
+    }
+  }
+  
+  // Create target directory
+  fs.mkdirSync(targetDir, { recursive: true });
+  
+  // Copy build directory (contains pdf.worker.mjs and other build files)
+  const buildSrc = path.join(pdfjsPath, 'build');
+  const buildDest = path.join(targetDir, 'build');
+  if (!copyDirectory(buildSrc, buildDest)) {
+    throw new Error('Failed to copy build directory');
+  }
+  
+  // Copy web directory (contains pdf_viewer.mjs, css, and assets)
+  const webSrc = path.join(pdfjsPath, 'web');
+  const webDest = path.join(targetDir, 'web');
+  if (!copyDirectory(webSrc, webDest)) {
+    throw new Error('Failed to copy web directory');
+  }
+
+  // Copy custom viewer.html from our package assets
+  // PDF.js 5.x no longer includes viewer.html, so we provide our own
+  const customViewerSrc = path.join(__dirname, '..', 'assets', 'viewer.html');
+  const customViewerDest = path.join(webDest, 'viewer.html');
+
+  if (fs.existsSync(customViewerSrc)) {
+    fs.copyFileSync(customViewerSrc, customViewerDest);
+  } else {
+    throw new Error('Custom viewer.html template not found in package assets');
+  }
+
+  // Write version file
+  const currentVersion = getPdfjsVersion();
+  const versionFile = path.join(targetDir, '.version');
+  fs.writeFileSync(versionFile, currentVersion, 'utf8');
+
+  return true; // Copy successful
+}
+
+module.exports = {
+  getPdfjsVersion,
+  getSavedVersion,
+  copyDirectory,
+  findPdfjsDistPath,
+  findPublicDirectory,
+  copyPdfJsFiles,
+};
+

package/scripts/copy-utils.test.js

@@ -0,0 +1,164 @@
+/**
+ * Tests for copy-utils.js
+ * Note: These are basic smoke tests. Full integration tests would require actual file system operations.
+ */
+
+const { describe, it, expect, beforeEach, afterEach } = require('vitest');
+const fs = require('fs');
+const path = require('path');
+const copyUtils = require('./copy-utils.js');
+
+describe('copy-utils', () => {
+  describe('getPdfjsVersion', () => {
+    it('should return a version string', () => {
+      const version = copyUtils.getPdfjsVersion();
+      expect(version).toBeDefined();
+      expect(typeof version).toBe('string');
+      // Should be a valid version or 'unknown'
+      expect(version).toMatch(/^\d+\.\d+\.\d+$|^unknown$/);
+    });
+  });
+
+  describe('getSavedVersion', () => {
+    const testDir = path.join(__dirname, '__test_temp__');
+    const versionFile = path.join(testDir, '.version');
+
+    beforeEach(() => {
+      // Create test directory
+      if (!fs.existsSync(testDir)) {
+        fs.mkdirSync(testDir, { recursive: true });
+      }
+    });
+
+    afterEach(() => {
+      // Cleanup test directory
+      if (fs.existsSync(testDir)) {
+        fs.rmSync(testDir, { recursive: true, force: true });
+      }
+    });
+
+    it('should return null if version file does not exist', () => {
+      const version = copyUtils.getSavedVersion(testDir);
+      expect(version).toBeNull();
+    });
+
+    it('should return version from .version file', () => {
+      fs.writeFileSync(versionFile, '5.3.93', 'utf8');
+      const version = copyUtils.getSavedVersion(testDir);
+      expect(version).toBe('5.3.93');
+    });
+
+    it('should trim whitespace from version file', () => {
+      fs.writeFileSync(versionFile, '  5.3.93  \n', 'utf8');
+      const version = copyUtils.getSavedVersion(testDir);
+      expect(version).toBe('5.3.93');
+    });
+  });
+
+  describe('findPdfjsDistPath', () => {
+    it('should find pdfjs-dist package', () => {
+      const pdfjsPath = copyUtils.findPdfjsDistPath();
+      // Should either find it or return null (if not installed)
+      if (pdfjsPath) {
+        expect(fs.existsSync(pdfjsPath)).toBe(true);
+        expect(pdfjsPath).toContain('pdfjs-dist');
+      }
+    });
+  });
+
+  describe('copyDirectory', () => {
+    const testSrcDir = path.join(__dirname, '__test_src__');
+    const testDestDir = path.join(__dirname, '__test_dest__');
+
+    beforeEach(() => {
+      // Create test source directory with sample files
+      if (!fs.existsSync(testSrcDir)) {
+        fs.mkdirSync(testSrcDir, { recursive: true });
+        fs.writeFileSync(path.join(testSrcDir, 'test.txt'), 'test content');
+        fs.mkdirSync(path.join(testSrcDir, 'subdir'), { recursive: true });
+        fs.writeFileSync(path.join(testSrcDir, 'subdir', 'nested.txt'), 'nested content');
+      }
+    });
+
+    afterEach(() => {
+      // Cleanup test directories
+      if (fs.existsSync(testSrcDir)) {
+        fs.rmSync(testSrcDir, { recursive: true, force: true });
+      }
+      if (fs.existsSync(testDestDir)) {
+        fs.rmSync(testDestDir, { recursive: true, force: true });
+      }
+    });
+
+    it('should copy directory and its contents', () => {
+      const result = copyUtils.copyDirectory(testSrcDir, testDestDir);
+      
+      expect(result).toBe(true);
+      expect(fs.existsSync(testDestDir)).toBe(true);
+      expect(fs.existsSync(path.join(testDestDir, 'test.txt'))).toBe(true);
+      expect(fs.existsSync(path.join(testDestDir, 'subdir', 'nested.txt'))).toBe(true);
+      
+      const content = fs.readFileSync(path.join(testDestDir, 'test.txt'), 'utf8');
+      expect(content).toBe('test content');
+    });
+
+    it('should return false if source does not exist', () => {
+      const result = copyUtils.copyDirectory('/nonexistent/path', testDestDir);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('copyPdfJsFiles', () => {
+    const testTargetDir = path.join(__dirname, '__test_pdfjs__');
+
+    afterEach(() => {
+      // Cleanup test directory
+      if (fs.existsSync(testTargetDir)) {
+        fs.rmSync(testTargetDir, { recursive: true, force: true });
+      }
+    });
+
+    it('should handle missing pdfjs-dist gracefully', () => {
+      // This test might fail if pdfjs-dist is actually installed
+      // It's mainly to check that the function doesn't crash
+      try {
+        copyUtils.copyPdfJsFiles(testTargetDir, false);
+      } catch (error) {
+        // Expected to throw if pdfjs-dist is not found
+        expect(error.message).toContain('pdfjs-dist');
+      }
+    });
+
+    it('should not copy if already up to date', () => {
+      const pdfjsPath = copyUtils.findPdfjsDistPath();
+      if (!pdfjsPath) {
+        // Skip test if pdfjs-dist is not available
+        return;
+      }
+
+      // First copy
+      copyUtils.copyPdfJsFiles(testTargetDir, false);
+      expect(fs.existsSync(testTargetDir)).toBe(true);
+
+      // Second copy should not happen (up to date)
+      const result = copyUtils.copyPdfJsFiles(testTargetDir, false);
+      expect(result).toBe(false);
+    });
+
+    it('should force copy when force flag is true', () => {
+      const pdfjsPath = copyUtils.findPdfjsDistPath();
+      if (!pdfjsPath) {
+        // Skip test if pdfjs-dist is not available
+        return;
+      }
+
+      // First copy
+      copyUtils.copyPdfJsFiles(testTargetDir, false);
+      
+      // Force copy should always happen
+      const result = copyUtils.copyPdfJsFiles(testTargetDir, true);
+      expect(result).toBe(true);
+    });
+  });
+});
+