@oxog/vld 2.0.2 → 2.1.0

package/dist/cjs/kernel.cjs

@@ -0,0 +1,415 @@
+'use strict';
+
+var compat_emitter = require('./compat/emitter.cjs');
+
+/**
+ * VLD Kernel
+ *
+ * The kernel is the core of the VLD plugin system.
+ * It manages plugins, validators, transforms, and codecs.
+ */
+/**
+ * Create the VLD kernel
+ */
+function createVldKernel(options = {}) {
+    // ============================================
+    // State
+    // ============================================
+    const context = {
+        locale: 'en',
+        strict: false,
+        debug: options.debug ?? false,
+        custom: {},
+        ...options.context
+    };
+    const plugins = new Map();
+    const validators = new Map();
+    const transforms = new Map();
+    const codecs = new Map();
+    const emitter = compat_emitter.createEmitter();
+    const errorStrategy = options.errorStrategy ?? 'throw';
+    // ============================================
+    // Context Management
+    // ============================================
+    const getContext = () => ({ ...context });
+    const setContext = (partial) => {
+        Object.assign(context, partial);
+    };
+    // ============================================
+    // Plugin Management
+    // ============================================
+    const use = (plugin) => {
+        if (plugins.has(plugin.name)) {
+            if (errorStrategy === 'throw') {
+                throw new Error(`Plugin "${plugin.name}" is already registered`);
+            }
+            return kernel;
+        }
+        // Register plugin validators
+        if (plugin.validators) {
+            for (const [name, factory] of Object.entries(plugin.validators)) {
+                validators.set(name, factory);
+            }
+        }
+        // Register plugin transforms
+        if (plugin.transforms) {
+            for (const [name, factory] of Object.entries(plugin.transforms)) {
+                transforms.set(name, factory);
+            }
+        }
+        // Register plugin codecs
+        if (plugin.codecs) {
+            for (const [name, codec] of Object.entries(plugin.codecs)) {
+                codecs.set(name, codec);
+            }
+        }
+        // Store plugin
+        plugins.set(plugin.name, plugin);
+        // Call install hook
+        if (plugin.install) {
+            try {
+                const result = plugin.install(kernel);
+                if (result instanceof Promise) {
+                    result.catch((err) => {
+                        if (context.debug) {
+                            console.error(`Error installing plugin "${plugin.name}":`, err);
+                        }
+                    });
+                }
+            }
+            catch (err) {
+                if (errorStrategy === 'throw') {
+                    throw err;
+                }
+                if (context.debug) {
+                    console.error(`Error installing plugin "${plugin.name}":`, err);
+                }
+            }
+        }
+        // Emit event
+        emitter.emit('vld:plugin:registered', {
+            name: plugin.name,
+            version: plugin.version,
+            timestamp: Date.now()
+        });
+        return kernel;
+    };
+    const remove = (name) => {
+        const plugin = plugins.get(name);
+        if (!plugin)
+            return false;
+        // Call uninstall hook
+        if (plugin.uninstall) {
+            try {
+                const result = plugin.uninstall(kernel);
+                if (result instanceof Promise) {
+                    result.catch((err) => {
+                        if (context.debug) {
+                            console.error(`Error uninstalling plugin "${name}":`, err);
+                        }
+                    });
+                }
+            }
+            catch (err) {
+                if (context.debug) {
+                    console.error(`Error uninstalling plugin "${name}":`, err);
+                }
+            }
+        }
+        // Remove plugin validators
+        if (plugin.validators) {
+            for (const validatorName of Object.keys(plugin.validators)) {
+                validators.delete(validatorName);
+            }
+        }
+        // Remove plugin transforms
+        if (plugin.transforms) {
+            for (const transformName of Object.keys(plugin.transforms)) {
+                transforms.delete(transformName);
+            }
+        }
+        // Remove plugin codecs
+        if (plugin.codecs) {
+            for (const codecName of Object.keys(plugin.codecs)) {
+                codecs.delete(codecName);
+            }
+        }
+        return plugins.delete(name);
+    };
+    const getPlugin = (name) => plugins.get(name);
+    const getPlugins = () => Array.from(plugins.values());
+    const hasPlugin = (name) => plugins.has(name);
+    // ============================================
+    // Validator Registry
+    // ============================================
+    const registerValidator = (name, factory) => {
+        validators.set(name, factory);
+        emitter.emit('vld:validator:registered', {
+            name,
+            timestamp: Date.now()
+        });
+        return kernel;
+    };
+    const getValidator = (name) => {
+        const factory = validators.get(name);
+        return factory ? factory() : undefined;
+    };
+    const getValidators = () => Object.fromEntries(validators);
+    // ============================================
+    // Transform Registry
+    // ============================================
+    const registerTransform = (name, factory) => {
+        transforms.set(name, factory);
+        return kernel;
+    };
+    const getTransform = (name) => transforms.get(name);
+    // ============================================
+    // Codec Registry
+    // ============================================
+    const registerCodec = (name, codec) => {
+        codecs.set(name, codec);
+        emitter.emit('vld:codec:registered', {
+            name,
+            timestamp: Date.now()
+        });
+        return kernel;
+    };
+    const getCodec = (name) => codecs.get(name);
+    // ============================================
+    // Hook Execution
+    // ============================================
+    const executeBeforeParse = (value, schema, hookContext) => {
+        let currentValue = value;
+        for (const plugin of plugins.values()) {
+            if (plugin.onBeforeParse) {
+                try {
+                    currentValue = plugin.onBeforeParse(currentValue, schema, hookContext);
+                }
+                catch (err) {
+                    if (errorStrategy === 'throw')
+                        throw err;
+                    if (context.debug) {
+                        console.error(`Error in onBeforeParse hook of "${plugin.name}":`, err);
+                    }
+                }
+            }
+        }
+        return currentValue;
+    };
+    const executeAfterParse = (result, schema, hookContext) => {
+        let currentResult = result;
+        for (const plugin of plugins.values()) {
+            if (plugin.onAfterParse) {
+                try {
+                    currentResult = plugin.onAfterParse(currentResult, schema, hookContext);
+                }
+                catch (err) {
+                    if (errorStrategy === 'throw')
+                        throw err;
+                    if (context.debug) {
+                        console.error(`Error in onAfterParse hook of "${plugin.name}":`, err);
+                    }
+                }
+            }
+        }
+        return currentResult;
+    };
+    const executeOnError = (error, schema, hookContext) => {
+        for (const plugin of plugins.values()) {
+            if (plugin.onError) {
+                try {
+                    plugin.onError(error, schema, hookContext);
+                }
+                catch (err) {
+                    if (context.debug) {
+                        console.error(`Error in onError hook of "${plugin.name}":`, err);
+                    }
+                }
+            }
+        }
+    };
+    const executeOnSuccess = (data, schema, hookContext) => {
+        for (const plugin of plugins.values()) {
+            if (plugin.onSuccess) {
+                try {
+                    plugin.onSuccess(data, schema, hookContext);
+                }
+                catch (err) {
+                    if (context.debug) {
+                        console.error(`Error in onSuccess hook of "${plugin.name}":`, err);
+                    }
+                }
+            }
+        }
+    };
+    // ============================================
+    // Lifecycle
+    // ============================================
+    const dispose = async () => {
+        // Uninstall all plugins in reverse order
+        const pluginList = Array.from(plugins.values()).reverse();
+        for (const plugin of pluginList) {
+            if (plugin.uninstall) {
+                try {
+                    await plugin.uninstall(kernel);
+                }
+                catch (err) {
+                    if (context.debug) {
+                        console.error(`Error uninstalling plugin "${plugin.name}":`, err);
+                    }
+                }
+            }
+        }
+        // Clear all registries
+        plugins.clear();
+        validators.clear();
+        transforms.clear();
+        codecs.clear();
+        emitter.removeAllListeners();
+    };
+    // ============================================
+    // Kernel Instance
+    // ============================================
+    const kernel = {
+        // Context
+        getContext,
+        setContext,
+        // Plugins
+        use,
+        remove,
+        getPlugin,
+        getPlugins,
+        hasPlugin,
+        // Validators
+        registerValidator,
+        getValidator,
+        getValidators,
+        // Transforms
+        registerTransform,
+        getTransform,
+        // Codecs
+        registerCodec,
+        getCodec,
+        // Hooks
+        executeBeforeParse,
+        executeAfterParse,
+        executeOnError,
+        executeOnSuccess,
+        // Lifecycle
+        dispose
+    };
+    // ============================================
+    // Load Initial Plugins
+    // ============================================
+    if (options.plugins) {
+        for (const plugin of options.plugins) {
+            use(plugin);
+        }
+    }
+    return kernel;
+}
+// ============================================
+// Plugin Builder
+// ============================================
+/**
+ * Create a plugin using the builder pattern
+ */
+function definePlugin() {
+    let _name = '';
+    let _version = '1.0.0';
+    let _description = '';
+    const _validators = {};
+    const _transforms = {};
+    const _codecs = {};
+    const _hooks = {};
+    let _install;
+    const builder = {
+        name(name) {
+            _name = name;
+            return this;
+        },
+        version(version) {
+            _version = version;
+            return this;
+        },
+        description(description) {
+            _description = description;
+            return this;
+        },
+        validator(name, factory) {
+            _validators[name] = factory;
+            return this;
+        },
+        transform(name, factory) {
+            _transforms[name] = factory;
+            return this;
+        },
+        codec(name, codec) {
+            _codecs[name] = codec;
+            return this;
+        },
+        hook(name, fn) {
+            _hooks[name] = fn;
+            return this;
+        },
+        install(fn) {
+            _install = fn;
+            return this;
+        },
+        build() {
+            if (!_name) {
+                throw new Error('Plugin name is required');
+            }
+            const plugin = {
+                name: _name,
+                version: _version,
+                description: _description,
+                ..._hooks
+            };
+            if (Object.keys(_validators).length > 0)
+                plugin.validators = _validators;
+            if (Object.keys(_transforms).length > 0)
+                plugin.transforms = _transforms;
+            if (Object.keys(_codecs).length > 0)
+                plugin.codecs = _codecs;
+            if (_install !== undefined)
+                plugin.install = _install;
+            return plugin;
+        }
+    };
+    return builder;
+}
+// ============================================
+// Global Kernel Instance
+// ============================================
+let globalKernel = null;
+/**
+ * Get or create the global VLD kernel
+ */
+function getVldKernel(options) {
+    if (!globalKernel) {
+        globalKernel = createVldKernel(options);
+    }
+    return globalKernel;
+}
+/**
+ * Reset the global VLD kernel
+ */
+async function resetVldKernel() {
+    if (globalKernel) {
+        await globalKernel.dispose();
+        globalKernel = null;
+    }
+}
+/**
+ * Use a plugin with the global kernel
+ */
+function usePlugin(plugin) {
+    return getVldKernel().use(plugin);
+}
+
+exports.createVldKernel = createVldKernel;
+exports.definePlugin = definePlugin;
+exports.getVldKernel = getVldKernel;
+exports.resetVldKernel = resetVldKernel;
+exports.usePlugin = usePlugin;

package/dist/cjs/locales/af.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+const af = {
+    // String validation messages
+    invalidString: 'Ongeldige string',
+    stringMin: (min) => `String moet ten minste ${min} karakters lank wees`,
+    stringMax: (max) => `String mag hoogstens ${max} karakters lank wees`,
+    stringLength: (length) => `String moet presies ${length} karakters lank wees`,
+    stringEmail: 'Ongeldige e-pos adres',
+    stringUrl: 'Ongeldige URL',
+    stringUuid: 'Ongeldige UUID',
+    stringRegex: 'Ongeldige formaat',
+    stringStartsWith: (prefix) => `String moet begin met "${prefix}"`,
+    stringEndsWith: (suffix) => `String moet eindig met "${suffix}"`,
+    stringIncludes: (substring) => `String moet "${substring}" bevat`,
+    stringIp: 'Ongeldige IP adres',
+    stringIpv4: 'Ongeldige IPv4 adres',
+    stringIpv6: 'Ongeldige IPv6 adres',
+    stringEmpty: 'String mag nie leeg wees nie',
+    // Number validation messages
+    invalidNumber: 'Ongeldige getal',
+    numberMin: (min) => `Getal moet ten minste ${min} wees`,
+    numberMax: (max) => `Getal mag hoogstens ${max} wees`,
+    numberInt: "Getal moet 'n heelgetal wees",
+    numberPositive: 'Getal moet positief wees',
+    numberNegative: 'Getal moet negatief wees',
+    numberNonnegative: 'Getal mag nie negatief wees nie',
+    numberNonpositive: 'Getal mag nie positief wees nie',
+    numberFinite: 'Getal moet eindig wees',
+    numberSafe: "Getal moet 'n veilige heelgetal wees",
+    numberMultipleOf: (value) => `Getal moet 'n veelvoud van ${value} wees`,
+    // Boolean validation messages
+    invalidBoolean: 'Ongeldige boolean waarde',
+    // Date validation messages
+    invalidDate: 'Ongeldige datum',
+    dateMin: (date) => `Datum moet na ${date.toISOString()} wees`,
+    dateMax: (date) => `Datum moet voor ${date.toISOString()} wees`,
+    // Object validation messages
+    invalidObject: 'Ongeldige objek',
+    unexpectedKeys: (keys) => `Onverwagte sleutels: ${keys.join(', ')}`,
+    // Array validation messages
+    invalidArray: 'Ongeldige skikking',
+    arrayMin: (min) => `Skikking moet ten minste ${min} elemente hê`,
+    arrayMax: (max) => `Skikking mag hoogstens ${max} elemente hê`,
+    arrayLength: (length) => `Skikking moet presies ${length} elemente hê`,
+    arrayEmpty: 'Skikking mag nie leeg wees nie',
+    arrayItem: (index, error) => `Ongeldige element by indeks ${index}: ${error}`,
+    // Object field validation
+    objectField: (field, error) => `Ongeldige veld "${field}": ${error}`,
+    // Union validation messages
+    unionNoMatch: (errors) => `Geen union lid het gepas nie: ${errors.join(', ')}`,
+    // Intersection validation messages
+    intersectionError: (error) => `Intersection validasie het gefaal: ${error}`,
+    // Literal validation messages
+    literalExpected: (expected, received) => `Verwag ${expected}, ontvang ${received}`,
+    // Enum validation messages
+    enumExpected: (values, received) => `Verwag een van [${values.join(', ')}], ontvang ${received}`,
+    // Special type validation messages
+    expectedUndefined: 'Verwag undefined',
+    neverType: 'Never tipe kan nie geparseer word nie',
+    // New advanced type validation messages
+    invalidBigint: 'Ongeldige bigint',
+    invalidSymbol: 'Ongeldige simbool',
+    invalidTuple: 'Ongeldige tupel',
+    tupleLength: (expected, received) => `Tupel moet presies ${expected} elemente hê, ontvang ${received}`,
+    invalidRecord: 'Ongeldige rekord',
+    invalidSet: 'Ongeldige Set',
+    invalidMap: 'Ongeldige Map',
+    // Transformation and refinement messages
+    transformError: (error) => `Transformasie het gefaal: ${error}`,
+    refinementError: (error) => `Verfyning het gefaal: ${error}`,
+    customValidationError: (error) => `Pasgemaakte validasie het misluk: ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `Kan nie ${JSON.stringify(value)} na ${type} dwing nie`,
+    // Codec messages
+    codecDecodeFailed: 'Failed to decode value',
+    codecEncodeFailed: 'Failed to encode value',
+    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
+    // Base64/Hex messages
+    invalidBase64: 'Invalid base64 string',
+    invalidHex: 'Invalid hexadecimal string',
+    // Uint8Array messages
+    expectedUint8Array: 'Expected Uint8Array',
+    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
+    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
+    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
+    // Generic type error messages
+    expectedString: 'Expected string',
+    stringExpected: (received, expected) => `Verwag ${expected}, ontvang ${received}`,
+    stringBoolExpected: (validValues, received) => `Ongeldige boolean string. Een van die volgende verwag: ${validValues}, ontvang: "${received}"`,
+    invalidJson: 'Ongeldige JSON',
+    stringPatternInvalid: 'String stem nie ooreen met die vereiste patroon nie',
+    // File validation messages
+    invalidFile: 'Expected a File object',
+    fileNotSupported: 'File API not supported in this environment',
+    fileMinSize: (min) => `File size must be at least ${min} bytes`,
+    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
+    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(', ')}`,
+    // Function validation messages
+    invalidFunction: "'n Funksie word verwag",
+    // CIDR validation messages
+    stringCidrv4: 'Ongeldige IPv4 CIDR-blok',
+    stringCidrv6: 'Ongeldige IPv6 CIDR-blok',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `Kan nie bestaande sleutels oorskryf nie: ${keys.join(', ')}. Gebruik extend() om te oorskryf.`
+};
+
+exports.af = af;

package/dist/cjs/locales/ar.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+const ar = {
+    // String validation messages
+    invalidString: 'نص غير صحيح',
+    stringMin: (min) => `يجب أن يحتوي النص على ${min} حرف على الأقل`,
+    stringMax: (max) => `لا يمكن أن يحتوي النص على أكثر من ${max} حرف`,
+    stringLength: (length) => `يجب أن يحتوي النص على ${length} حرف بالضبط`,
+    stringEmail: 'عنوان بريد إلكتروني غير صحيح',
+    stringUrl: 'رابط غير صحيح',
+    stringUuid: 'UUID غير صحيح',
+    stringRegex: 'تنسيق غير صحيح',
+    stringStartsWith: (prefix) => `يجب أن يبدأ النص بـ "${prefix}"`,
+    stringEndsWith: (suffix) => `يجب أن ينتهي النص بـ "${suffix}"`,
+    stringIncludes: (substring) => `يجب أن يحتوي النص على "${substring}"`,
+    stringIp: 'عنوان IP غير صحيح',
+    stringIpv4: 'عنوان IPv4 غير صحيح',
+    stringIpv6: 'عنوان IPv6 غير صحيح',
+    stringEmpty: 'لا يمكن أن يكون النص فارغاً',
+    // Number validation messages
+    invalidNumber: 'رقم غير صحيح',
+    numberMin: (min) => `يجب أن يكون الرقم ${min} على الأقل`,
+    numberMax: (max) => `لا يمكن أن يكون الرقم أكبر من ${max}`,
+    numberInt: 'يجب أن يكون الرقم صحيحاً',
+    numberPositive: 'يجب أن يكون الرقم موجباً',
+    numberNegative: 'يجب أن يكون الرقم سالباً',
+    numberNonnegative: 'لا يمكن أن يكون الرقم سالباً',
+    numberNonpositive: 'لا يمكن أن يكون الرقم موجباً',
+    numberFinite: 'يجب أن يكون الرقم محدوداً',
+    numberSafe: 'يجب أن يكون الرقم صحيحاً آمناً',
+    numberMultipleOf: (value) => `يجب أن يكون الرقم مضاعفاً لـ ${value}`,
+    // Boolean validation messages
+    invalidBoolean: 'قيمة منطقية غير صحيحة',
+    // Date validation messages
+    invalidDate: 'تاريخ غير صحيح',
+    dateMin: (date) => `يجب أن يكون التاريخ بعد ${date.toISOString()}`,
+    dateMax: (date) => `يجب أن يكون التاريخ قبل ${date.toISOString()}`,
+    // Object validation messages
+    invalidObject: 'كائن غير صحيح',
+    unexpectedKeys: (keys) => `مفاتيح غير متوقعة: ${keys.join(', ')}`,
+    // Array validation messages
+    invalidArray: 'مصفوفة غير صحيحة',
+    arrayMin: (min) => `يجب أن تحتوي المصفوفة على ${min} عنصر على الأقل`,
+    arrayMax: (max) => `لا يمكن أن تحتوي المصفوفة على أكثر من ${max} عنصر`,
+    arrayLength: (length) => `يجب أن تحتوي المصفوفة على ${length} عنصر بالضبط`,
+    arrayEmpty: 'لا يمكن أن تكون المصفوفة فارغة',
+    arrayItem: (index, error) => `عنصر غير صحيح في الفهرس ${index}: ${error}`,
+    // Object field validation
+    objectField: (field, error) => `حقل غير صحيح "${field}": ${error}`,
+    // Union validation messages
+    unionNoMatch: (errors) => `لا يوجد عضو اتحاد مطابق: ${errors.join(', ')}`,
+    // Intersection validation messages
+    intersectionError: (error) => `فشل في التحقق من التقاطع: ${error}`,
+    // Literal validation messages
+    literalExpected: (expected, received) => `متوقع ${expected}، تم استلام ${received}`,
+    // Enum validation messages
+    enumExpected: (values, received) => `متوقع واحد من [${values.join(', ')}]، تم استلام ${received}`,
+    // Special type validation messages
+    expectedUndefined: 'متوقع undefined',
+    neverType: 'لا يمكن تحليل نوع never',
+    // New advanced type validation messages
+    invalidBigint: 'bigint غير صحيح',
+    invalidSymbol: 'رمز غير صحيح',
+    invalidTuple: 'صف غير صحيح',
+    tupleLength: (expected, received) => `يجب أن يحتوي الصف على ${expected} عنصر بالضبط، تم استلام ${received}`,
+    invalidRecord: 'سجل غير صحيح',
+    invalidSet: 'Set غير صحيح',
+    invalidMap: 'Map غير صحيح',
+    // Transformation and refinement messages
+    transformError: (error) => `فشل التحويل: ${error}`,
+    refinementError: (error) => `فشل التنقيح: ${error}`,
+    customValidationError: (error) => `فشل في التحقق المخصص: ${error}`,
+    // Coercion messages
+    coercionFailed: (type, value) => `لا يمكن إكراه ${JSON.stringify(value)} إلى ${type}`,
+    // Codec messages
+    codecDecodeFailed: 'Failed to decode value',
+    codecEncodeFailed: 'Failed to encode value',
+    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
+    // Base64/Hex messages
+    invalidBase64: 'Invalid base64 string',
+    invalidHex: 'Invalid hexadecimal string',
+    // Uint8Array messages
+    expectedUint8Array: 'Expected Uint8Array',
+    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
+    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
+    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
+    // Generic type error messages
+    expectedString: 'Expected string',
+    stringExpected: (received, expected) => `متوقع ${expected}، تم استلام ${received}`,
+    stringBoolExpected: (validValues, received) => `سلسلة منطقية غير صحيحة. متوقع واحد من: ${validValues}، تم استلام: "${received}"`,
+    invalidJson: 'JSON غير صالح',
+    stringPatternInvalid: 'السلسلة لا تطابق النمط المطلوب',
+    // File validation messages
+    invalidFile: 'Expected a File object',
+    fileNotSupported: 'File API not supported in this environment',
+    fileMinSize: (min) => `File size must be at least ${min} bytes`,
+    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
+    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
+    // Function validation messages
+    invalidFunction: 'دالة متوقعة',
+    // CIDR validation messages
+    stringCidrv4: 'كتلة CIDR IPv4 غير صالحة',
+    stringCidrv6: 'كتلة CIDR IPv6 غير صالحة',
+    // Safe extend validation messages
+    safeExtendOverlap: (keys) => `لا يمكن استبدال المفاتيح الموجودة: ${keys.join(', ')}. استخدم extend() للاستبدال.`
+};
+
+exports.ar = ar;