@zajno/common 2.7.2 → 2.7.4

package/types/logger/loggable.d.ts

@@ -1,13 +1,18 @@
 import { Getter } from '../types/getter.js';
-import { Nullable } from '../types/misc.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;
+    /** Returns current logger ({@linkcode ILogger}), or {@link EMPTY_LOGGER} if not set via {@linkcode Loggable.setLogger} or {@linkcode Loggable.setLoggerFactory}. */
+    protected get logger(): ILogger;
+    /** @returns Whether logger has been set */
+    protected get hasLogger(): boolean;
+    setLogger(logger: Getter<Nullable<ILogger>>): this;
     setLoggerFactory(factory: ILoggerFactory | null, ...args: Parameters<ILoggerFactory>): this;
+    /** Override this method to customize logger name formatting which is used in {@link Loggable._createLogger} */
     protected getLoggerName(name: string | undefined): string;
+    /** Helper for creating a logger instance with factory and params. */
     protected _createLogger(factory: ILoggerFactory, ...args: Parameters<ILoggerFactory>): ILogger;
 }

package/types/logger/provider.d.ts

@@ -4,7 +4,7 @@ import type { ILogger, ILoggerFactory } from './types.js';
 export declare class LoggerProvider extends Loggable {
     private _factory;
     constructor(nameFormatter?: (name: string | undefined) => string, logger?: ILogger);
-    get logger(): ILogger | null;
+    get logger(): ILogger;
     get factory(): ILoggerFactory | null;
     setLoggerFactory(factory: ILoggerFactory | null, ...args: Parameters<ILoggerFactory>): this;
     createLogger(...args: Parameters<ILoggerFactory>): ILogger | null;

package/types/logger/types.d.ts

@@ -1,9 +1,9 @@
 import type { Getter } from '../types/getter.js';
 export type LoggerFunction = (...args: any[]) => void;
 export interface ILogger {
-    log: LoggerFunction;
-    warn: LoggerFunction;
-    error: LoggerFunction;
+    readonly log: LoggerFunction;
+    readonly warn: LoggerFunction;
+    readonly error: LoggerFunction;
 }
 export interface ILoggerSwitchable {
     enable(): void;

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/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.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/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 { Loggable } from '../logger/loggable.js';
-import { IMapModel, IValueModel } from '../models/types.js';
+import type { IMapModel, IValueModel } from '../models/types.js';
 export type DeferredGetter<T> = {
     readonly current: T | null | undefined;
     readonly promise: Promise<T | null>;

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/subscribersMap.d.ts

@@ -1,4 +1,4 @@
-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 extends Loggable implements IDisposable {

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>;