@zajno/common 2.7.1 → 2.7.3

package/types/logger/index.d.ts

@@ -1,13 +1,9 @@
-import { ILogger, LoggerFunction } from './abstractions.js';
+import type { ILogger, ILoggerFactory, LoggerFunction, LoggerModes } from './types.js';
 import { ConsoleLogger } from './console.js';
 import { batchLoggers } from './batch.js';
-import { LoggerModes, LoggersManager } from './manager.js';
-export type { ILogger, LoggerFunction, LoggerModes };
+import { LoggersManager } from './manager.js';
+import { Loggable } from './loggable.js';
+import { LoggerProvider } from './provider.js';
+export type { ILogger, ILoggerFactory, LoggerFunction, LoggerModes };
 export { NamedLogger } from './named.js';
-export { ConsoleLogger, batchLoggers };
-export { LoggersManager };
-/** Shared logger instance used internally in this library.
- *
- * For internal default loggers to be enabled and working, don't forget to set the mode to this instance.
-*/
-export * as SharedLogger from './shared.js';
+export { ConsoleLogger, batchLoggers, LoggersManager, Loggable, LoggerProvider, };

package/types/logger/loggable.d.ts

@@ -0,0 +1,13 @@
+import { Getter } from '../types/getter.js';
+import type { Nullable } from '../types/misc.js';
+import type { ILogger, ILoggerFactory } from './types.js';
+/** Helper base class for storing and using a logger instance. */
+export declare class Loggable {
+    private _logger;
+    constructor(logger?: ILogger);
+    protected get logger(): ILogger | null;
+    setLogger(logger?: Getter<Nullable<ILogger>>): this;
+    setLoggerFactory(factory: ILoggerFactory | null, ...args: Parameters<ILoggerFactory>): this;
+    protected getLoggerName(name: string | undefined): string;
+    protected _createLogger(factory: ILoggerFactory, ...args: Parameters<ILoggerFactory>): ILogger;
+}

package/types/logger/manager.d.ts

@@ -1,22 +1,46 @@
-import { Getter } from '../types/getter.js';
-import { ILogger } from './abstractions.js';
+import type { ILogger, LoggerModes } from './types.js';
 import { ProxyLogger } from './proxy.js';
-export type LoggerTypes = 'console';
-export type LoggerModes = LoggerTypes | false | Getter<ILogger>;
 export declare class LoggersManager {
+    /** Storage for instances created by this manager */
     private readonly _managed;
+    /** Storage for all attached instances. */
     private readonly _all;
+    /** Current main mode. */
     private _mode;
+    /** Additionally attached logger destinations (e.g. for analytics) */
+    private readonly _destinations;
     get mode(): LoggerModes;
     /** Creates and attaches an logger instance created from the current mode  */
     create(name: string | undefined, mode?: undefined | LoggerModes): ILogger;
-    /** Attaches existing instance, optionally adds name prefix to it */
-    attach(instance: ILogger, name?: string): boolean;
-    /** Sets the current mode if changed. All internally created loggers implementation will be overridden with a new implementation according to the new mode.  */
+    /** Attaches existing instance, optionally adds name prefix to it.
+     *
+     * Useful when it's needed to enable/disable independent logger when this manager's mode changes.
+     *
+     * @returns - The attached logger instance wrapped in a ProxyLogger.
+    */
+    attach(instance: ILogger, name?: string): ProxyLogger;
+    /**
+     * Adds a destination to the logger manager.
+     *
+     * This is useful for analytics or other purposes where you want to log to multiple destinations.
+     *
+     * @param target - Target logger instance that will recieve all logs disregarding current active mode.
+     * @param name - An optional name for the destination (prepended to every log message).
+     * @returns - A function to remove the destination.
+     */
+    addDestination(target: ILogger, name?: string): () => void;
+    /**
+     * Sets the current mode if changed, for all attached instances.
+     *
+     * All internally created loggers implementation will be overridden with a new implementation according to the new mode.
+     *
+     * The rest just attached loggers will be just enabled/disabled based on input mode.
+     * */
     setMode(mode: LoggerModes | null | undefined): void;
     recognize(instance: ILogger): ProxyLogger | null;
     /** Detaches instance so it won't be affected by setting mode later on, optionally disables it */
     detach(instance: ILogger, terminate?: boolean): boolean;
+    private _updateAll;
     private _findInstance;
     private _createImplementation;
     expose(): {

package/types/logger/named.d.ts

@@ -1,13 +1,14 @@
-import { ILogger, ILoggerSwitchable, LoggerFunction } from './abstractions.js';
-export declare const EMPTY_FUNCTION: () => void;
+import type { ILogger, ILoggerSwitchable, LoggerFunction } from './types.js';
 export declare abstract class NamedLogger implements ILogger, ILoggerSwitchable {
     log: LoggerFunction;
     warn: LoggerFunction;
     error: LoggerFunction;
     private _name;
+    private _enabled;
     get name(): string | null;
-    protected abstract get implementation(): ILogger;
     constructor(name?: string);
+    protected abstract get implementation(): ILogger;
+    get isEnabled(): boolean;
     enable(overrideName?: string | null): this;
     disable(): this;
 }

package/types/logger/provider.d.ts

@@ -0,0 +1,11 @@
+import { Loggable } from './loggable.js';
+import type { ILogger, ILoggerFactory } from './types.js';
+/** Logger instance holder, for re-usability */
+export declare class LoggerProvider extends Loggable {
+    private _factory;
+    constructor(nameFormatter?: (name: string | undefined) => string, logger?: ILogger);
+    get logger(): ILogger | null;
+    get factory(): ILoggerFactory | null;
+    setLoggerFactory(factory: ILoggerFactory | null, ...args: Parameters<ILoggerFactory>): this;
+    createLogger(...args: Parameters<ILoggerFactory>): ILogger | null;
+}

package/types/logger/proxy.d.ts

@@ -1,6 +1,5 @@
-import { ILogger } from './abstractions.js';
+import type { ILogger } from './types.js';
 import { NamedLogger } from './named.js';
-export declare const EMPTY_LOGGER: ILogger;
 export declare class ProxyLogger extends NamedLogger {
     protected get implementation(): ILogger;
     private _logger;

package/types/logger/types.d.ts

@@ -0,0 +1,21 @@
+import type { Getter } from '../types/getter.js';
+export type LoggerFunction = (...args: any[]) => void;
+export interface ILogger {
+    log: LoggerFunction;
+    warn: LoggerFunction;
+    error: LoggerFunction;
+}
+export interface ILoggerSwitchable {
+    enable(): void;
+    disable(): void;
+}
+export type LogLevelTypes = keyof ILogger;
+export declare const LogLevels: {
+    readonly log: 1;
+    readonly warn: 2;
+    readonly error: 3;
+};
+export type LogLevelValues = typeof LogLevels[LogLevelTypes];
+export type LoggerTypes = 'console';
+export type LoggerModes = LoggerTypes | false | Getter<ILogger>;
+export type ILoggerFactory = (name: string | undefined, mode?: LoggerModes) => ILogger;

package/types/math/arrays.d.ts

@@ -1,4 +1,4 @@
-import { Comparator, Getter, Nullable, Predicate } from '../types/index.js';
+import { Comparator, Getter, type Nullable, type Predicate } from '../types/index.js';
 /** type-safe `Array.isArray` wrapper  */
 export declare function isArray<T>(value: any): value is T[];
 export declare function arrayCompareG<T>(arr: ReadonlyArray<T> | null | undefined, cond: (current: T, previous: T | null) => boolean): T | null;

package/types/math/object/helpers.d.ts

@@ -1,5 +1,5 @@
-import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep.js';
-import { BasePair, IObjectOps, NumKey } from './types.js';
+import type { DeepReadonly, DeepReadonlyPartial } from '../../types/deep.js';
+import type { BasePair, IObjectOps, NumKey } from './types.js';
 export declare function _getValue<T extends object, TKey extends NumKey<T> = NumKey<T>>(o: DeepReadonlyPartial<T>, key: TKey): T[TKey] | null;
 export declare function _getInnerValue<T extends object, TKey extends string & keyof T>(o: DeepReadonly<T>, key: TKey): DeepReadonly<T[TKey]>;
 export declare function _getInnerValue<T extends object, TKey extends string & keyof T>(o: DeepReadonly<T> | number, key: TKey): DeepReadonly<T[TKey]> | number;

package/types/math/object/math.composite.d.ts

@@ -1,7 +1,7 @@
-import { AnyObject } from '../../types/index.js';
-import { DeepReadonly } from '../../types/deep.js';
+import type { AnyObject } from '../../types/index.js';
+import type { DeepReadonly } from '../../types/deep.js';
 import { CompositeObjectOps } from './ops.composite.js';
-import { AbsOptions, IObjectMath, MathPairsMap, RoundOptions } from './types.js';
+import type { AbsOptions, IObjectMath, MathPairsMap, RoundOptions } from './types.js';
 export declare class CompositeObjectMath<T extends AnyObject> extends CompositeObjectOps<T> implements IObjectMath<T> {
     private readonly _math;
     constructor(innerMath: MathPairsMap<T>);

package/types/math/object/math.d.ts

@@ -1,6 +1,6 @@
-import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep.js';
+import type { DeepReadonly, DeepReadonlyPartial } from '../../types/deep.js';
 import { ObjectOps } from './ops.js';
-import { AbsOptions, DELETE_TYPE, IObjectMath, NumKey, RoundOptions } from './types.js';
+import type { AbsOptions, DELETE_TYPE, IObjectMath, NumKey, RoundOptions } from './types.js';
 export declare class ObjectMath<T extends object> extends ObjectOps<T> implements IObjectMath<T> {
     getTotal(o: DeepReadonlyPartial<T>): number;
     contains(base: DeepReadonly<T>, target: DeepReadonly<T>): boolean;

package/types/math/object/ops.composite.d.ts

@@ -1,6 +1,6 @@
-import { AnyObject } from '../../types/index.js';
-import { DeepReadonly } from '../../types/deep.js';
-import { IObjectOps, OpsPairsMap } from './types.js';
+import type { AnyObject } from '../../types/index.js';
+import type { DeepReadonly } from '../../types/deep.js';
+import type { IObjectOps, OpsPairsMap } from './types.js';
 export declare class CompositeObjectOps<T extends AnyObject> implements IObjectOps<T> {
     readonly Empty: Readonly<T>;
     private readonly _ops;

package/types/math/object/ops.d.ts

@@ -1,6 +1,6 @@
 import { SkipCondition, SkipOptions } from '../../fields/skip.js';
-import { AnyObject, DeepPartial, DeepReadonly, Predicate } from '../../types/index.js';
-import { IObjectOps, NumKey } from './types.js';
+import type { AnyObject, DeepPartial, DeepReadonly, Predicate } from '../../types/index.js';
+import type { IObjectOps, NumKey } from './types.js';
 type Keys<T extends AnyObject> = NumKey<T>[];
 export declare class ObjectOps<T extends AnyObject> implements IObjectOps<T> {
     readonly keys: Keys<T>;

package/types/math/object/types.d.ts

@@ -1,4 +1,4 @@
-import { AnyObject, DeepReadonly, TypedKeys } from '../../types/index.js';
+import type { AnyObject, DeepReadonly, TypedKeys } from '../../types/index.js';
 export type NumKey<T extends AnyObject> = TypedKeys<T, number>;
 export type AbsOptions = false | 'remove' | 'zero';
 export type RoundOptions = 'floor' | 'ceil' | 'round';

package/types/models/LogicModel.d.ts

@@ -1,7 +1,7 @@
 import { ExclusiveLoadingError, LoadingModel } from './Loading.js';
 import { Getter } from '../types/index.js';
 import { PromiseExtended } from '../structures/promiseExtended.js';
-import { ILogger } from '../logger/shared.js';
+import { Loggable } from '../logger/loggable.js';
 export type ActionRunOptions = {
     /** Action name, required for logging and joining. */
     name?: string;
@@ -21,13 +21,13 @@ export type ActionRunOptions = {
     /** Whether to disable logging for the action. */
     noLogs?: boolean;
 };
-export declare class LogicModel {
+export declare class LogicModel extends Loggable {
     protected readonly _loading: LoadingModel;
     get isLoading(): boolean;
-    protected logger: ILogger;
     private readonly _namedRunners;
     private readonly _runningActionNames;
-    constructor(name?: string, useFirstInit?: boolean);
+    constructor(useFirstInit?: boolean);
+    protected getLoggerName(name?: string): string;
     protected pureConstructLoadingModel(useFirstInit: boolean): LoadingModel;
     protected runAction<T = unknown>(worker: () => Promise<T>, options?: ActionRunOptions, errorCtx?: Getter<unknown>): ActionResult<T>;
 }

package/types/models/Model.d.ts

@@ -1,6 +1,6 @@
 import type { IResetableModel, IValueModel } from './types.js';
 import { Getter } from '../types/getter.js';
-import { Nullable } from '../types/misc.js';
+import type { Nullable } from '../types/misc.js';
 export declare class Model<T> implements IValueModel<Nullable<T>>, IResetableModel {
     private _value;
     private readonly _defaultValue;

package/types/observing/event.d.ts

@@ -1,18 +1,15 @@
 import type { Predicate } from '../types/index.js';
-import { ILogger } from '../logger/shared.js';
+import { Loggable } from '../logger/loggable.js';
 export type EventHandler<T = any> = (data?: T) => void | Promise<void>;
 type Unsubscribe = () => void;
 export interface IEvent<T = any> {
     on(handler: EventHandler<T>): () => void;
     off(handler: EventHandler<T>): void;
 }
-export declare class Event<T = any> implements IEvent<T> {
+export declare class Event<T = any> extends Loggable implements IEvent<T> {
     private _handlers;
-    private _logger;
-    constructor(withDefaultLogger?: boolean);
     get isEmpty(): boolean;
-    withLogger(logger?: ILogger | null): this;
-    withLogger(name?: string | null): this;
+    protected getLoggerName(name: string | undefined): string;
     /** Clears handlers list */
     resetHandlers: () => void;
     on(handler: EventHandler<T>): Unsubscribe;

package/types/observing/event.late.d.ts

@@ -1,4 +1,4 @@
-import { Event, EventHandler } from './event.js';
+import { Event, type EventHandler } from './event.js';
 /**
  * One-time event that can be triggered only once, but listeners will be notified at the time of event or subscription, if it happens later.
  *

package/types/observing/progressTracker.d.ts

@@ -1,6 +1,6 @@
-import { type ILogger } from '../logger/shared.js';
+import { type ILogger } from '../logger/index.js';
 export declare class ProgressTracker {
-    readonly log: boolean | ILogger;
+    readonly logger?: ILogger | undefined;
     private readonly _firstTimestamp;
     private _lastTimestamp;
     private _lastCompleted;
@@ -9,7 +9,7 @@ export declare class ProgressTracker {
     private _currentProgress;
     private readonly _deltas;
     private readonly _changed;
-    constructor(log?: boolean | ILogger);
+    constructor(logger?: ILogger | undefined);
     get changed(): import("./event.js").IEvent<{
         completed: number;
         total: number;
@@ -20,7 +20,6 @@ export declare class ProgressTracker {
     get total(): number;
     get completed(): number;
     get current(): number;
-    private get logger();
     setTotal(total: number): this;
     add(amount?: number, restart?: boolean): void;
     track(completed: number, total: number): void;

package/types/observing/timer.d.ts

@@ -1,5 +1,5 @@
-import { IDisposable } from '../functions/disposer.js';
-import { EventHandler, IEvent } from './event.js';
+import type { IDisposable } from '../functions/disposer.js';
+import { type EventHandler, type IEvent } from './event.js';
 export type TimerState = {
     timer: Timer;
     elapsed: number;

package/types/observing/transition.d.ts

@@ -0,0 +1,40 @@
+import { type IEvent } from './event.js';
+import type { DisposeFunction, IDisposable } from '../functions/disposer.js';
+import { Getter } from '../types/getter.js';
+import type { Nullable } from '../types/misc.js';
+import { Loggable } from '../logger/loggable.js';
+export type TransitionReaction<T> = (getter: Getter<T>, handler: (v: T) => any) => DisposeFunction;
+export declare class TransitionObserver<T> extends Loggable implements IDisposable {
+    protected readonly reaction: TransitionReaction<T>;
+    private _event;
+    private _getter;
+    private _filter;
+    private _disposer;
+    private _prev;
+    private _from;
+    private _to;
+    private _cb;
+    private _fireOnce;
+    private _promise;
+    private _promiseReject;
+    constructor(reaction: TransitionReaction<T>, getter?: () => T);
+    get event(): IEvent<T>;
+    get currentValue(): Nullable<T>;
+    get isObserving(): boolean;
+    private get isPromising();
+    observe(getter: () => T): this;
+    from(from: Getter<T>): this;
+    to(to: Getter<T>): this;
+    filter(filter: (next: T, prev: Nullable<T>) => boolean): this;
+    cb(cb: (v: Nullable<T>) => any): this;
+    forceCall(): this;
+    fireOnce(enable?: boolean): this;
+    forceCheck(): boolean;
+    andForceCheck(): this;
+    getPromise(timeout?: number | null): Promise<Nullable<T>>;
+    reverse(): TransitionObserver<T>;
+    dispose: () => void;
+    private _checkValue;
+    private _finishPromise;
+}
+export declare function waitFor<T>(reaction: TransitionReaction<T>, current: () => T, toBe: T): Promise<Nullable<T>>;

package/types/structures/path/builder.d.ts

@@ -1,4 +1,4 @@
-import { BaseInput, CombineBuilders, SwitchBuilder } from './types.js';
+import type { BaseInput, CombineBuilders, SwitchBuilder } from './types.js';
 export type * from './types.js';
 export type { TemplateTransform } from './types.helpers.js';
 /** Tagged template literal to create a path builder */

package/types/structures/path/utils.d.ts

@@ -1,4 +1,4 @@
-import { Nullable } from '../../types/misc.js';
+import type { Nullable } from '../../types/misc.js';
 export declare function indexTrim(str: string | null | undefined, ch: string): string;
 export type CombineOptions = {
     noTrim?: boolean;

package/types/structures/promiseCache.d.ts

@@ -1,5 +1,5 @@
-import { ILogger } from '../logger/shared.js';
-import { IMapModel, IValueModel } from '../models/types.js';
+import { Loggable } from '../logger/loggable.js';
+import type { IMapModel, IValueModel } from '../models/types.js';
 export type DeferredGetter<T> = {
     readonly current: T | null | undefined;
     readonly promise: Promise<T | null>;
@@ -19,7 +19,7 @@ export declare namespace DeferredGetter {
  *  - batching of fetches.
  *  - auto-invalidation of cached items.
 */
-export declare class PromiseCache<T, K = string> {
+export declare class PromiseCache<T, K = string> extends Loggable {
     private readonly fetcher;
     private readonly keyAdapter?;
     private readonly keyParser?;
@@ -31,7 +31,6 @@ export declare class PromiseCache<T, K = string> {
     private _batch;
     private _invalidationTimeMs;
     private _keepInstanceDuringInvalidation;
-    private _logger;
     private _version;
     constructor(fetcher: (id: K) => Promise<T>, keyAdapter?: (K extends string ? null : (k: K) => string) | undefined, keyParser?: (K extends string ? null : (id: string) => K) | undefined);
     get busyCount(): number;
@@ -40,7 +39,7 @@ export declare class PromiseCache<T, K = string> {
     protected pure_createItemsStatus(): IMapModel<string, boolean>;
     protected pure_createFetchCache(): IMapModel<string, Promise<T | null>>;
     private _pk;
-    useLogger(nameOrLogger?: string | ILogger): this;
+    protected getLoggerName(name: string | undefined): string;
     /**
      * Provide a fetcher function that takes multiple ids and returns multiple results at once. Will be called with a slight delay to allow multiple ids to be collected.
      *

package/types/structures/promiseProxy.d.ts

@@ -1,5 +1,5 @@
 import { LazyPromise } from '../lazy/promise.js';
-import { AnyObject, FunctionKeys, StringKeys } from '../types/index.js';
+import type { AnyObject, FunctionKeys, StringKeys } from '../types/index.js';
 declare const PromiseGetter = "__promise";
 type AllowedFnKeys<T extends AnyObject> = FunctionKeys<T, any[], void>;
 type PromiseProxy<T extends AnyObject, TKeys extends StringKeys<T> = StringKeys<T>, TFnKeys = never, TWrap extends object = object> = {

package/types/structures/queue/parallel.d.ts

@@ -1,10 +1,10 @@
+import { Loggable } from '../../logger/loggable.js';
 export type QueueItem = () => void | Promise<void>;
-export declare class ParallelQueue {
+export declare class ParallelQueue extends Loggable {
     private readonly _queues;
     private _inProgress;
     private _currentIndex;
     private _maxIndex;
-    private _logger;
     private readonly _beforePriorityRun;
     private readonly _afterPriorityRun;
     private readonly _finished;
@@ -13,7 +13,7 @@ export declare class ParallelQueue {
     get beforePriorityRun(): import("../../observing/event.js").IEvent<number>;
     get afterPriorityRun(): import("../../observing/event.js").IEvent<number>;
     get finished(): import("../../observing/event.js").IEvent<any>;
-    withLogger(name?: string): this;
+    protected getLoggerName(name: string | undefined): string;
     /** @returns A callback that will try to cancel queued item */
     enqueue(cb: QueueItem, priority?: number): () => void;
     start(): Promise<boolean | undefined>;

package/types/structures/subscribersMap.d.ts

@@ -1,16 +1,17 @@
-import { IDisposable } from '../functions/disposer.js';
+import { type IDisposable } from '../functions/disposer.js';
+import { Loggable } from '../logger/loggable.js';
 type Unsub = () => void;
-export declare class SubscribersMap implements IDisposable {
+export declare class SubscribersMap extends Loggable implements IDisposable {
     readonly subscribe: null | ((key: string) => Promise<Unsub[]>);
     readonly name?: string | undefined;
     /** Unsubscribers map: key => unsub fn */
     private readonly _map;
     /** Timeouts map: key => timeout handle */
     private readonly _timeouts;
-    private readonly _logger;
     protected _count: number;
     constructor(subscribe: null | ((key: string) => Promise<Unsub[]>), name?: string | undefined);
     get count(): number;
+    protected getLoggerName(name: string | undefined): string;
     getIsObserving(key: string): boolean;
     getHasObserveTimeout(key: string): boolean;
     enable(key: string, enable: boolean, clearAfter?: number | null, existingUnsubs?: Unsub[] | null): Promise<void>;

package/types/types/deep.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction } from './misc.js';
+import type { AnyFunction } from './misc.js';
 export type DeepReadonly<T> = T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : (T extends AnyFunction ? T : (T extends object ? {
     readonly [P in keyof T]: DeepReadonly<T[P]>;
 } : T));

package/types/types/functions.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction } from './misc.js';
+import type { AnyFunction } from './misc.js';
 export type TypedFn<A extends unknown[], R> = (...args: A) => R;
 export type Asyncify<T> = {
     [P in keyof T]: T[P] extends TypedFn<unknown[], Promise<unknown>> ? T[P] : (T[P] extends TypedFn<infer A, infer R> ? (...args: A) => Promise<R> : T[P]);

package/types/types/ident.d.ts

@@ -2,4 +2,3 @@ export type Ident<T, K extends keyof any = string> = T & {
     id: K;
 };
 export type IdentAny = Ident<object>;
-export default Ident;

package/types/validation/helpers.d.ts

@@ -1,6 +1,6 @@
-import { AnyObject } from '../types/index.js';
+import type { AnyObject } from '../types/index.js';
 import { ValidationErrors } from './ValidationErrors.js';
-import { ValidationConfig, ValidationResults, ValidationVoid, ValidatorFunction, ValidatorFunctionAsync } from './types.js';
+import type { ValidationConfig, ValidationResults, ValidationVoid, ValidatorFunction, ValidatorFunctionAsync } from './types.js';
 export declare function createShouldBeEqualTo<T = string>(getter: () => T): ValidatorFunction<T>;
 export declare function throwNotOk(result: ValidationErrors, message?: string): void;
 export declare function validateObject<T extends AnyObject, TErrors = ValidationErrors>(obj: T, validators: ValidationConfig<T, TErrors>, onlyTruthy?: boolean, context?: T): ValidationResults<T, TErrors>;

package/types/validation/index.d.ts

@@ -1,5 +1,6 @@
 export * from './ValidationErrors.js';
-export * from './types.js';
+export * from './validationError.js';
+export type * from './types.js';
 export * from './validators.js';
 export * from './wrappers.js';
 export * from './helpers.js';

package/types/validation/types.d.ts

@@ -1,4 +1,4 @@
-import { ValidationErrors } from './ValidationErrors.js';
+import { type ValidationErrors } from './ValidationErrors.js';
 export type ValidatorFunction<T = string, TErrors = ValidationErrors, TContext = any> = (val: T, ctx?: TContext) => TErrors;
 export type ValidatorFunctionAsync<T = string, TErrors = ValidationErrors, TContext = any> = (val: T, ctx?: TContext) => Promise<TErrors>;
 export type ValidationConfig<T, TErrors> = {
@@ -8,10 +8,6 @@ export type ValidationResults<T, TErrors> = {
     [P in keyof T]?: TErrors;
 };
 export type WrapperFunction = (val: ValidatorFunction) => ValidatorFunction;
-export declare class ValidationError<TErrors = ValidationErrors> extends Error {
-    readonly code: TErrors;
-    constructor(message: string, code: TErrors);
-}
 export interface ValidationVoid {
     readonly error?: string | null | undefined;
     validate(): Promise<boolean>;

package/types/validation/validationError.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationErrors } from './ValidationErrors.js';
+export declare class ValidationError<TErrors = ValidationErrors> extends Error {
+    readonly code: TErrors;
+    constructor(message: string, code: TErrors);
+}

package/types/validation/wrappers.d.ts

@@ -1,4 +1,4 @@
-import { ValidatorFunction } from './types.js';
+import type { ValidatorFunction } from './types.js';
 export declare const Wrappers: {
     required<T = string>(validator: ValidatorFunction<T>): ValidatorFunction<T>;
     notRequired<T = string>(validator: ValidatorFunction<T>): ValidatorFunction<T>;

package/cjs/logger/abstractions.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=abstractions.js.map

package/cjs/logger/abstractions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"abstractions.js","sourceRoot":"","sources":["../../../src/logger/abstractions.ts"],"names":[],"mappings":""}

package/cjs/logger/file.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileLoggerNode = void 0;
-const tslib_1 = require("tslib");
-/* eslint-disable no-console */
-const Path = tslib_1.__importStar(require("path"));
-const FS = tslib_1.__importStar(require("fs"));
-const Util = tslib_1.__importStar(require("util"));
-class FileLoggerNode {
-    extraLogger;
-    instantFlush;
-    _buffer = [];
-    _logFilePath = null;
-    constructor(extraLogger = console, instantFlush = false) {
-        this.extraLogger = extraLogger;
-        this.instantFlush = instantFlush;
-        this.setLogName('');
-    }
-    setLogFilePath(path) {
-        this._logFilePath = path;
-        return this;
-    }
-    setLogName(name) {
-        const n = name ? `-${name}` : '';
-        this._logFilePath = Path.resolve(process.cwd(), `run${n}.${new Date().toISOString()}.log`);
-        return this;
-    }
-    append(..._args) {
-        const str = Util.format.apply(null, _args) + '\n';
-        this._buffer.push(str);
-        if (this.instantFlush) {
-            this.flush();
-        }
-    }
-    log = (...args) => {
-        this.extraLogger?.log(...args);
-        this.append(...args);
-    };
-    warn = (...args) => {
-        this.extraLogger?.warn(...args);
-        this.append(...args);
-    };
-    error = (...args) => {
-        this.extraLogger?.error(...args);
-        this.append(...args);
-    };
-    flush() {
-        if (!this._buffer.length) {
-            return;
-        }
-        try {
-            if (this._logFilePath) {
-                FS.appendFileSync(this._logFilePath, this._buffer.join(''));
-            }
-        }
-        catch (err) {
-            console.warn('Failed to flush file, error', err);
-        }
-        finally {
-            this._buffer.length = 0;
-        }
-    }
-}
-exports.FileLoggerNode = FileLoggerNode;
-//# sourceMappingURL=file.js.map

package/cjs/logger/file.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"file.js","sourceRoot":"","sources":["../../../src/logger/file.ts"],"names":[],"mappings":";;;;AACA,+BAA+B;AAC/B,mDAA6B;AAC7B,+CAAyB;AACzB,mDAA6B;AAI7B,MAAa,cAAc;IAIF;IAAyC;IAH7C,OAAO,GAAa,EAAE,CAAC;IAChC,YAAY,GAAkB,IAAI,CAAC;IAE3C,YAAqB,cAAuB,OAAO,EAAW,eAAe,KAAK;QAA7D,gBAAW,GAAX,WAAW,CAAmB;QAAW,iBAAY,GAAZ,YAAY,CAAQ;QAC9E,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;IACxB,CAAC;IAED,cAAc,CAAC,IAAY;QACvB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,UAAU,CAAC,IAAY;QACnB,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACjC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,IAAI,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QAC3F,OAAO,IAAI,CAAC;IAChB,CAAC;IAEO,MAAM,CAAC,GAAG,KAAY;QAC1B,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;QAClD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEvB,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC;IACL,CAAC;IAED,GAAG,GAAG,CAAC,GAAG,IAAW,EAAE,EAAE;QACrB,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IACzB,CAAC,CAAC;IAEF,IAAI,GAAG,CAAC,GAAG,IAAW,EAAE,EAAE;QACtB,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IACzB,CAAC,CAAC;IAEF,KAAK,GAAG,CAAC,GAAG,IAAW,EAAE,EAAE;QACvB,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IACzB,CAAC,CAAC;IAEF,KAAK;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACvB,OAAO;QACX,CAAC;QAED,IAAI,CAAC;YACD,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBACpB,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;YAChE,CAAC;QACL,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,6BAA6B,EAAE,GAAG,CAAC,CAAC;QACrD,CAAC;gBAAS,CAAC;YACP,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QAC5B,CAAC;IACL,CAAC;CACJ;AA1DD,wCA0DC"}