@zajno/common 2.4.3 → 2.4.4

package/types/logger/proxy.d.ts

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

package/types/math/arrays.d.ts

@@ -1,4 +1,4 @@
-import { Comparator, Getter, Nullable, Predicate } from '../types';
+import { Comparator, Getter, Nullable, 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/index.d.ts

@@ -1,5 +1,5 @@
-export * from './calc';
-export * from './arrays';
-export * from './distribution';
+export * from './calc.js';
+export * from './arrays.js';
+export * from './distribution.js';
 export declare function getNumberSuffix(num: number): "st" | "nd" | "rd" | "th";
 export declare function format(n: number, digits?: number): string;

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

@@ -1,5 +1,5 @@
-import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep';
-import { BasePair, IObjectOps, NumKey } from './types';
+import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep.js';
+import { 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/index.d.ts

@@ -1,5 +1,5 @@
-export * from './types';
-export { ObjectOps } from './ops';
-export { ObjectMath } from './math';
-export { CompositeObjectOps } from './ops.composite';
-export { CompositeObjectMath } from './math.composite';
+export * from './types.js';
+export { ObjectOps } from './ops.js';
+export { ObjectMath } from './math.js';
+export { CompositeObjectOps } from './ops.composite.js';
+export { CompositeObjectMath } from './math.composite.js';

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

@@ -1,7 +1,7 @@
-import { AnyObject } from '../../types';
-import { DeepReadonly } from '../../types/deep';
-import { CompositeObjectOps } from './ops.composite';
-import { AbsOptions, IObjectMath, MathPairsMap, RoundOptions } from './types';
+import { AnyObject } from '../../types/index.js';
+import { DeepReadonly } from '../../types/deep.js';
+import { CompositeObjectOps } from './ops.composite.js';
+import { 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';
-import { ObjectOps } from './ops';
-import { AbsOptions, DELETE_TYPE, IObjectMath, NumKey, RoundOptions } from './types';
+import { DeepReadonly, DeepReadonlyPartial } from '../../types/deep.js';
+import { ObjectOps } from './ops.js';
+import { 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';
-import { DeepReadonly } from '../../types/deep';
-import { IObjectOps, OpsPairsMap } from './types';
+import { AnyObject } from '../../types/index.js';
+import { DeepReadonly } from '../../types/deep.js';
+import { 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';
-import { AnyObject, DeepPartial, DeepReadonly, Predicate } from '../../types';
-import { IObjectOps, NumKey } from './types';
+import { SkipCondition, SkipOptions } from '../../fields/skip.js';
+import { AnyObject, DeepPartial, DeepReadonly, Predicate } from '../../types/index.js';
+import { 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';
+import { 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/Loading.d.ts

@@ -1,4 +1,4 @@
-import type { IResetableModel, IValueModel } from './types';
+import type { IResetableModel, IValueModel } from './types.js';
 export type LoadingWorker<T> = () => (T | Promise<T>);
 export type LoadingResult<T = unknown> = {
     aborted: true;

package/types/models/LogicModel.d.ts

@@ -1,7 +1,7 @@
-import { ExclusiveLoadingError, LoadingModel } from './Loading';
-import { Getter } from '../types';
-import { PromiseExtended } from '../structures/promiseExtended';
-import { ILogger } from '../logger';
+import { ExclusiveLoadingError, LoadingModel } from './Loading.js';
+import { Getter } from '../types/index.js';
+import { PromiseExtended } from '../structures/promiseExtended.js';
+import { ILogger } from '../logger/index.js';
 export type ActionRunOptions = {
     /** Action name, required for logging and joining. */
     name?: string;

package/types/models/Model.d.ts

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

package/types/models/ValuesCollector.d.ts

@@ -1,4 +1,4 @@
-import type { IValueModel } from './types';
+import type { IValueModel } from './types.js';
 export interface IValueCollector<TSource, TValue> {
     getValue(source: TSource): TValue;
     setValue(source: TSource, value: TValue): void;

package/types/models/wrappers.d.ts

@@ -1,5 +1,5 @@
-import { Getter } from '../types/getter';
-import type { ILabel, IValueModel } from './types';
+import { Getter } from '../types/getter.js';
+import type { ILabel, IValueModel } from './types.js';
 export declare function withLabel<T, TModel extends IValueModel<T>, TLabel = string>(model: TModel, label: Getter<TLabel>): TModel & ILabel<TLabel>;
 export declare function inject<T, TModel extends IValueModel<T>>(model: TModel, source: IValueModel<T>): TModel;
 /**

package/types/observing/event.d.ts

@@ -1,5 +1,5 @@
-import type { Predicate } from '../types';
-import { ILogger } from '../logger';
+import type { Predicate } from '../types/index.js';
+import { ILogger } from '../logger/index.js';
 export type EventHandler<T = any> = (data?: T) => void | Promise<void>;
 type Unsubscribe = () => void;
 export interface IEvent<T = any> {

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

@@ -1,4 +1,4 @@
-import { Event, EventHandler } from './event';
+import { Event, EventHandler } from './event.js';
 export declare class OneTimeLateEvent<T = any> extends Event<T> {
     private _triggeredWith;
     private _triggered;

package/types/observing/progressTracker.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../logger';
+import { ILogger } from '../logger/index.js';
 export declare class ProgressTracker {
     readonly log: boolean | ILogger;
     private readonly _firstTimestamp;
@@ -10,7 +10,7 @@ export declare class ProgressTracker {
     private readonly _deltas;
     private readonly _changed;
     constructor(log?: boolean | ILogger);
-    get changed(): import("./event").IEvent<{
+    get changed(): import("./event.js").IEvent<{
         completed: number;
         total: number;
         currentProgress: number;

package/types/observing/throttledEvent.d.ts

@@ -1,4 +1,4 @@
-import { Event } from './event';
+import { Event } from './event.js';
 export declare class ThrottledEvent extends Event {
     private readonly _throttle;
     setTimeout(timeout: number): this;

package/types/observing/timer.d.ts

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

package/types/storage/index.d.ts

@@ -1,2 +1,2 @@
-export * from './types';
-export * from './wrappers';
+export * from './types.js';
+export * from './wrappers.js';

package/types/storage/types.d.ts

@@ -1,4 +1,4 @@
-import type { RemoveFirstParameter, Awaitify } from '../types/functions';
+import type { RemoveFirstParameter, Awaitify } from '../types/functions.js';
 export interface IStorage<T = string> {
     getValue(key: string): Promise<T | null>;
     setValue(key: string, value: T): Promise<void>;

package/types/storage/wrappers.d.ts

@@ -1,4 +1,4 @@
-import type { IKeyedStorage, IKeyedStorageSync, IStorage, IStorageSync } from './types';
+import type { IKeyedStorage, IKeyedStorageSync, IStorage, IStorageSync } from './types.js';
 export declare namespace Storages {
     function toAsync<T = string>(storage: IStorageSync<T>): IStorage<T>;
     function toKeyed<T = string>(storage: IStorage<T>, storageKey: string): IKeyedStorage<T>;

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

@@ -1,5 +1,5 @@
-import { BaseInput, CombineBuilders, StaticBuilder, SwitchBuilder } from './types';
-export * from './types';
+import { BaseInput, CombineBuilders, StaticBuilder, SwitchBuilder } from './types.js';
+export * from './types.js';
 /** Tagged template literal to create a path builder */
 export declare function build<TArgs extends string[]>(strings: TemplateStringsArray, ...params: TArgs): SwitchBuilder<TArgs>;
 export declare const Empty: StaticBuilder;

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

@@ -1,2 +1,2 @@
-export * from './utils';
-export * as Path from './builder';
+export * from './utils.js';
+export * as Path from './builder.js';

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

@@ -1,5 +1,5 @@
-import type { LengthArray, Nullable } from '../../types/misc';
-import type { CombineOptions } from './utils';
+import type { LengthArray, Nullable } from '../../types/misc.js';
+import type { CombineOptions } from './utils.js';
 export type ArgValue = string | number;
 export type ObjectBuilderArgs<TArgs extends string> = Record<TArgs, ArgValue>;
 export type BuilderArgs<TArgs extends string, L extends number = number> = LengthArray<ArgValue, L> | Record<TArgs, ArgValue>;

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

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

package/types/structures/pool.d.ts

@@ -1,4 +1,4 @@
-import type { IDisposable } from '../functions/disposer';
+import type { IDisposable } from '../functions/disposer.js';
 export declare class Pool<T> {
     readonly factory: () => T;
     private readonly _container;

package/types/structures/promiseCache.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../logger';
+import { ILogger } from '../logger/index.js';
 export type DeferredGetter<T> = {
     readonly current: T | null | undefined;
     readonly promise: Promise<T | null>;

package/types/structures/promiseExtended.d.ts

@@ -1,4 +1,4 @@
-import type { Nullable } from '../types/misc';
+import type { Nullable } from '../types/misc.js';
 /**
  * The idea here is to wrap a promise (or promise getter) so it will never throw natively, but still be able to provide success/fail results:
  * - `onSuccess` for handling successful result: like `then` but to be called only if there was no error

package/types/structures/promiseProxy.d.ts

@@ -1,5 +1,5 @@
-import { LazyPromise } from '../lazy/promise';
-import { AnyObject, FunctionKeys, StringKeys } from '../types';
+import { LazyPromise } from '../lazy/promise.js';
+import { 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

@@ -10,9 +10,9 @@ export declare class ParallelQueue {
     private readonly _finished;
     get currentPriority(): number;
     get inProgress(): boolean;
-    get beforePriorityRun(): import("../../observing/event").IEvent<number>;
-    get afterPriorityRun(): import("../../observing/event").IEvent<number>;
-    get finished(): import("../../observing/event").IEvent<any>;
+    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;
     /** @returns A callback that will try to cancel queued item */
     enqueue(cb: QueueItem, priority?: number): () => void;

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

@@ -1,4 +1,4 @@
-import type { ILogger } from '../../logger';
+import type { ILogger } from '../../logger/index.js';
 type Factory<T> = () => Promise<T>;
 export declare class TasksQueue<T> {
     readonly limit: number;

package/types/structures/subscribersMap.d.ts

@@ -1,4 +1,4 @@
-import { IDisposable } from '../functions/disposer';
+import { IDisposable } from '../functions/disposer.js';
 type Unsub = () => void;
 export declare class SubscribersMap implements IDisposable {
     readonly subscribe: null | ((key: string) => Promise<Unsub[]>);

package/types/structures/tempoCache.d.ts

@@ -1,5 +1,5 @@
-import type { ILazy, ILazyPromise } from '../lazy/types';
-import { ExpireTracker } from './expire';
+import type { ILazy, ILazyPromise } from '../lazy/types.js';
+import { ExpireTracker } from './expire.js';
 /**
  * Calls factory fn to fetch and store some value for a limited time.
  *

package/types/types/deep.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction } from './misc';
+import { 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';
+import { 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/index.d.ts

@@ -1,4 +1,4 @@
-export * from './deep';
-export * from './getter';
-export * from './comparator';
-export * from './misc';
+export * from './deep.js';
+export * from './getter.js';
+export * from './comparator.js';
+export * from './misc.js';

package/types/validation/ValidationErrors.d.ts

@@ -1,4 +1,4 @@
-import EnumHelper from '../structures/helpers/enum';
+import EnumHelper from '../structures/helpers/enum.js';
 export declare enum ValidationErrors {
     None = 0,
     ShouldBeNonEmpty = 1,

package/types/validation/helpers.d.ts

@@ -1,6 +1,6 @@
-import { AnyObject } from '../types';
-import { ValidationErrors } from './ValidationErrors';
-import { ValidationConfig, ValidationResults, ValidationVoid, ValidatorFunction, ValidatorFunctionAsync } from './types';
+import { AnyObject } from '../types/index.js';
+import { ValidationErrors } from './ValidationErrors.js';
+import { 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,5 @@
-export * from './ValidationErrors';
-export * from './types';
-export * from './validators';
-export * from './wrappers';
-export * from './helpers';
+export * from './ValidationErrors.js';
+export * 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';
+import { 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> = {

package/types/validation/validators.d.ts

@@ -1,4 +1,4 @@
-import { ValidationErrors } from './ValidationErrors';
+import { ValidationErrors } from './ValidationErrors.js';
 export declare const ValidatorsRegExps: {
     name: RegExp;
     englishLetters: RegExp;

package/types/validation/wrappers.d.ts

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