@oxog/vld 2.0.2 → 2.1.0

package/dist/cjs/compat/emitter.cjs

@@ -0,0 +1,184 @@
+'use strict';
+
+/**
+ * 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
+    };
+}
+
+exports.createEmitter = createEmitter;
+exports.createEventBus = createEventBus;
+exports.withEmitter = withEmitter;

package/dist/cjs/compat/result.cjs

@@ -0,0 +1,189 @@
+'use strict';
+
+/**
+ * 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
+};
+
+exports.Err = Err;
+exports.Ok = Ok;
+exports.ResultUtils = ResultUtils;
+exports.all = all;
+exports.failure = failure;
+exports.flatMap = flatMap;
+exports.fromNullable = fromNullable;
+exports.isErr = isErr;
+exports.isOk = isOk;
+exports.isResult = isResult;
+exports.map = map;
+exports.mapErr = mapErr;
+exports.match = match;
+exports.success = success;
+exports.tryCatch = tryCatch;
+exports.tryCatchAsync = tryCatchAsync;
+exports.unwrap = unwrap;
+exports.unwrapOr = unwrapOr;

package/dist/cjs/errors.cjs

@@ -1,216 +1,9 @@
 'use strict';
 
-/**
- * VLD Pigment - Colored Console Output
- *
- * This module provides ANSI color utilities for terminal output,
- * compatible with @oxog/pigment when available.
- */
-/* eslint-enable @typescript-eslint/no-explicit-any */
-/**
- * Check if colors are supported in the current environment
- */
-function supportsColor() {
-    // Check for NO_COLOR environment variable
-    if (typeof process !== 'undefined' && process.env?.NO_COLOR) {
-        return false;
-    }
-    // Check for FORCE_COLOR environment variable
-    if (typeof process !== 'undefined' && process.env?.FORCE_COLOR) {
-        return true;
-    }
-    // Check for TTY
-    if (typeof process !== 'undefined' && process.stdout?.isTTY) {
-        return true;
-    }
-    // Browser environment - no ANSI colors
-    if (typeof window !== 'undefined') {
-        return false;
-    }
-    return false;
-}
-/**
- * ANSI escape codes
- */
-const ANSI = {
-    // Reset
-    reset: '\x1b[0m',
-    // Styles
-    bold: '\x1b[1m',
-    dim: '\x1b[2m',
-    italic: '\x1b[3m',
-    underline: '\x1b[4m',
-    inverse: '\x1b[7m',
-    hidden: '\x1b[8m',
-    strikethrough: '\x1b[9m',
-    // Foreground colors
-    black: '\x1b[30m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m',
-    cyan: '\x1b[36m',
-    white: '\x1b[37m',
-    gray: '\x1b[90m',
-    grey: '\x1b[90m',
-    // Bright foreground colors
-    brightRed: '\x1b[91m',
-    brightGreen: '\x1b[92m',
-    brightYellow: '\x1b[93m',
-    brightBlue: '\x1b[94m',
-    brightMagenta: '\x1b[95m',
-    brightCyan: '\x1b[96m',
-    brightWhite: '\x1b[97m',
-    // Background colors
-    bgBlack: '\x1b[40m',
-    bgRed: '\x1b[41m',
-    bgGreen: '\x1b[42m',
-    bgYellow: '\x1b[43m',
-    bgBlue: '\x1b[44m',
-    bgMagenta: '\x1b[45m',
-    bgCyan: '\x1b[46m',
-    bgWhite: '\x1b[47m'};
-/**
- * Create a color function
- */
-function createColorFn(code) {
-    const enabled = supportsColor();
-    return (text) => {
-        if (!enabled || text === '')
-            return text;
-        return `${code}${text}${ANSI.reset}`;
-    };
-}
-/**
- * Pigment - Color utilities for terminal output
- */
-const pigment = {
-    // Styles
-    bold: createColorFn(ANSI.bold),
-    dim: createColorFn(ANSI.dim),
-    italic: createColorFn(ANSI.italic),
-    underline: createColorFn(ANSI.underline),
-    inverse: createColorFn(ANSI.inverse),
-    hidden: createColorFn(ANSI.hidden),
-    strikethrough: createColorFn(ANSI.strikethrough),
-    // Foreground colors
-    black: createColorFn(ANSI.black),
-    red: createColorFn(ANSI.red),
-    green: createColorFn(ANSI.green),
-    yellow: createColorFn(ANSI.yellow),
-    blue: createColorFn(ANSI.blue),
-    magenta: createColorFn(ANSI.magenta),
-    cyan: createColorFn(ANSI.cyan),
-    white: createColorFn(ANSI.white),
-    gray: createColorFn(ANSI.gray),
-    grey: createColorFn(ANSI.grey),
-    // Bright colors
-    brightRed: createColorFn(ANSI.brightRed),
-    brightGreen: createColorFn(ANSI.brightGreen),
-    brightYellow: createColorFn(ANSI.brightYellow),
-    brightBlue: createColorFn(ANSI.brightBlue),
-    brightMagenta: createColorFn(ANSI.brightMagenta),
-    brightCyan: createColorFn(ANSI.brightCyan),
-    brightWhite: createColorFn(ANSI.brightWhite),
-    // Background colors
-    bgBlack: createColorFn(ANSI.bgBlack),
-    bgRed: createColorFn(ANSI.bgRed),
-    bgGreen: createColorFn(ANSI.bgGreen),
-    bgYellow: createColorFn(ANSI.bgYellow),
-    bgBlue: createColorFn(ANSI.bgBlue),
-    bgMagenta: createColorFn(ANSI.bgMagenta),
-    bgCyan: createColorFn(ANSI.bgCyan),
-    bgWhite: createColorFn(ANSI.bgWhite),
-    // Semantic colors
-    success: createColorFn(ANSI.green),
-    error: createColorFn(ANSI.red),
-    warning: createColorFn(ANSI.yellow),
-    info: createColorFn(ANSI.blue),
-    muted: createColorFn(ANSI.gray)};
-// Aliases for convenience
-const { bold, dim, red, green, yellow, blue, cyan} = pigment;
-/**
- * Default VLD theme for error formatting
- */
-const vldTheme = {
-    error: red,
-    success: green,
-    warning: yellow,
-    info: blue,
-    muted: dim,
-    path: cyan,
-    value: yellow,
-    key: bold,
-    symbol: red
-};
+var pigment = require('./pigment.cjs');
+var errorsCore = require('./chunks/errors-core-DWxLFs2f.cjs');
 
 // VLD Error System - Advanced error formatting and utilities
-class VldError extends Error {
-    constructor(issues) {
-        const message = issues.length === 1 ? issues[0].message : `${issues.length} validation errors`;
-        super(message);
-        this.name = 'VldError';
-        this.issues = issues;
-        // Maintain proper stack trace
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, VldError);
-        }
-    }
-    get firstError() {
-        return this.issues[0];
-    }
-    get formattedErrors() {
-        return this.issues.map((issue) => issue.message);
-    }
-    /**
-     * Convert error to JSON representation
-     * Compatible with @oxog/types OxogError
-     */
-    toJSON() {
-        return {
-            name: this.name,
-            message: this.message,
-            code: 'VLD_VALIDATION_ERROR',
-            issues: this.issues.map((issue) => ({
-                code: issue.code,
-                path: issue.path,
-                message: issue.message,
-                expected: issue.expected,
-                received: issue.received,
-                keys: issue.keys,
-                minimum: issue.minimum,
-                maximum: issue.maximum,
-                exact: issue.exact,
-                inclusive: issue.inclusive
-            }))
-        };
-    }
-    /**
-     * Create VldError from JSON representation
-     */
-    static fromJSON(json) {
-        const issues = json.issues.map((issue) => ({
-            code: issue.code,
-            path: issue.path,
-            message: issue.message,
-            expected: issue.expected,
-            received: issue.received,
-            keys: issue.keys,
-            minimum: issue.minimum,
-            maximum: issue.maximum,
-            exact: issue.exact,
-            inclusive: issue.inclusive
-        }));
-        return new VldError(issues);
-    }
-    /**
-     * Check if a value is a VldError
-     */
-    static isVldError(value) {
-        return value instanceof VldError;
-    }
-}
 /**
  * Convert VldError to a nested tree structure
  */
@@ -268,7 +61,7 @@ function treeifyError(error) {
  * Convert VldError to human-readable string
  */
 function prettifyError(error, options = {}) {
-    const { colored = true, theme = vldTheme, includeCode = false, includeDetails = false } = options;
+    const { colored = true, theme = pigment.vldTheme, includeCode = false, includeDetails = false } = options;
     const lines = [];
     for (const issue of error.issues) {
         // Symbol and message
@@ -341,7 +134,8 @@ function flattenError(error) {
             formErrors.push(issue.message);
         }
         else {
-            const fieldName = issue.path[0].toString();
+            const firstPathSegment = issue.path[0];
+            const fieldName = firstPathSegment.toString();
             if (!fieldErrors[fieldName]) {
                 fieldErrors[fieldName] = [];
             }
@@ -376,7 +170,7 @@ function getValueType(value) {
     return typeof value;
 }
 
-exports.VldError = VldError;
+exports.VldError = errorsCore.VldError;
 exports.createIssue = createIssue;
 exports.flattenError = flattenError;
 exports.getValueType = getValueType;
@@ -384,4 +178,3 @@ exports.prettifyError = prettifyError;
 exports.prettifyErrorColored = prettifyErrorColored;
 exports.prettifyErrorPlain = prettifyErrorPlain;
 exports.treeifyError = treeifyError;
-//# sourceMappingURL=errors.cjs.map