@oxog/vld 2.0.2 → 2.1.0

package/dist/cjs/cli/bin.cjs

@@ -0,0 +1,506 @@
+#!/usr/bin/env node
+'use strict';
+
+var cli_index = require('./index.cjs');
+var fs = require('fs');
+var path = require('path');
+var pigment = require('../pigment.cjs');
+var errors = require('../errors.cjs');
+var index = require('../index.cjs');
+require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../validators/base.cjs');
+require('../registry.cjs');
+require('../chunks/string-BKZrc4hs.cjs');
+require('../locales/runtime.cjs');
+require('../locales/en.cjs');
+require('../validators/number.cjs');
+require('../validators/boolean.cjs');
+require('../validators/date.cjs');
+require('../validators/string-bool.cjs');
+require('../validators/array.cjs');
+require('../validators/object.cjs');
+require('../validators/enum.cjs');
+require('../chunks/security-Dc3Jh13T.cjs');
+require('../validators/union.cjs');
+require('../validators/literal.cjs');
+require('../validators/bigint.cjs');
+require('../validators/symbol.cjs');
+require('../validators/tuple.cjs');
+require('../validators/record.cjs');
+require('../validators/set.cjs');
+require('../validators/map.cjs');
+require('../validators/intersection.cjs');
+require('../validators/any.cjs');
+require('../validators/unknown.cjs');
+require('../validators/void.cjs');
+require('../validators/never.cjs');
+require('../validators/null.cjs');
+require('../validators/undefined.cjs');
+require('../validators/nan.cjs');
+require('../validators/lazy.cjs');
+require('../validators/discriminated-union.cjs');
+require('../validators/xor.cjs');
+require('../validators/json.cjs');
+require('../validators/template-literal.cjs');
+require('../validators/custom.cjs');
+require('../validators/file.cjs');
+require('../validators/function.cjs');
+require('../validators/codec.cjs');
+require('../validators/base64.cjs');
+require('../validators/hex.cjs');
+require('../validators/uint8array.cjs');
+require('../validators/promise.cjs');
+require('../compat/result.cjs');
+require('../chunks/index-Cc3bjUMX.cjs');
+require('../locales/tr.cjs');
+require('../locales/es.cjs');
+require('../locales/fr.cjs');
+require('../locales/de.cjs');
+require('../locales/it.cjs');
+require('../locales/pt.cjs');
+require('../locales/ru.cjs');
+require('../locales/ja.cjs');
+require('../locales/ko.cjs');
+require('../locales/zh.cjs');
+require('../locales/ar.cjs');
+require('../locales/hi.cjs');
+require('../locales/nl.cjs');
+require('../locales/pl.cjs');
+require('../locales/da.cjs');
+require('../locales/sv.cjs');
+require('../locales/no.cjs');
+require('../locales/fi.cjs');
+require('../locales/th.cjs');
+require('../locales/vi.cjs');
+require('../locales/id.cjs');
+require('../locales/bn.cjs');
+require('../locales/sw.cjs');
+require('../locales/af.cjs');
+require('../locales/pt-BR.cjs');
+require('../locales/es-MX.cjs');
+require('../coercion/index.cjs');
+require('../validators/string-formats.cjs');
+require('../chunks/index-BkI37108.cjs');
+require('../compat/emitter.cjs');
+require('../kernel.cjs');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+/**
+ * VLD CLI - Validate Command
+ *
+ * Validate JSON data against a VLD schema file.
+ */
+function assertWithinCwd(absolutePath, label, original) {
+    const allowedDir = process.cwd();
+    if (!absolutePath.startsWith(allowedDir + path__namespace.sep) && absolutePath !== allowedDir) {
+        throw new Error(`${label} path escapes allowed directory: ${original}`);
+    }
+}
+/**
+ * Validate command
+ */
+const validateCommand = {
+    name: 'validate',
+    description: 'Validate JSON data against a VLD schema',
+    aliases: ['v'],
+    arguments: [
+        {
+            name: 'schema',
+            description: 'Path to schema file (.ts or .js)',
+            required: true
+        },
+        {
+            name: 'data',
+            description: 'Path to JSON data file or JSON string',
+            required: true
+        }
+    ],
+    options: [
+        {
+            name: 'strict',
+            short: 's',
+            description: 'Enable strict mode (no extra keys)',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'quiet',
+            short: 'q',
+            description: 'Only output errors',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'json',
+            short: 'j',
+            description: 'Output as JSON',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'no-color',
+            description: 'Disable colored output',
+            type: 'boolean',
+            default: false
+        }
+    ],
+    action: async (args, options) => {
+        const schemaPath = args['schema'];
+        const dataArg = args['data'];
+        const quiet = options['quiet'];
+        const json = options['json'];
+        const noColor = options['no-color'];
+        // Load schema
+        let schema;
+        try {
+            const absoluteSchemaPath = path__namespace.resolve(process.cwd(), schemaPath);
+            // Security: Ensure resolved path is within allowed directories
+            assertWithinCwd(absoluteSchemaPath, 'Schema', schemaPath);
+            if (!fs__namespace.existsSync(absoluteSchemaPath)) {
+                throw new Error(`Schema file not found: ${schemaPath}`);
+            }
+            // Dynamic import for ESM/CJS compatibility
+            const schemaModule = await import(absoluteSchemaPath);
+            schema = schemaModule.default || schemaModule.schema || schemaModule;
+            if (!schema || typeof schema.parse !== 'function') {
+                throw new Error('Schema must export a VLD validator with parse() method');
+            }
+        }
+        catch (error) {
+            if (json) {
+                console.log(JSON.stringify({ success: false, error: error.message }));
+            }
+            else {
+                console.error(pigment.default.red('Schema Error:'), error.message);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        // Load data
+        let data;
+        try {
+            // Check if it's a file path or JSON string
+            if (dataArg.startsWith('{') || dataArg.startsWith('[')) {
+                data = JSON.parse(dataArg);
+            }
+            else {
+                const absoluteDataPath = path__namespace.resolve(process.cwd(), dataArg);
+                // Security: Ensure resolved path is within allowed directories
+                assertWithinCwd(absoluteDataPath, 'Data', dataArg);
+                if (!fs__namespace.existsSync(absoluteDataPath)) {
+                    throw new Error(`Data file not found: ${dataArg}`);
+                }
+                const content = fs__namespace.readFileSync(absoluteDataPath, 'utf-8');
+                data = JSON.parse(content);
+            }
+        }
+        catch (error) {
+            if (json) {
+                console.log(JSON.stringify({ success: false, error: error.message }));
+            }
+            else {
+                console.error(pigment.default.red('Data Error:'), error.message);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        // Validate
+        const result = schema.safeParse(data);
+        if (json) {
+            if (result.success) {
+                console.log(JSON.stringify({ success: true, data: result.data }));
+            }
+            else {
+                const err = result.error;
+                const errorJson = {
+                    success: false,
+                    error: err?.message,
+                    issues: err?.issues
+                };
+                console.log(JSON.stringify(errorJson));
+            }
+        }
+        else {
+            if (result.success) {
+                if (!quiet) {
+                    console.log(pigment.default.green('Validation passed'));
+                    console.log('');
+                    console.log(pigment.default.dim('Data:'));
+                    console.log(JSON.stringify(result.data, null, 2));
+                }
+            }
+            else {
+                console.error(pigment.default.red('Validation failed'));
+                console.error('');
+                // Check if it's a VldError with issues
+                if (result.error && 'issues' in result.error) {
+                    const formatted = noColor
+                        ? errors.prettifyError(result.error, { colored: false })
+                        : errors.prettifyErrorColored(result.error);
+                    console.error(formatted);
+                }
+                else {
+                    console.error(result.error?.message || 'Unknown error');
+                }
+                process.exitCode = 1;
+            }
+        }
+    }
+};
+
+/**
+ * VLD CLI - Benchmark Command
+ *
+ * Run performance benchmarks for VLD validation.
+ */
+/**
+ * Run a single benchmark
+ */
+function runBenchmark(name, fn, iterations) {
+    // Warm up
+    for (let i = 0; i < Math.min(100, iterations / 10); i++) {
+        fn();
+    }
+    // Run benchmark
+    const start = performance.now();
+    for (let i = 0; i < iterations; i++) {
+        fn();
+    }
+    const end = performance.now();
+    const totalMs = end - start;
+    const avgMs = totalMs / iterations;
+    const opsPerSec = 1000 / avgMs;
+    return { name, iterations, totalMs, avgMs, opsPerSec };
+}
+/**
+ * Format number with comma separators
+ */
+function formatNumber(n) {
+    return n.toLocaleString('en-US', { maximumFractionDigits: 2 });
+}
+/**
+ * Format benchmark result
+ */
+function formatResult(result, colored) {
+    const name = colored ? pigment.default.cyan(result.name.padEnd(30)) : result.name.padEnd(30);
+    const ops = colored
+        ? pigment.default.green(formatNumber(result.opsPerSec).padStart(12))
+        : formatNumber(result.opsPerSec).padStart(12);
+    const avg = colored
+        ? pigment.default.yellow(result.avgMs.toFixed(6).padStart(12))
+        : result.avgMs.toFixed(6).padStart(12);
+    return `${name} ${ops} ops/sec  ${avg} ms/op`;
+}
+/**
+ * Benchmark command
+ */
+const benchmarkCommand = {
+    name: 'benchmark',
+    description: 'Run performance benchmarks',
+    aliases: ['bench', 'b'],
+    options: [
+        {
+            name: 'iterations',
+            short: 'n',
+            description: 'Number of iterations',
+            type: 'number',
+            default: 10000
+        },
+        {
+            name: 'suite',
+            short: 's',
+            description: 'Benchmark suite to run (all, primitives, objects, arrays)',
+            type: 'string',
+            default: 'all'
+        },
+        {
+            name: 'json',
+            short: 'j',
+            description: 'Output as JSON',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'no-color',
+            description: 'Disable colored output',
+            type: 'boolean',
+            default: false
+        }
+    ],
+    action: async (_args, options) => {
+        const iterations = options['iterations'];
+        const suite = options['suite'];
+        const json = options['json'];
+        const noColor = options['no-color'];
+        const colored = !noColor;
+        const results = [];
+        // Primitive validators
+        const stringSchema = index.default.string();
+        const numberSchema = index.default.number();
+        const booleanSchema = index.default.boolean();
+        const dateSchema = index.default.date();
+        // Object validator
+        const userSchema = index.default.object({
+            name: index.default.string(),
+            email: index.default.string(),
+            age: index.default.number(),
+            active: index.default.boolean()
+        });
+        // Array validator
+        const numbersSchema = index.default.array(index.default.number());
+        // Nested object validator
+        const nestedSchema = index.default.object({
+            user: index.default.object({
+                name: index.default.string(),
+                email: index.default.string()
+            }),
+            items: index.default.array(index.default.object({
+                id: index.default.number(),
+                name: index.default.string(),
+                price: index.default.number()
+            }))
+        });
+        // Test data
+        const testString = 'hello world';
+        const testNumber = 42;
+        const testBoolean = true;
+        const testDate = new Date();
+        const testUser = { name: 'John', email: 'john@example.com', age: 30, active: true };
+        const testNumbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        const testNested = {
+            user: { name: 'John', email: 'john@example.com' },
+            items: [
+                { id: 1, name: 'Item 1', price: 10.99 },
+                { id: 2, name: 'Item 2', price: 20.99 },
+                { id: 3, name: 'Item 3', price: 30.99 }
+            ]
+        };
+        if (!json) {
+            console.log(pigment.default.bold('VLD Performance Benchmark'));
+            console.log(pigment.default.dim(`Running ${formatNumber(iterations)} iterations per test`));
+            console.log('');
+        }
+        // Primitive benchmarks
+        if (suite === 'all' || suite === 'primitives') {
+            if (!json) {
+                console.log(pigment.default.bold('Primitives:'));
+            }
+            results.push(runBenchmark('string.parse()', () => stringSchema.parse(testString), iterations));
+            results.push(runBenchmark('number.parse()', () => numberSchema.parse(testNumber), iterations));
+            results.push(runBenchmark('boolean.parse()', () => booleanSchema.parse(testBoolean), iterations));
+            results.push(runBenchmark('date.parse()', () => dateSchema.parse(testDate), iterations));
+            results.push(runBenchmark('string.safeParse()', () => stringSchema.safeParse(testString), iterations));
+            if (!json) {
+                for (const result of results.slice(-5)) {
+                    console.log('  ' + formatResult(result, colored));
+                }
+                console.log('');
+            }
+        }
+        // Object benchmarks
+        if (suite === 'all' || suite === 'objects') {
+            if (!json) {
+                console.log(pigment.default.bold('Objects:'));
+            }
+            results.push(runBenchmark('object.parse()', () => userSchema.parse(testUser), iterations));
+            results.push(runBenchmark('object.safeParse()', () => userSchema.safeParse(testUser), iterations));
+            results.push(runBenchmark('nested.parse()', () => nestedSchema.parse(testNested), iterations));
+            if (!json) {
+                for (const result of results.slice(-3)) {
+                    console.log('  ' + formatResult(result, colored));
+                }
+                console.log('');
+            }
+        }
+        // Array benchmarks
+        if (suite === 'all' || suite === 'arrays') {
+            if (!json) {
+                console.log(pigment.default.bold('Arrays:'));
+            }
+            results.push(runBenchmark('array.parse()', () => numbersSchema.parse(testNumbers), iterations));
+            results.push(runBenchmark('array.safeParse()', () => numbersSchema.safeParse(testNumbers), iterations));
+            if (!json) {
+                for (const result of results.slice(-2)) {
+                    console.log('  ' + formatResult(result, colored));
+                }
+                console.log('');
+            }
+        }
+        // Summary
+        if (!json) {
+            const totalOps = results.reduce((sum, r) => sum + r.opsPerSec, 0);
+            const avgOps = totalOps / results.length;
+            console.log(pigment.default.bold('Summary:'));
+            console.log(`  Total benchmarks: ${results.length}`);
+            console.log(`  Average ops/sec:  ${formatNumber(avgOps)}`);
+        }
+        else {
+            console.log(JSON.stringify({
+                iterations,
+                suite,
+                results: results.map((r) => ({
+                    name: r.name,
+                    iterations: r.iterations,
+                    totalMs: r.totalMs,
+                    avgMs: r.avgMs,
+                    opsPerSec: r.opsPerSec
+                }))
+            }));
+        }
+    }
+};
+
+/**
+ * VLD CLI Entry Point
+ *
+ * This is the main entry point for the `vld` command-line tool.
+ */
+const packageJson = JSON.parse(fs.readFileSync(new URL('../../package.json', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli/bin.cjs', document.baseURI).href))), 'utf-8'));
+const version = packageJson.version || '0.0.0';
+cli_index.vldCli.version = version;
+// Register commands
+cli_index.vldCli.command(validateCommand);
+cli_index.vldCli.command(benchmarkCommand);
+// Help command
+cli_index.vldCli.command({
+    name: 'help',
+    description: 'Show help information',
+    aliases: ['h'],
+    action: () => {
+        console.log(cli_index.vldCli.help());
+    }
+});
+// Version command
+cli_index.vldCli.command({
+    name: 'version',
+    description: 'Show version information',
+    action: () => {
+        console.log(`vld v${version}`);
+    }
+});
+// Run CLI
+cli_index.vldCli.run(process.argv.slice(2)).catch((error) => {
+    console.error('Fatal error:', error);
+    process.exitCode = 1;
+});