@oxog/vld 2.0.3 → 2.2.5

package/dist/compat/emitter.js

@@ -1,181 +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 };
-//# sourceMappingURL=emitter.js.map
+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/index.d.ts

@@ -8,8 +8,7 @@
  * - Result pattern (@oxog/types compatibility)
  * - Event emitter (@oxog/emitter compatibility)
  */
-export type { Result, VldResult } from './result';
-export { Ok, Err, success, failure, isOk, isErr, isResult, unwrap, unwrapOr, map, mapErr, flatMap, match, tryCatch, tryCatchAsync, all, fromNullable, ResultUtils } from './result';
-export type { EventMap, EventHandler, ListenerOptions, Emitter, VldEventHandler } from './emitter';
-export { createEmitter, createEventBus, withEmitter } from './emitter';
-//# sourceMappingURL=index.d.ts.map
+export type { Result, VldResult } from './result.js';
+export { Ok, Err, success, failure, isOk, isErr, isResult, unwrap, unwrapOr, map, mapErr, flatMap, match, tryCatch, tryCatchAsync, all, fromNullable, ResultUtils } from './result.js';
+export type { EventMap, EventHandler, ListenerOptions, Emitter, VldEventHandler } from './emitter.js';
+export { createEmitter, createEventBus, withEmitter } from './emitter.js';

package/dist/compat/result.d.ts

@@ -4,7 +4,7 @@
  * This module provides a Result type for functional error handling,
  * compatible with @oxog/types when available.
  */
-import type { VldError } from '../errors';
+import type { VldError } from '../errors.js';
 /**
  * Success result type
  */
@@ -125,4 +125,3 @@ export declare const ResultUtils: {
     all: typeof all;
     fromNullable: typeof fromNullable;
 };
-//# sourceMappingURL=result.d.ts.map

package/dist/compat/result.js

@@ -1,171 +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 };
-//# sourceMappingURL=result.js.map
+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

@@ -0,0 +1,58 @@
+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)[];
+    message: string;
+    expected?: string;
+    received?: string;
+    keys?: string[];
+    minimum?: number;
+    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;
+    code: string;
+    issues: Array<{
+        code: string;
+        path: (string | number)[];
+        message: string;
+        expected?: string;
+        received?: string;
+        keys?: string[];
+        minimum?: number;
+        maximum?: number;
+        exact?: number;
+        inclusive?: boolean;
+        origin?: string;
+        format?: string;
+        values?: unknown[];
+        pattern?: string;
+    }>;
+}
+export declare class VldError extends Error {
+    readonly issues: VldIssue[];
+    constructor(issues: VldIssue[]);
+    get firstError(): VldIssue | undefined;
+    get formattedErrors(): string[];
+    toJSON(): VldErrorJSON;
+    static fromJSON(json: VldErrorJSON): VldError;
+    static isVldError(value: unknown): value is VldError;
+}

package/dist/errors.d.ts

@@ -1,56 +1,7 @@
-import { type Theme } from './pigment';
-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 interface VldIssue {
-    code: VldErrorCode;
-    path: (string | number)[];
-    message: string;
-    expected?: string;
-    received?: string;
-    keys?: string[];
-    minimum?: number;
-    maximum?: number;
-    exact?: number;
-    inclusive?: boolean;
-}
-export declare class VldError extends Error {
-    readonly issues: VldIssue[];
-    constructor(issues: VldIssue[]);
-    get firstError(): VldIssue | undefined;
-    get formattedErrors(): string[];
-    /**
-     * Convert error to JSON representation
-     * Compatible with @oxog/types OxogError
-     */
-    toJSON(): VldErrorJSON;
-    /**
-     * Create VldError from JSON representation
-     */
-    static fromJSON(json: VldErrorJSON): VldError;
-    /**
-     * Check if a value is a VldError
-     */
-    static isVldError(value: unknown): value is VldError;
-}
-/**
- * JSON representation of VldError
- */
-export interface VldErrorJSON {
-    name: string;
-    message: string;
-    code: string;
-    issues: Array<{
-        code: string;
-        path: (string | number)[];
-        message: string;
-        expected?: string;
-        received?: string;
-        keys?: string[];
-        minimum?: number;
-        maximum?: number;
-        exact?: number;
-        inclusive?: boolean;
-    }>;
-}
+import { type Theme } from './pigment.js';
+export { VldError } from './errors-core.js';
+export type { VldErrorCode, VldErrorJSON, VldIssue } from './errors-core.js';
+import { VldError, type VldErrorCode, type VldIssue } from './errors-core.js';
 export interface VldErrorTree {
     errors: string[];
     properties?: Record<string, VldErrorTree>;
@@ -103,4 +54,3 @@ export declare function createIssue(code: VldErrorCode, path: (string | number)[
  * Helper to determine the type of a value for error messages
  */
 export declare function getValueType(value: unknown): string;
-//# sourceMappingURL=errors.d.ts.map