@oxog/vld 2.0.3 → 2.1.0

package/dist/cjs/cli/index.cjs

@@ -0,0 +1,209 @@
+'use strict';
+
+var pigment = require('../pigment.cjs');
+
+/**
+ * VLD CLI Tool
+ *
+ * Command-line interface for VLD validation library.
+ * Provides commands for validation, schema generation, and benchmarking.
+ */
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args, options = []) {
+    const result = {
+        positional: [],
+        options: {}
+    };
+    // Set defaults
+    for (const opt of options) {
+        if (opt.default !== undefined) {
+            result.options[opt.name] = opt.default;
+        }
+    }
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === undefined) {
+            i++;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            // Long option
+            const [name, value] = arg.slice(2).split('=');
+            if (name === undefined || name === '') {
+                i++;
+                continue;
+            }
+            const option = options.find((o) => o.name === name);
+            if (option) {
+                if (option.type === 'boolean') {
+                    result.options[name] = value !== 'false';
+                }
+                else if (value !== undefined) {
+                    result.options[name] = option.type === 'number' ? Number(value) : value;
+                }
+                else if (i + 1 < args.length && args[i + 1] !== undefined && !args[i + 1].startsWith('-')) {
+                    i++;
+                    const nextArg = args[i];
+                    if (nextArg !== undefined) {
+                        result.options[name] = option.type === 'number' ? Number(nextArg) : nextArg;
+                    }
+                }
+                else {
+                    result.options[name] = true;
+                }
+            }
+        }
+        else if (arg.startsWith('-')) {
+            // Short option
+            const short = arg.slice(1);
+            const option = options.find((o) => o.short === short);
+            if (option) {
+                if (option.type === 'boolean') {
+                    result.options[option.name] = true;
+                }
+                else if (i + 1 < args.length && args[i + 1] !== undefined && !args[i + 1].startsWith('-')) {
+                    i++;
+                    const nextArg = args[i];
+                    if (nextArg === undefined) {
+                        i++;
+                        continue;
+                    }
+                    result.options[option.name] =
+                        option.type === 'number' ? Number(nextArg) : nextArg;
+                }
+            }
+        }
+        else {
+            // Positional argument
+            result.positional.push(arg);
+        }
+        i++;
+    }
+    return result;
+}
+/**
+ * Create a CLI instance
+ */
+function createCli(name, version, description) {
+    const commands = new Map();
+    const cli = {
+        name,
+        version,
+        description,
+        commands,
+        command(cmd) {
+            commands.set(cmd.name, cmd);
+            if (cmd.aliases) {
+                for (const alias of cmd.aliases) {
+                    commands.set(alias, cmd);
+                }
+            }
+            return this;
+        },
+        help() {
+            const lines = [];
+            lines.push(pigment.default.bold(`${this.name} v${this.version}`));
+            lines.push(pigment.default.dim(description));
+            lines.push('');
+            lines.push(pigment.default.bold('Usage:'));
+            lines.push(`  ${name} <command> [options]`);
+            lines.push('');
+            lines.push(pigment.default.bold('Commands:'));
+            const uniqueCommands = new Map();
+            for (const [, cmd] of commands) {
+                if (!uniqueCommands.has(cmd.name)) {
+                    uniqueCommands.set(cmd.name, cmd);
+                }
+            }
+            for (const [cmdName, cmd] of uniqueCommands) {
+                const aliases = cmd.aliases?.length ? pigment.default.dim(` (${cmd.aliases.join(', ')})`) : '';
+                lines.push(`  ${pigment.default.cyan(cmdName)}${aliases}`);
+                lines.push(`    ${cmd.description}`);
+            }
+            lines.push('');
+            lines.push(pigment.default.bold('Options:'));
+            lines.push(`  ${pigment.default.cyan('-h, --help')}     Show help`);
+            lines.push(`  ${pigment.default.cyan('-v, --version')}  Show version`);
+            return lines.join('\n');
+        },
+        async run(args) {
+            // Handle help
+            if (args.includes('--help') || args.includes('-h') || args.length === 0) {
+                console.log(this.help());
+                return;
+            }
+            // Handle version
+            if (args.includes('--version') || args.includes('-v')) {
+                console.log(`${this.name} v${this.version}`);
+                return;
+            }
+            // Get command
+            const cmdName = args[0];
+            if (cmdName === undefined) {
+                console.log(this.help());
+                return;
+            }
+            const cmd = commands.get(cmdName);
+            if (!cmd) {
+                console.error(pigment.default.red(`Unknown command: ${cmdName}`));
+                console.log('');
+                console.log(this.help());
+                process.exitCode = 1;
+                return;
+            }
+            // Parse arguments
+            const parsed = parseArgs(args.slice(1), cmd.options);
+            // Map positional arguments
+            const positionalArgs = {};
+            if (cmd.arguments) {
+                for (let i = 0; i < cmd.arguments.length; i++) {
+                    const arg = cmd.arguments[i];
+                    if (arg === undefined) {
+                        continue;
+                    }
+                    if (i < parsed.positional.length) {
+                        positionalArgs[arg.name] = parsed.positional[i];
+                    }
+                    else if (arg.default !== undefined) {
+                        positionalArgs[arg.name] = arg.default;
+                    }
+                    else if (arg.required) {
+                        console.error(pigment.default.red(`Missing required argument: ${arg.name}`));
+                        process.exitCode = 1;
+                        return;
+                    }
+                }
+            }
+            // Check required options
+            if (cmd.options) {
+                for (const opt of cmd.options) {
+                    if (opt.required && parsed.options[opt.name] === undefined) {
+                        console.error(pigment.default.red(`Missing required option: --${opt.name}`));
+                        process.exitCode = 1;
+                        return;
+                    }
+                }
+            }
+            // Execute command
+            try {
+                await cmd.action(positionalArgs, parsed.options);
+            }
+            catch (error) {
+                console.error(pigment.default.red('Error:'), error.message);
+                process.exitCode = 1;
+            }
+        }
+    };
+    return cli;
+}
+/**
+ * VLD CLI instance
+ */
+const vldCli = createCli('vld', '1.5.0', 'Fast TypeScript Validation Library');
+
+exports.cli = createCli;
+exports.createCli = createCli;
+exports.vldCli = vldCli;

package/dist/cjs/codecs/index.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+require('../validators/codec.cjs');
+require('../validators/base64.cjs');
+require('../validators/hex.cjs');
+require('../validators/uint8array.cjs');
+require('../chunks/string-BKZrc4hs.cjs');
+require('../validators/number.cjs');
+require('../validators/bigint.cjs');
+require('../validators/boolean.cjs');
+require('../validators/date.cjs');
+require('../validators/unknown.cjs');
+var codecs_index = require('../chunks/index-BkI37108.cjs');
+require('../validators/base.cjs');
+require('../registry.cjs');
+require('../errors.cjs');
+require('../pigment.cjs');
+require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../locales/runtime.cjs');
+require('../locales/en.cjs');
+
+
+
+exports.base64Json = codecs_index.base64Json;
+exports.base64ToBytes = codecs_index.base64ToBytes;
+exports.base64UrlToBytes = codecs_index.base64UrlToBytes;
+exports.base64urlToBytes = codecs_index.base64urlToBytes;
+exports.bytesToUtf8 = codecs_index.bytesToUtf8;
+exports.epochMillisToDate = codecs_index.epochMillisToDate;
+exports.epochSecondsToDate = codecs_index.epochSecondsToDate;
+exports.hexLowerToBytes = codecs_index.hexLowerToBytes;
+exports.hexToBytes = codecs_index.hexToBytes;
+exports.invertCodec = codecs_index.invertCodec;
+exports.isoDatetimeToDate = codecs_index.isoDatetimeToDate;
+exports.jsonCodec = codecs_index.jsonCodec;
+exports.jwtPayload = codecs_index.jwtPayload;
+exports.numberToBigInt = codecs_index.numberToBigInt;
+exports.stringToBigInt = codecs_index.stringToBigInt;
+exports.stringToBoolean = codecs_index.stringToBoolean;
+exports.stringToHttpURL = codecs_index.stringToHttpURL;
+exports.stringToInt = codecs_index.stringToInt;
+exports.stringToNumber = codecs_index.stringToNumber;
+exports.stringToURL = codecs_index.stringToURL;
+exports.uriComponent = codecs_index.uriComponent;
+exports.utf8ToBytes = codecs_index.utf8ToBytes;