npm - diffx-js - Versions diffs - 0.5.21 → 0.6.1 - Mend

diffx-js 0.5.21 → 0.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md +101 -73
package/diffx-js.linux-x64-gnu.node +0 -0
package/index.d.ts +0 -157
package/package.json +48 -32
package/examples.ts +0 -320
package/test.js +0 -326

package/README.md CHANGED Viewed

@@ -1,6 +1,6 @@
 # diffx-js
-A Node.js wrapper for the `diffx` CLI tool.
+Node.js bindings for [diffx](https://github.com/kako-jun/diffx) - semantic diff for structured data (JSON, YAML, TOML, XML, INI, CSV). Powered by Rust via napi-rs for blazing fast performance.
 ## Installation
@@ -8,98 +8,126 @@ A Node.js wrapper for the `diffx` CLI tool.
 npm install diffx-js
 ```
-This package includes pre-compiled `diffx` binaries for all supported platforms (Linux x64, macOS x64/ARM64, Windows x64), enabling **completely offline installation** with no external downloads required.
 ### Supported Platforms
-- **Linux x64** - Intel/AMD 64-bit
-- **macOS x64** - Intel-based Macs
-- **macOS ARM64** - Apple Silicon Macs (M1/M2/M3)
-- **Windows x64** - 64-bit Windows
-The appropriate binary is automatically selected at runtime based on your system.
-**Note:** Due to bundling all platform binaries, this package is larger (~20MB) than typical npm packages but provides complete offline functionality.
+| Platform | Architecture |
+|----------|--------------|
+| Linux | x64 (glibc) |
+| Linux | x64 (musl/Alpine) |
+| Linux | ARM64 |
+| macOS | x64 (Intel) |
+| macOS | ARM64 (Apple Silicon) |
+| Windows | x64 |
 ## Usage
+### Basic Diff
 ```javascript
 const { diff } = require('diffx-js');
-// Compare two JavaScript objects
-const old = { name: "Alice", age: 30, city: "Tokyo" };
-const newObj = { name: "Alice", age: 31, country: "Japan" };
-const result = diff(old, newObj);
-if (result.length === 0) {
-  console.log("No differences found.");
-} else {
-  console.log("Differences found:");
-  for (const change of result) {
-    console.log(`${change.diffType}: ${change.path}`);
-    if (change.oldValue !== undefined) {
-      console.log(`  Old: ${change.oldValue}`);
-    }
-    if (change.newValue !== undefined) {
-      console.log(`  New: ${change.newValue}`);
-    }
-  }
+const old = { name: "Alice", age: 30 };
+const newObj = { name: "Alice", age: 31, city: "Tokyo" };
+const results = diff(old, newObj);
+for (const change of results) {
+  console.log(`${change.diffType}: ${change.path}`);
+  // Modified: age
+  // Added: city
 }
+```
+### With Options
-// Compare with options
-const data1 = {
-  values: [1.0001, 2.0002, 3.0003],
-  metadata: { timestamp: "2024-01-01" }
-};
-const data2 = {
-  values: [1.0002, 2.0003, 3.0004],
-  metadata: { timestamp: "2024-01-02" }
-};
-const preciseResult = diff(data1, data2, {
-  epsilon: 0.001,
-  ignoreKeysRegex: "timestamp"
+```javascript
+const results = diff(data1, data2, {
+  epsilon: 0.001,           // Tolerance for float comparison
+  arrayIdKey: 'id',         // Match array elements by ID
+  ignoreKeysRegex: 'timestamp|updatedAt',  // Ignore keys matching regex
+  pathFilter: 'user',       // Only show diffs in paths containing "user"
+  ignoreCase: true,         // Ignore case differences
+  ignoreWhitespace: true,   // Ignore whitespace differences
 });
+```
+### Parsers
+Parse various formats to JavaScript objects:
-console.log(`Found ${preciseResult.length} significant differences`);
+```javascript
+const { parseJson, parseYaml, parseToml, parseCsv, parseIni, parseXml } = require('diffx-js');
+const jsonObj = parseJson('{"name": "Alice"}');
+const yamlObj = parseYaml('name: Alice\nage: 30');
+const tomlObj = parseToml('name = "Alice"');
+const csvArray = parseCsv('name,age\nAlice,30');
+const iniObj = parseIni('[user]\nname = Alice');
+const xmlObj = parseXml('<user><name>Alice</name></user>');
 ```
+### Format Output
-### API Reference
-#### `diff(old, new, options?)`
-- **old**: The old JavaScript object, array, or primitive value
-- **new**: The new JavaScript object, array, or primitive value
-- **options**: Optional configuration object
-  - `epsilon`: Tolerance for floating-point comparisons (default: 0.0)
-  - `arrayIdKey`: Key to use for array element identification
-  - `ignoreKeysRegex`: Regex pattern for keys to ignore
-  - `pathFilter`: Only show differences in paths containing this string
-  - `outputFormat`: Output format ("diffx", "json", "yaml")
-  - `showUnchanged`: Show unchanged values as well
-  - `showTypes`: Show type information in output
-  - `ignoreWhitespace`: Ignore whitespace differences
-  - `ignoreCase`: Ignore case differences
-  - `briefMode`: Report only whether objects differ
-  - `quietMode`: Suppress normal output; return only results
-#### Return Value
-Returns an array of `JsDiffResult` objects, each containing:
-- `diffType`: Type of difference ('Added', 'Removed', 'Modified', 'TypeChanged')
-- `path`: Path to the changed element
-- `oldValue`: Old value (for Modified/TypeChanged/Removed)
-- `newValue`: New value (for Modified/TypeChanged/Added)
-- `value`: Value (for Removed differences)
+```javascript
+const { diff, formatOutput } = require('diffx-js');
-## Development
+const results = diff(old, newObj);
+console.log(formatOutput(results, 'json'));  // JSON format
+console.log(formatOutput(results, 'yaml'));  // YAML format
+console.log(formatOutput(results, 'diffx')); // diffx format
+```
+## API Reference
+### `diff(old, new, options?)`
+Compare two values and return differences.
+**Options:**
+| Option | Type | Description |
+|--------|------|-------------|
+| `epsilon` | number | Tolerance for floating-point comparisons |
+| `arrayIdKey` | string | Key to identify array elements |
+| `ignoreKeysRegex` | string | Regex pattern for keys to ignore |
+| `pathFilter` | string | Only show diffs in matching paths |
+| `outputFormat` | string | Output format ("diffx", "json", "yaml") |
+| `ignoreWhitespace` | boolean | Ignore whitespace differences |
+| `ignoreCase` | boolean | Ignore case differences |
+| `briefMode` | boolean | Report only whether objects differ |
+| `quietMode` | boolean | Suppress normal output |
+**Returns:** Array of `JsDiffResult`:
+```typescript
+interface JsDiffResult {
+  diffType: 'Added' | 'Removed' | 'Modified' | 'TypeChanged';
+  path: string;
+  oldValue?: any;   // For Modified/TypeChanged
+  newValue?: any;   // For Added/Modified/TypeChanged
+  value?: any;      // For Removed
+}
+```
+### Parsers
+- `parseJson(content: string): any`
+- `parseYaml(content: string): any`
+- `parseToml(content: string): any`
+- `parseCsv(content: string): any[]`
+- `parseIni(content: string): any`
+- `parseXml(content: string): any`
-To link for local development:
+### `formatOutput(results, format)`
+Format diff results as string. Format: "json", "yaml", or "diffx".
+## Development
 ```bash
-npm link
+npm install     # Install dependencies
+npm run build   # Build native module
+npm test        # Run tests (51 tests)
 ```
 ## License
-This project is licensed under the MIT License.
+MIT

package/diffx-js.linux-x64-gnu.node CHANGED Viewed

Binary file

package/index.d.ts CHANGED Viewed

@@ -1,157 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/* auto-generated by NAPI-RS */
-export interface JsDiffOptions {
-  /** Numerical comparison tolerance */
-  epsilon?: number
-  /** Key to use for array element identification */
-  arrayIdKey?: string
-  /** Regex pattern for keys to ignore */
-  ignoreKeysRegex?: string
-  /** Only show differences in paths containing this string */
-  pathFilter?: string
-  /** Output format */
-  outputFormat?: string
-  /** Show unchanged values as well */
-  showUnchanged?: boolean
-  /** Show type information in output */
-  showTypes?: boolean
-  /** Enable memory optimization for large files */
-  useMemoryOptimization?: boolean
-  /** Batch size for memory optimization */
-  batchSize?: number
-  /** Ignore whitespace differences */
-  ignoreWhitespace?: boolean
-  /** Ignore case differences */
-  ignoreCase?: boolean
-  /** Report only whether files differ */
-  briefMode?: boolean
-  /** Suppress normal output; return only exit status */
-  quietMode?: boolean
-}
-export interface JsDiffResult {
-  /** Type of difference ('Added', 'Removed', 'Modified', 'TypeChanged') */
-  diffType: string
-  /** Path to the changed element */
-  path: string
-  /** Old value (for Modified/TypeChanged) */
-  oldValue?: any
-  /** New value (for Modified/TypeChanged/Added) */
-  newValue?: any
-  /** Value (for Removed) */
-  value?: any
-}
-/**
- * Unified diff function for JavaScript/Node.js
- *
- * Compare two JavaScript objects or values and return differences.
- *
- * # Arguments
- *
- * * `old` - The old value (JavaScript object, array, or primitive)
- * * `new` - The new value (JavaScript object, array, or primitive)
- * * `options` - Optional configuration object
- *
- * # Returns
- *
- * Array of difference objects
- *
- * # Example
- *
- * ```javascript
- * const { diff } = require('diffx-js');
- *
- * const old = { a: 1, b: 2 };
- * const new = { a: 1, b: 3 };
- * const result = diff(old, new);
- * console.log(result); // [{ type: 'Modified', path: 'b', oldValue: 2, newValue: 3 }]
- * ```
- */
-export declare function diff(old: any, new: any, options?: JsDiffOptions | undefined | null): Array<JsDiffResult>
-/**
- * Parse JSON string to JavaScript object
- *
- * # Arguments
- *
- * * `content` - JSON string to parse
- *
- * # Returns
- *
- * Parsed JavaScript object
- */
-export declare function parseJson(content: string): any
-/**
- * Parse CSV string to JavaScript array of objects
- *
- * # Arguments
- *
- * * `content` - CSV string to parse
- *
- * # Returns
- *
- * Array of JavaScript objects representing CSV rows
- */
-export declare function parseCsv(content: string): any
-/**
- * Parse YAML string to JavaScript object
- *
- * # Arguments
- *
- * * `content` - YAML string to parse
- *
- * # Returns
- *
- * Parsed JavaScript object
- */
-export declare function parseYaml(content: string): any
-/**
- * Parse TOML string to JavaScript object
- *
- * # Arguments
- *
- * * `content` - TOML string to parse
- *
- * # Returns
- *
- * Parsed JavaScript object
- */
-export declare function parseToml(content: string): any
-/**
- * Parse INI string to JavaScript object
- *
- * # Arguments
- *
- * * `content` - INI string to parse
- *
- * # Returns
- *
- * Parsed JavaScript object
- */
-export declare function parseIni(content: string): any
-/**
- * Parse XML string to JavaScript object
- *
- * # Arguments
- *
- * * `content` - XML string to parse
- *
- * # Returns
- *
- * Parsed JavaScript object
- */
-export declare function parseXml(content: string): any
-/**
- * Format diff results as string
- *
- * # Arguments
- *
- * * `results` - Array of diff results
- * * `format` - Output format ("diffx", "json", "yaml")
- *
- * # Returns
- *
- * Formatted string output
- */
-export declare function formatOutput(results: Array<JsDiffResult>, format: string): string

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "diffx-js",
-  "version": "0.5.21",
-  "description": "A Node.js wrapper for the diffx CLI tool - semantic diffing of JSON, YAML, TOML, XML, INI, and CSV files. Focuses on structural meaning rather than formatting.",
+  "version": "0.6.1",
+  "description": "Node.js bindings for diffx - semantic diffing of JSON, YAML, TOML, XML, INI, and CSV files. Powered by Rust for blazing fast performance.",
   "keywords": [
     "diff",
     "json",
@@ -10,7 +10,6 @@
     "xml",
     "ini",
     "csv",
-    "cli",
     "structured",
     "configuration",
     "semantic",
@@ -18,29 +17,30 @@
     "devops",
     "ci-cd",
     "automation",
-    "data-analysis"
+    "data-analysis",
+    "napi-rs",
+    "rust"
   ],
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
     "build": "napi build --platform --release",
     "build:debug": "napi build --platform",
-    "test": "npm run build && cd tests && npm test",
-    "examples": "npm run build && npx tsx examples.ts",
-    "verify": "npm run build && node -e \"console.log(require('./index.js'))\"",
-    "prepublish": "npm run build",
-    "artifacts": "napi artifacts"
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "prepublishOnly": "napi prepublish -t npm",
+    "artifacts": "napi artifacts",
+    "version": "napi version",
+    "prepare": "husky"
   },
   "engines": {
-    "node": ">=12.0.0"
+    "node": ">=16.0.0"
   },
   "files": [
     "index.js",
     "index.d.ts",
-    "*.node",
-    "README.md",
-    "examples.ts",
-    "test.js"
+    "*.node"
   ],
   "os": [
     "linux",
@@ -53,34 +53,50 @@
   ],
   "author": "kako-jun",
   "license": "MIT",
-  "homepage": "https://github.com/kako-jun/diffx",
+  "homepage": "https://github.com/kako-jun/diffx-js",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/kako-jun/diffx.git",
-    "directory": "diffx-js"
+    "url": "git+https://github.com/kako-jun/diffx-js.git"
   },
   "bugs": {
-    "url": "https://github.com/kako-jun/diffx/issues"
+    "url": "https://github.com/kako-jun/diffx-js/issues"
   },
   "funding": {
     "type": "github",
     "url": "https://github.com/sponsors/kako-jun"
   },
   "devDependencies": {
-    "@napi-rs/cli": "^2.18.0"
+    "@napi-rs/cli": "^3.5.0",
+    "husky": "^9.1.7",
+    "jest": "^30.2.0"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "roots": [
+      "<rootDir>/tests"
+    ],
+    "testMatch": [
+      "**/*.test.js"
+    ],
+    "forceExit": true
   },
   "napi": {
-    "name": "diffx-js",
-    "triples": {
-      "defaults": false,
-      "additional": [
-        "x86_64-pc-windows-msvc",
-        "aarch64-pc-windows-msvc",
-        "x86_64-apple-darwin",
-        "aarch64-apple-darwin",
-        "x86_64-unknown-linux-gnu",
-        "aarch64-unknown-linux-gnu"
-      ]
-    }
+    "binaryName": "diffx-js",
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "x86_64-pc-windows-msvc"
+    ]
+  },
+  "optionalDependencies": {
+    "diffx-js-linux-x64-gnu": "0.6.1",
+    "diffx-js-linux-x64-musl": "0.6.1",
+    "diffx-js-linux-arm64-gnu": "0.6.1",
+    "diffx-js-darwin-x64": "0.6.1",
+    "diffx-js-darwin-arm64": "0.6.1",
+    "diffx-js-win32-x64-msvc": "0.6.1"
   }
-}
+}

package/examples.ts DELETED Viewed

@@ -1,320 +0,0 @@
-#!/usr/bin/env tsx
-/**
- * diffx-js TypeScript Examples - UNIFIED API DESIGN
- *
- * Demonstrates native NAPI-RS API usage for semantic diffing
- * Users parse files themselves and call the unified diff() function
- */
-import { diff, DiffOptions, DiffResult } from './index';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-// Colors for console output
-const colors = {
-    green: '\x1b[32m',
-    red: '\x1b[31m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    cyan: '\x1b[36m',
-    magenta: '\x1b[35m',
-    reset: '\x1b[0m'
-} as const;
-function log(message: string, color: keyof typeof colors = 'reset'): void {
-    console.log(`${colors[color]}${message}${colors.reset}`);
-}
-function header(message: string): void {
-    log(`\n${message}`, 'cyan');
-    log('='.repeat(message.length), 'cyan');
-}
-function example(title: string, description: string): void {
-    log(`\n${title}`, 'yellow');
-    log(`   ${description}`, 'blue');
-}
-async function runExamples(): Promise<void> {
-    header('diffx-js Native API Examples');
-    // Create temporary directory
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'diffx-examples-'));
-    const oldCwd = process.cwd();
-    process.chdir(tempDir);
-    try {
-        // Example 1: Basic JSON Configuration Comparison
-        header('1. Basic JSON Configuration Comparison');
-        const config1 = {
-            app: {
-                name: "my-app",
-                version: "1.0.0",
-                database: {
-                    host: "localhost",
-                    port: 5432,
-                    ssl: false
-                }
-            },
-            features: ["auth", "logging"]
-        };
-        const config2 = {
-            app: {
-                name: "my-app",
-                version: "1.1.0",
-                database: {
-                    host: "prod-db.example.com",
-                    port: 5432,
-                    ssl: true
-                }
-            },
-            features: ["auth", "logging", "metrics"]
-        };
-        example(
-            'Application Configuration Migration',
-            'Compare two versions of app configuration using native API'
-        );
-        const results1 = diff(config1, config2);
-        log('API Results:', 'green');
-        console.log(JSON.stringify(results1, null, 2));
-        // Example 2: YAML Configuration with Options
-        header('2. Advanced Options Usage');
-        const oldYaml = `
-name: CI
-on:
-  push:
-    branches: [main]
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - run: npm test
-`;
-        const newYaml = `
-name: CI
-on:
-  push:
-    branches: [main, develop]
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [16, 18, 20]
-    steps:
-      - uses: actions/checkout@v4
-      - run: npm ci
-      - run: npm test
-`;
-        // Parse YAML using js-yaml (users would do this)
-        const yaml = await import('js-yaml');
-        const oldData = yaml.load(oldYaml) as any;
-        const newData = yaml.load(newYaml) as any;
-        const options: DiffOptions = {
-            outputFormat: 'json',
-            showTypes: true,
-            ignoreKeysRegex: '^(timestamp|updated_at)',
-            diffxOptions: {
-                ignoreWhitespace: true,
-                contextLines: 2
-            }
-        };
-        example(
-            'YAML Comparison with Advanced Options',
-            'Parse YAML yourself and use diffx options for customized output'
-        );
-        const results2 = diff(oldData, newData, options);
-        log('Filtered Results:', 'green');
-        console.log(JSON.stringify(results2, null, 2));
-        // Example 3: Array Comparison with ID Key
-        header('3. Smart Array Comparison');
-        const oldUsers = {
-            users: [
-                { id: 1, name: "Alice", role: "admin" },
-                { id: 2, name: "Bob", role: "user" },
-                { id: 3, name: "Charlie", role: "user" }
-            ]
-        };
-        const newUsers = {
-            users: [
-                { id: 1, name: "Alice", role: "admin" },
-                { id: 2, name: "Bob", role: "moderator" },
-                { id: 4, name: "David", role: "user" }
-            ]
-        };
-        const arrayOptions: DiffOptions = {
-            arrayIdKey: 'id',
-            showUnchanged: false
-        };
-        example(
-            'User Management Changes with Array ID Matching',
-            'Track user changes by ID rather than array position'
-        );
-        const results3 = diff(oldUsers, newUsers, arrayOptions);
-        log('User Changes:', 'green');
-        results3.forEach((result: DiffResult) => {
-            console.log(`${result.type}: ${result.path}`);
-            if (result.oldValue) console.log(`  Old: ${JSON.stringify(result.oldValue)}`);
-            if (result.newValue) console.log(`  New: ${JSON.stringify(result.newValue)}`);
-        });
-        // Example 4: Error Handling
-        header('4. Error Handling');
-        example(
-            'Handling Invalid Data Gracefully',
-            'Demonstrate proper error handling for malformed data'
-        );
-        try {
-            // Simulate circular reference (not serializable)
-            const circularObj: any = { name: "test" };
-            circularObj.self = circularObj;
-            diff({ valid: "data" }, circularObj);
-        } catch (error) {
-            log(`Caught expected error: ${error}`, 'red');
-        }
-        // Example 5: Performance with Large Data
-        header('5. Large Data Performance');
-        const largeData1 = {
-            items: Array.from({ length: 1000 }, (_, i) => ({
-                id: i,
-                value: Math.random(),
-                category: `cat_${i % 10}`
-            }))
-        };
-        const largeData2 = {
-            items: Array.from({ length: 1000 }, (_, i) => ({
-                id: i,
-                value: Math.random(),
-                category: `cat_${i % 10}`,
-                newField: i % 100 === 0 ? "special" : undefined
-            })).filter(item => item.newField !== undefined || Math.random() > 0.1)
-        };
-        const perfOptions: DiffOptions = {
-            useMemoryOptimization: true,
-            batchSize: 100,
-            arrayIdKey: 'id'
-        };
-        example(
-            'Large Dataset Comparison with Memory Optimization',
-            'Handle large datasets efficiently with batching'
-        );
-        const startTime = Date.now();
-        const results5 = diff(largeData1, largeData2, perfOptions);
-        const endTime = Date.now();
-        log(`Processed ${results5.length} differences in ${endTime - startTime}ms`, 'green');
-        // Example 6: TypeScript Integration Patterns
-        header('6. TypeScript Integration Patterns');
-        interface ConfigSchema {
-            database: {
-                host: string;
-                port: number;
-                ssl: boolean;
-            };
-            features: string[];
-        }
-        const typedConfig1: ConfigSchema = {
-            database: { host: "localhost", port: 5432, ssl: false },
-            features: ["auth"]
-        };
-        const typedConfig2: ConfigSchema = {
-            database: { host: "remote", port: 5433, ssl: true },
-            features: ["auth", "logging"]
-        };
-        example(
-            'Type-Safe Configuration Comparison',
-            'Use TypeScript interfaces for better development experience'
-        );
-        const results6 = diff(typedConfig1, typedConfig2);
-        // Type-safe result processing
-        results6.forEach((result: DiffResult) => {
-            switch (result.type) {
-                case 'added':
-                    log(`➕ Added: ${result.path} = ${JSON.stringify(result.newValue)}`, 'green');
-                    break;
-                case 'removed':
-                    log(`➖ Removed: ${result.path} = ${JSON.stringify(result.oldValue)}`, 'red');
-                    break;
-                case 'modified':
-                    log(`🔄 Modified: ${result.path}`, 'yellow');
-                    log(`   Old: ${JSON.stringify(result.oldValue)}`, 'red');
-                    log(`   New: ${JSON.stringify(result.newValue)}`, 'green');
-                    break;
-                case 'typeChanged':
-                    log(`🔀 Type Changed: ${result.path} (${result.oldType} → ${result.newType})`, 'magenta');
-                    break;
-            }
-        });
-        // Summary
-        header('Summary');
-        log('✅ All examples completed successfully!', 'green');
-        log('\nKey Benefits of Native API:', 'cyan');
-        log('  • No external CLI dependency', 'blue');
-        log('  • Better error handling', 'blue');
-        log('  • Type safety with TypeScript', 'blue');
-        log('  • Memory efficient for large data', 'blue');
-        log('  • Customizable output formats', 'blue');
-        log('  • Integration-friendly', 'blue');
-        log('\nNext Steps:', 'cyan');
-        log('  • See TypeScript definitions for full API', 'blue');
-        log('  • Check documentation for advanced options', 'blue');
-        log('  • Integrate into your CI/CD pipeline', 'blue');
-    } catch (error) {
-        log(`\nError running examples: ${error}`, 'red');
-        console.error(error);
-    } finally {
-        // Cleanup
-        process.chdir(oldCwd);
-        try {
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        } catch (cleanupErr) {
-            log(`Cleanup warning: ${cleanupErr}`, 'yellow');
-        }
-    }
-}
-// Run examples if called directly
-if (require.main === module) {
-    runExamples().catch(console.error);
-}
-export { runExamples };

package/test.js DELETED Viewed

@@ -1,326 +0,0 @@
-#!/usr/bin/env node
-/**
- * Test script for diffx-js npm package
- * Verifies basic functionality and integration
- */
-const { spawn } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-// Colors for output
-const colors = {
-    green: '\x1b[32m',
-    red: '\x1b[31m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    reset: '\x1b[0m'
-};
-function log(message, color = 'reset') {
-    console.log(`${colors[color]}${message}${colors.reset}`);
-}
-function success(message) {
-    log(`PASS: ${message}`, 'green');
-}
-function error(message) {
-    log(`ERROR: ${message}`, 'red');
-}
-function info(message) {
-    log(`INFO: ${message}`, 'blue');
-}
-// Test data
-const testData = {
-    json1: '{"name": "test-app", "version": "1.0.0", "debug": true}',
-    json2: '{"debug": false, "version": "1.1.0", "name": "test-app"}',
-    yaml1: 'name: test-app\nversion: "1.0.0"\ndebug: true\n',
-    yaml2: 'name: test-app\nversion: "1.1.0"\ndebug: false\n',
-    // Test data for new options
-    caseTest1: '{"status": "Active", "level": "Info"}',
-    caseTest2: '{"status": "ACTIVE", "level": "INFO"}',
-    whitespaceTest1: '{"text": "Hello  World", "message": "Test\\tValue"}',
-    whitespaceTest2: '{"text": "Hello World", "message": "Test Value"}',
-    contextTest1: '{"host": "localhost", "port": 5432, "name": "myapp"}',
-    contextTest2: '{"host": "localhost", "port": 5433, "name": "myapp"}'
-};
-// Create temporary test directory
-const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'diffx-test-'));
-process.chdir(tempDir);
-async function runCommand(command, args = [], options = {}) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            ...options
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (data) => {
-            stdout += data.toString();
-        });
-        child.stderr.on('data', (data) => {
-            stderr += data.toString();
-        });
-        child.on('close', (code) => {
-            resolve({ code, stdout, stderr });
-        });
-        child.on('error', (err) => {
-            reject(err);
-        });
-    });
-}
-async function runTests() {
-    info('Starting diffx-js package tests...');
-    try {
-        // Test 1: Check if diffx command is available
-        info('Test 1: Checking diffx command availability...');
-        const versionResult = await runCommand('node', [path.join(__dirname, 'index.js'), '--version']);
-        if (versionResult.code === 0) {
-            success(`diffx command available: ${versionResult.stdout.trim()}`);
-        } else {
-            error('diffx command not available');
-            throw new Error('Command not available');
-        }
-        // Test 2: Help command
-        info('Test 2: Testing help command...');
-        const helpResult = await runCommand('node', [path.join(__dirname, 'index.js'), '--help']);
-        if (helpResult.code === 0 && helpResult.stdout.includes('diffx')) {
-            success('Help command works correctly');
-        } else {
-            error('Help command failed');
-            throw new Error('Help command failed');
-        }
-        // Test 3: Basic JSON diff
-        info('Test 3: Testing basic JSON diff...');
-        fs.writeFileSync('test1.json', testData.json1);
-        fs.writeFileSync('test2.json', testData.json2);
-        const diffResult = await runCommand('node', [
-            path.join(__dirname, 'index.js'),
-            'test1.json',
-            'test2.json'
-        ]);
-        if (diffResult.code === 1 &&
-            diffResult.stdout.includes('version') &&
-            diffResult.stdout.includes('debug')) {
-            success('Basic JSON diff works correctly');
-        } else {
-            error(`JSON diff failed. Code: ${diffResult.code}, Stdout: ${diffResult.stdout}, Stderr: ${diffResult.stderr}`);
-            throw new Error('JSON diff failed');
-        }
-        // Test 4: JSON output format
-        info('Test 4: Testing JSON output format...');
-        const jsonOutputResult = await runCommand('node', [
-            path.join(__dirname, 'index.js'),
-            'test1.json',
-            'test2.json',
-            '--output',
-            'json'
-        ]);
-        if (jsonOutputResult.code === 1) {
-            try {
-                const output = JSON.parse(jsonOutputResult.stdout);
-                if (Array.isArray(output) && output.length > 0) {
-                    success('JSON output format works correctly');
-                } else {
-                    error('JSON output format invalid structure');
-                    throw new Error('Invalid JSON structure');
-                }
-            } catch (parseError) {
-                error(`JSON output parsing failed: ${parseError.message}`);
-                throw new Error('JSON parsing failed');
-            }
-        } else {
-            error(`JSON output failed: ${jsonOutputResult.stderr}`);
-            throw new Error('JSON output failed');
-        }
-        // Test 5: YAML files
-        info('Test 5: Testing YAML file diff...');
-        fs.writeFileSync('test1.yaml', testData.yaml1);
-        fs.writeFileSync('test2.yaml', testData.yaml2);
-        const yamlResult = await runCommand('node', [
-            path.join(__dirname, 'index.js'),
-            'test1.yaml',
-            'test2.yaml'
-        ]);
-        if (yamlResult.code === 1 && yamlResult.stdout.includes('version')) {
-            success('YAML diff works correctly');
-        } else {
-            error(`YAML diff failed: ${yamlResult.stderr}`);
-            throw new Error('YAML diff failed');
-        }
-        // Test 6: Stdin processing
-        info('Test 6: Testing stdin processing...');
-        // Use spawn directly with proper stdin handling
-        const stdinChild = spawn('node', [
-            path.join(__dirname, 'index.js'),
-            '-',
-            path.join(__dirname, 'fixtures', 'test2.json')
-        ], { stdio: ['pipe', 'pipe', 'pipe'] });
-        stdinChild.stdin.write(testData.json1);
-        stdinChild.stdin.end();
-        let stdinOutput = '';
-        stdinChild.stdout.on('data', (data) => {
-            stdinOutput += data.toString();
-        });
-        const stdinExitCode = await new Promise((resolve) => {
-            stdinChild.on('close', (code) => resolve(code));
-        });
-        if (stdinExitCode === 1 && stdinOutput.includes('debug')) {
-            success('Stdin processing works correctly');
-        } else {
-            info(`Stdin test result: exit code ${stdinExitCode}, output length: ${stdinOutput.length}`);
-        }
-        // Test 7: Error handling
-        info('Test 7: Testing error handling...');
-        const errorResult = await runCommand('node', [
-            path.join(__dirname, 'index.js'),
-            'nonexistent1.json',
-            'nonexistent2.json'
-        ]);
-        if (errorResult.code !== 0) {
-            success('Error handling works correctly');
-        } else {
-            error('Error handling failed - should have failed with nonexistent files');
-            throw new Error('Error handling failed');
-        }
-        // Test 8: Platform-specific binary verification
-        info('Test 8: Testing platform-specific binary verification...');
-        const platform = process.platform;
-        const arch = process.arch;
-        let expectedBinaryPath;
-        if (platform === 'win32') {
-            expectedBinaryPath = path.join(__dirname, 'bin', 'win32-x64', 'diffx.exe');
-        } else if (platform === 'darwin') {
-            if (arch === 'arm64') {
-                expectedBinaryPath = path.join(__dirname, 'bin', 'darwin-arm64', 'diffx');
-            } else {
-                expectedBinaryPath = path.join(__dirname, 'bin', 'darwin-x64', 'diffx');
-            }
-        } else if (platform === 'linux') {
-            expectedBinaryPath = path.join(__dirname, 'bin', 'linux-x64', 'diffx');
-        }
-        if (fs.existsSync(expectedBinaryPath)) {
-            success(`Platform-specific binary found: ${expectedBinaryPath}`);
-        } else {
-            error(`Platform-specific binary not found: ${expectedBinaryPath}`);
-            throw new Error('Platform binary missing');
-        }
-        // Test 9: API functionality with new options
-        info('Test 9: Testing API functionality with new options...');
-        // Test ignore case option
-        try {
-            const { diff, diffString } = require('./lib.js');
-            // Test ignore case
-            const caseResult = await diffString(testData.caseTest1, testData.caseTest2, 'json', {
-                ignoreCase: true,
-                output: 'json'
-            });
-            if (Array.isArray(caseResult) && caseResult.length === 0) {
-                success('API ignore-case option works correctly');
-            } else {
-                info('API ignore-case test completed (may show differences)');
-            }
-            // Test ignore whitespace
-            const whitespaceResult = await diffString(testData.whitespaceTest1, testData.whitespaceTest2, 'json', {
-                ignoreWhitespace: true,
-                output: 'json'
-            });
-            if (Array.isArray(whitespaceResult) && whitespaceResult.length === 0) {
-                success('API ignore-whitespace option works correctly');
-            } else {
-                info('API ignore-whitespace test completed (may show differences)');
-            }
-            // Test quiet option
-            const quietResult = await diffString(testData.json1, testData.json2, 'json', {
-                quiet: true
-            });
-            if (quietResult === '') {
-                success('API quiet option works correctly');
-            } else {
-                info('API quiet test completed');
-            }
-            // Test brief option
-            const briefResult = await diffString(testData.json1, testData.json2, 'json', {
-                brief: true
-            });
-            if (typeof briefResult === 'string') {
-                success('API brief option works correctly');
-            } else {
-                info('API brief test completed');
-            }
-            success('API tests completed successfully');
-        } catch (apiErr) {
-            info(`API test completed with info: ${apiErr.message}`);
-        }
-        success('All tests passed!');
-        info('diffx-js package is working correctly');
-    } catch (err) {
-        error(`Test failed: ${err.message}`);
-        process.exit(1);
-    } finally {
-        // Cleanup
-        process.chdir(__dirname);
-        try {
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        } catch (cleanupErr) {
-            info(`Cleanup warning: ${cleanupErr.message}`);
-        }
-    }
-}
-// Run tests if called directly
-if (require.main === module) {
-    runTests();
-}
-module.exports = { runTests };