@oxog/vld 2.1.0 → 2.2.5

package/dist/compat/emitter.js

@@ -1,180 +1 @@
-/**
- * Event Emitter Implementation
- *
- * This module provides a type-safe event emitter,
- * compatible with @oxog/emitter when available.
- */
-/**
- * Create a type-safe event emitter
- */
-function createEmitter() {
-    const listeners = new Map();
-    const getListeners = (event) => {
-        if (!listeners.has(event)) {
-            listeners.set(event, []);
-        }
-        return listeners.get(event);
-    };
-    const sortListeners = (event) => {
-        const eventListeners = getListeners(event);
-        eventListeners.sort((a, b) => b.priority - a.priority);
-    };
-    const on = (event, handler, options = {}) => {
-        const entry = {
-            handler,
-            once: options.once ?? false,
-            priority: options.priority ?? 0
-        };
-        getListeners(event).push(entry);
-        sortListeners(event);
-        // Return unsubscribe function
-        return () => off(event, handler);
-    };
-    const once = (event, handler) => {
-        return on(event, handler, { once: true });
-    };
-    const off = (event, handler) => {
-        const eventListeners = listeners.get(event);
-        if (!eventListeners)
-            return;
-        const index = eventListeners.findIndex((entry) => entry.handler === handler);
-        if (index !== -1) {
-            eventListeners.splice(index, 1);
-        }
-    };
-    const emit = (event, payload) => {
-        const eventListeners = listeners.get(event);
-        if (!eventListeners || eventListeners.length === 0)
-            return;
-        // Create a copy to allow modifications during iteration
-        const listenersToCall = [...eventListeners];
-        for (const entry of listenersToCall) {
-            if (entry.once) {
-                off(event, entry.handler);
-            }
-            try {
-                entry.handler(payload);
-            }
-            catch (error) {
-                // Log error but don't stop other handlers
-                console.error(`Error in event handler for "${String(event)}":`, error);
-            }
-        }
-    };
-    const emitAsync = async (event, payload) => {
-        const eventListeners = listeners.get(event);
-        if (!eventListeners || eventListeners.length === 0)
-            return;
-        // Create a copy to allow modifications during iteration
-        const listenersToCall = [...eventListeners];
-        for (const entry of listenersToCall) {
-            if (entry.once) {
-                off(event, entry.handler);
-            }
-            try {
-                await entry.handler(payload);
-            }
-            catch (error) {
-                // Log error but don't stop other handlers
-                console.error(`Error in async event handler for "${String(event)}":`, error);
-            }
-        }
-    };
-    const removeAllListeners = (event) => {
-        if (event !== undefined) {
-            listeners.delete(event);
-        }
-        else {
-            listeners.clear();
-        }
-    };
-    const listenerCount = (event) => {
-        return listeners.get(event)?.length ?? 0;
-    };
-    const eventNames = () => {
-        return Array.from(listeners.keys()).filter((key) => {
-            const eventListeners = listeners.get(key);
-            return eventListeners !== undefined && eventListeners.length > 0;
-        });
-    };
-    return {
-        on,
-        once,
-        off,
-        emit,
-        emitAsync,
-        removeAllListeners,
-        listenerCount,
-        eventNames
-    };
-}
-/**
- * Mixin to add event emitter capabilities to a class
- */
-function withEmitter() {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return function (Base) {
-        return class extends Base {
-            constructor() {
-                super(...arguments);
-                /** @internal */
-                this._emitter = createEmitter();
-            }
-            on(event, handler, options) {
-                return this._emitter.on(event, handler, options);
-            }
-            once(event, handler) {
-                return this._emitter.once(event, handler);
-            }
-            off(event, handler) {
-                this._emitter.off(event, handler);
-            }
-            emit(event, payload) {
-                this._emitter.emit(event, payload);
-            }
-            async emitAsync(event, payload) {
-                await this._emitter.emitAsync(event, payload);
-            }
-        };
-    };
-}
-/**
- * Create an event bus for global event handling
- */
-function createEventBus() {
-    const emitter = createEmitter();
-    const createScope = () => {
-        const unsubscribers = [];
-        const scopedEmitter = {
-            on: (event, handler, options) => {
-                const unsubscribe = emitter.on(event, handler, options);
-                unsubscribers.push(unsubscribe);
-                return unsubscribe;
-            },
-            once: (event, handler) => {
-                const unsubscribe = emitter.once(event, handler);
-                unsubscribers.push(unsubscribe);
-                return unsubscribe;
-            },
-            off: emitter.off,
-            emit: emitter.emit,
-            emitAsync: emitter.emitAsync,
-            removeAllListeners: emitter.removeAllListeners,
-            listenerCount: emitter.listenerCount,
-            eventNames: emitter.eventNames,
-            dispose: () => {
-                for (const unsubscribe of unsubscribers) {
-                    unsubscribe();
-                }
-                unsubscribers.length = 0;
-            }
-        };
-        return scopedEmitter;
-    };
-    return {
-        ...emitter,
-        createScope
-    };
-}
-
-export { createEmitter, createEventBus, withEmitter };
+function e(){const e=new Map,t=t=>(e.has(t)||e.set(t,[]),e.get(t)),n=(e,n,o={})=>{const s={handler:n,once:o.once??!1,priority:o.priority??0};return t(e).push(s),(e=>{t(e).sort((e,t)=>t.priority-e.priority)})(e),()=>r(e,n)},r=(t,n)=>{const r=e.get(t);if(!r)return;const o=r.findIndex(e=>e.handler===n);-1!==o&&r.splice(o,1)};return{on:n,once:(e,t)=>n(e,t,{once:!0}),off:r,emit:(t,n)=>{const o=e.get(t);if(!o||0===o.length)return;const s=[...o];for(const e of s){e.once&&r(t,e.handler);try{e.handler(n)}catch(e){console.error(`Error in event handler for "${String(t)}":`,e)}}},emitAsync:async(t,n)=>{const o=e.get(t);if(!o||0===o.length)return;const s=[...o];for(const e of s){e.once&&r(t,e.handler);try{await e.handler(n)}catch(e){console.error(`Error in async event handler for "${String(t)}":`,e)}}},removeAllListeners:t=>{void 0!==t?e.delete(t):e.clear()},listenerCount:t=>e.get(t)?.length??0,eventNames:()=>Array.from(e.keys()).filter(t=>{const n=e.get(t);return void 0!==n&&n.length>0})}}function t(){return function(t){return class extends t{constructor(){super(...arguments),this._emitter=e()}on(e,t,n){return this._emitter.on(e,t,n)}once(e,t){return this._emitter.once(e,t)}off(e,t){this._emitter.off(e,t)}emit(e,t){this._emitter.emit(e,t)}async emitAsync(e,t){await this._emitter.emitAsync(e,t)}}}}function n(){const t=e();return{...t,createScope:()=>{const e=[];return{on:(n,r,o)=>{const s=t.on(n,r,o);return e.push(s),s},once:(n,r)=>{const o=t.once(n,r);return e.push(o),o},off:t.off,emit:t.emit,emitAsync:t.emitAsync,removeAllListeners:t.removeAllListeners,listenerCount:t.listenerCount,eventNames:t.eventNames,dispose:()=>{for(const t of e)t();e.length=0}}}}}export{e as createEmitter,n as createEventBus,t as withEmitter};

package/dist/compat/result.js

@@ -1,170 +1 @@
-/**
- * Result Pattern Implementation
- *
- * This module provides a Result type for functional error handling,
- * compatible with @oxog/types when available.
- */
-/**
- * Create a success result
- */
-function Ok(data) {
-    return { success: true, data, value: data };
-}
-/**
- * Create an error result
- */
-function Err(error) {
-    return { success: false, error };
-}
-/**
- * Create a success result (alias)
- */
-const success = Ok;
-/**
- * Create a failure result (alias)
- */
-const failure = Err;
-/**
- * Check if result is Ok
- */
-function isOk(result) {
-    return result.success === true;
-}
-/**
- * Check if result is Err
- */
-function isErr(result) {
-    return result.success === false;
-}
-/**
- * Check if value is a Result
- */
-function isResult(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'success' in value &&
-        typeof value.success === 'boolean');
-}
-/**
- * Unwrap a result, throwing the error if it's an Err
- */
-function unwrap(result) {
-    if (isOk(result)) {
-        return result.data;
-    }
-    throw result.error;
-}
-/**
- * Unwrap a result with a default value
- */
-function unwrapOr(result, defaultValue) {
-    if (isOk(result)) {
-        return result.data;
-    }
-    return defaultValue;
-}
-/**
- * Map over a successful result
- */
-function map(result, fn) {
-    if (isOk(result)) {
-        return Ok(fn(result.data));
-    }
-    return result;
-}
-/**
- * Map over an error result
- */
-function mapErr(result, fn) {
-    if (isErr(result)) {
-        return Err(fn(result.error));
-    }
-    return result;
-}
-/**
- * Chain results (flatMap)
- */
-function flatMap(result, fn) {
-    if (isOk(result)) {
-        return fn(result.data);
-    }
-    return result;
-}
-/**
- * Pattern match on a result
- */
-function match(result, handlers) {
-    if (isOk(result)) {
-        return handlers.ok(result.data);
-    }
-    return handlers.err(result.error);
-}
-/**
- * Try to execute a function and wrap the result
- */
-function tryCatch(fn) {
-    try {
-        return Ok(fn());
-    }
-    catch (error) {
-        return Err(error instanceof Error ? error : new Error(String(error)));
-    }
-}
-/**
- * Try to execute an async function and wrap the result
- */
-async function tryCatchAsync(fn) {
-    try {
-        return Ok(await fn());
-    }
-    catch (error) {
-        return Err(error instanceof Error ? error : new Error(String(error)));
-    }
-}
-/**
- * Combine multiple results into a single result
- * Returns Ok with array of values if all succeed, Err with first error otherwise
- */
-function all(results) {
-    const values = [];
-    for (const result of results) {
-        if (isErr(result)) {
-            return result;
-        }
-        values.push(result.data);
-    }
-    return Ok(values);
-}
-/**
- * Convert a nullable value to a Result
- */
-function fromNullable(value, error = new Error('Value is null or undefined')) {
-    if (value === null || value === undefined) {
-        return Err(error);
-    }
-    return Ok(value);
-}
-/**
- * Result utilities namespace
- */
-const ResultUtils = {
-    Ok,
-    Err,
-    success,
-    failure,
-    isOk,
-    isErr,
-    isResult,
-    unwrap,
-    unwrapOr,
-    map,
-    mapErr,
-    flatMap,
-    match,
-    tryCatch,
-    tryCatchAsync,
-    all,
-    fromNullable
-};
-
-export { Err, Ok, ResultUtils, all, failure, flatMap, fromNullable, isErr, isOk, isResult, map, mapErr, match, success, tryCatch, tryCatchAsync, unwrap, unwrapOr };
+function r(r){return{success:!0,data:r,value:r}}function n(r){return{success:!1,error:r}}const t=r,u=n;function e(r){return!0===r.success}function c(r){return!1===r.success}function o(r){return"object"==typeof r&&null!==r&&"success"in r&&"boolean"==typeof r.success}function a(r){if(e(r))return r.data;throw r.error}function s(r,n){return e(r)?r.data:n}function i(n,t){return e(n)?r(t(n.data)):n}function f(r,t){return c(r)?n(t(r.error)):r}function l(r,n){return e(r)?n(r.data):r}function d(r,n){return e(r)?n.ok(r.data):n.err(r.error)}function p(t){try{return r(t())}catch(r){return n(r instanceof Error?r:new Error(String(r)))}}async function y(t){try{return r(await t())}catch(r){return n(r instanceof Error?r:new Error(String(r)))}}function E(n){const t=[];for(const r of n){if(c(r))return r;t.push(r.data)}return r(t)}function h(t,u=new Error("Value is null or undefined")){return null==t?n(u):r(t)}const w={Ok:r,Err:n,success:t,failure:u,isOk:e,isErr:c,isResult:o,unwrap:a,unwrapOr:s,map:i,mapErr:f,flatMap:l,match:d,tryCatch:p,tryCatchAsync:y,all:E,fromNullable:h};export{n as Err,r as Ok,w as ResultUtils,E as all,u as failure,l as flatMap,h as fromNullable,c as isErr,e as isOk,o as isResult,i as map,f as mapErr,d as match,t as success,p as tryCatch,y as tryCatchAsync,a as unwrap,s as unwrapOr};

package/dist/errors-core.d.ts

@@ -1,4 +1,4 @@
-export type VldErrorCode = 'invalid_type' | 'invalid_string' | 'string_too_small' | 'string_too_big' | 'invalid_email' | 'invalid_url' | 'invalid_uuid' | 'invalid_regex' | 'invalid_number' | 'too_small' | 'too_big' | 'not_integer' | 'not_finite' | 'not_safe' | 'invalid_boolean' | 'invalid_date' | 'invalid_array' | 'invalid_object' | 'unrecognized_keys' | 'invalid_union' | 'invalid_literal' | 'invalid_enum' | 'custom';
+export type VldErrorCode = 'invalid_type' | 'invalid_string' | 'string_too_small' | 'string_too_big' | 'invalid_email' | 'invalid_url' | 'invalid_uuid' | 'invalid_regex' | 'invalid_format' | 'invalid_number' | 'too_small' | 'too_big' | 'not_integer' | 'not_finite' | 'not_safe' | 'not_multiple_of' | 'invalid_boolean' | 'invalid_date' | 'invalid_array' | 'invalid_object' | 'unrecognized_keys' | 'invalid_union' | 'invalid_key' | 'invalid_element' | 'invalid_literal' | 'invalid_value' | 'invalid_enum' | 'custom';
 export interface VldIssue {
     code: VldErrorCode;
     path: (string | number)[];
@@ -10,7 +10,22 @@ export interface VldIssue {
     maximum?: number;
     exact?: number;
     inclusive?: boolean;
+    origin?: string;
+    format?: string;
+    values?: unknown[];
+    pattern?: string;
 }
+/**
+ * Map a JavaScript value to Zod 4's type name for `invalid_type` issues.
+ * Produces strings like 'string', 'number', 'boolean', 'undefined', 'null',
+ * 'array', 'bigint', 'symbol', 'date', 'map', 'set', 'function', 'nan',
+ * 'Infinity', '-Infinity', 'object'.
+ */
+export declare function getTypeName(value: unknown): string;
+/**
+ * Build a Zod 4-compatible `invalid_type` issue.
+ */
+export declare function createInvalidTypeIssue(expected: string, received: string, message?: string): VldIssue;
 export interface VldErrorJSON {
     name: string;
     message: string;
@@ -26,6 +41,10 @@ export interface VldErrorJSON {
         maximum?: number;
         exact?: number;
         inclusive?: boolean;
+        origin?: string;
+        format?: string;
+        values?: unknown[];
+        pattern?: string;
     }>;
 }
 export declare class VldError extends Error {

package/dist/errors.js

@@ -1,171 +1 @@
-import { vldTheme } from './pigment.js';
-export { V as VldError } from './chunks/errors-core-BeiFUtZM.js';
-
-// VLD Error System - Advanced error formatting and utilities
-/**
- * Convert VldError to a nested tree structure
- */
-function treeifyError(error) {
-    const tree = { errors: [] };
-    for (const issue of error.issues) {
-        let currentNode = tree;
-        const path = issue.path;
-        // Navigate to the correct position in the tree
-        for (let i = 0; i < path.length; i++) {
-            const segment = path[i];
-            const isLast = i === path.length - 1;
-            if (typeof segment === 'string') {
-                // Object property
-                if (!currentNode.properties) {
-                    currentNode.properties = {};
-                }
-                if (!currentNode.properties[segment]) {
-                    currentNode.properties[segment] = { errors: [] };
-                }
-                if (isLast) {
-                    currentNode.properties[segment].errors.push(issue.message);
-                }
-                else {
-                    currentNode = currentNode.properties[segment];
-                }
-            }
-            else if (typeof segment === 'number') {
-                // Array index
-                if (!currentNode.items) {
-                    currentNode.items = [];
-                }
-                while (currentNode.items.length <= segment) {
-                    currentNode.items.push(undefined);
-                }
-                if (!currentNode.items[segment]) {
-                    currentNode.items[segment] = { errors: [] };
-                }
-                if (isLast) {
-                    currentNode.items[segment].errors.push(issue.message);
-                }
-                else {
-                    currentNode = currentNode.items[segment];
-                }
-            }
-        }
-        // If path is empty, add to root errors
-        if (path.length === 0) {
-            tree.errors.push(issue.message);
-        }
-    }
-    return tree;
-}
-/**
- * Convert VldError to human-readable string
- */
-function prettifyError(error, options = {}) {
-    const { colored = true, theme = vldTheme, includeCode = false, includeDetails = false } = options;
-    const lines = [];
-    for (const issue of error.issues) {
-        // Symbol and message
-        const symbol = colored ? theme.symbol('✖') : '✖';
-        const message = colored ? theme.error(issue.message) : issue.message;
-        let line = `${symbol} ${message}`;
-        // Error code
-        if (includeCode) {
-            const code = colored ? theme.muted(`[${issue.code}]`) : `[${issue.code}]`;
-            line += ` ${code}`;
-        }
-        // Path
-        if (issue.path.length > 0) {
-            const pathStr = issue.path
-                .map((segment, index) => {
-                if (typeof segment === 'string') {
-                    const str = index === 0 ? segment : `.${segment}`;
-                    return colored ? theme.path(str) : str;
-                }
-                else {
-                    const str = `[${segment}]`;
-                    return colored ? theme.path(str) : str;
-                }
-            })
-                .join('');
-            const arrow = colored ? theme.muted('→ at ') : '→ at ';
-            line += `\n  ${arrow}${pathStr}`;
-        }
-        // Details
-        if (includeDetails) {
-            if (issue.expected) {
-                const expected = colored
-                    ? theme.muted('expected: ') + theme.success(issue.expected)
-                    : `expected: ${issue.expected}`;
-                line += `\n  ${expected}`;
-            }
-            if (issue.received) {
-                const received = colored
-                    ? theme.muted('received: ') + theme.warning(issue.received)
-                    : `received: ${issue.received}`;
-                line += `\n  ${received}`;
-            }
-        }
-        lines.push(line);
-    }
-    return lines.join('\n');
-}
-/**
- * Convert VldError to human-readable string with full colors
- * Shorthand for prettifyError with colored: true
- */
-function prettifyErrorColored(error, options = {}) {
-    return prettifyError(error, { ...options, colored: true });
-}
-/**
- * Convert VldError to plain text string (no colors)
- * Shorthand for prettifyError with colored: false
- */
-function prettifyErrorPlain(error, options = {}) {
-    return prettifyError(error, { ...options, colored: false });
-}
-/**
- * Flatten VldError for simple form validation
- */
-function flattenError(error) {
-    const formErrors = [];
-    const fieldErrors = {};
-    for (const issue of error.issues) {
-        if (issue.path.length === 0) {
-            formErrors.push(issue.message);
-        }
-        else {
-            const firstPathSegment = issue.path[0];
-            const fieldName = firstPathSegment.toString();
-            if (!fieldErrors[fieldName]) {
-                fieldErrors[fieldName] = [];
-            }
-            fieldErrors[fieldName].push(issue.message);
-        }
-    }
-    return { formErrors, fieldErrors };
-}
-/**
- * Create a validation issue
- */
-function createIssue(code, path, message, extra) {
-    return {
-        code,
-        path: [...path],
-        message,
-        ...extra
-    };
-}
-/**
- * Helper to determine the type of a value for error messages
- */
-function getValueType(value) {
-    if (value === null)
-        return 'null';
-    if (value === undefined)
-        return 'undefined';
-    if (Array.isArray(value))
-        return 'array';
-    if (value instanceof Date)
-        return 'date';
-    return typeof value;
-}
-
-export { createIssue, flattenError, getValueType, prettifyError, prettifyErrorColored, prettifyErrorPlain, treeifyError };
+import{vldTheme as e}from"./pigment.js";export{V as VldError}from"./chunks/errors-core-Cqi4-9ew.js";function r(e){const r={errors:[]};for(const t of e.issues){let e=r;const s=t.path;for(let r=0;r<s.length;r++){const o=s[r],n=r===s.length-1;if("string"==typeof o)e.properties||(e.properties={}),e.properties[o]||(e.properties[o]={errors:[]}),n?e.properties[o].errors.push(t.message):e=e.properties[o];else if("number"==typeof o){for(e.items||(e.items=[]);e.items.length<=o;)e.items.push(void 0);e.items[o]||(e.items[o]={errors:[]}),n?e.items[o].errors.push(t.message):e=e.items[o]}}0===s.length&&r.errors.push(t.message)}return r}function t(r,t={}){const{colored:s=!0,theme:o=e,includeCode:n=!1,includeDetails:i=!1}=t,c=[];for(const e of r.issues){let r=`${s?o.symbol("✖"):"✖"} ${s?o.error(e.message):e.message}`;if(n){r+=` ${s?o.muted(`[${e.code}]`):`[${e.code}]`}`}if(e.path.length>0){const t=e.path.map((e,r)=>{if("string"==typeof e){const t=0===r?e:`.${e}`;return s?o.path(t):t}{const r=`[${e}]`;return s?o.path(r):r}}).join("");r+=`\n  ${s?o.muted("→ at "):"→ at "}${t}`}if(i){if(e.expected){r+=`\n  ${s?o.muted("expected: ")+o.success(e.expected):`expected: ${e.expected}`}`}if(e.received){r+=`\n  ${s?o.muted("received: ")+o.warning(e.received):`received: ${e.received}`}`}}c.push(r)}return c.join("\n")}function s(e,r={}){return t(e,{...r,colored:!0})}function o(e,r={}){return t(e,{...r,colored:!1})}function n(e){const r=[],t={};for(const s of e.issues)if(0===s.path.length)r.push(s.message);else{const e=s.path[0].toString();t[e]||(t[e]=[]),t[e].push(s.message)}return{formErrors:r,fieldErrors:t}}function i(e,r,t,s){return{code:e,path:[...r],message:t,...s}}function c(e){return null===e?"null":void 0===e?"undefined":Array.isArray(e)?"array":e instanceof Date?"date":typeof e}export{i as createIssue,n as flattenError,c as getValueType,t as prettifyError,s as prettifyErrorColored,o as prettifyErrorPlain,r as treeifyError};