@zelgadis87/utils-core 4.9.0 → 4.11.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@zelgadis87/utils-core",
-  "version": "4.9.0",
+  "version": "4.11.0",
   "author": "Zelgadis87",
   "license": "ISC",
   "private": false,

package/src/Logger.ts

@@ -1,5 +1,5 @@
 import TimeInstant from "./time/TimeInstant";
-import { noop } from "./utils/index.js";
+import { noop } from "./utils/_index.js";
 
 const LEVELS = [ "log", "debug", "info", "warn", "error" ] as const;
 type TLogLevel = keyof Console & typeof LEVELS[ number ]

package/src/async/_index.ts

@@ -0,0 +1,7 @@
+
+export * from './CancelableDeferred.ts';
+export * from './Deferred.ts';
+export * from './RateThrottler.ts';
+export * from './Semaphore.ts';
+
+

package/src/index.ts

@@ -1,10 +1,10 @@
 
-export * from './async/index.js';
-export * from './lazy/index.js';
+export * from './async/_index.js';
+export * from './lazy/_index.js';
 export * from './Logger.js';
 export * from './Optional.js';
-export * from './sorting/index.js';
-export * from './time/index.js';
-export * from './upgrade/index.js';
-export * from './utils/index.js';
+export * from './sorting/_index.js';
+export * from './time/_index.js';
+export * from './upgrade/_index.js';
+export * from './utils/_index.js';
 

package/src/lazy/Lazy.ts

@@ -1,5 +1,5 @@
 
-import { ensureDefined } from "../utils";
+import { ensureDefined } from "../utils/_index";
 
 /**
  * Class that stores a value that is computationally/memory intensive to initialize.

package/src/sorting/ComparisonChain.ts

@@ -1,5 +1,5 @@
+import { TFunction, TKeysOfType, TReadableArray, isDefined, isNullOrUndefined } from "../utils/_index.js";
 import { identity } from "../utils/functions/constant.js";
-import { TFunction, TKeysOfType, TReadableArray, isDefined, isNullOrUndefined } from "../utils/index.js";
 import { TComparisonDirection, TComparisonFunction, TComparisonResult } from "./types.js";
 
 type TCompareValueOptions = {

package/src/sorting/Sorter.ts

@@ -1,5 +1,5 @@
+import { TBiFunction, TConditionalParameterOptions, TFunction, TKeysOfType, TPositiveNumber, TReadableArray, isDefined, isNullOrUndefined } from "../utils/_index.js";
 import { identity } from "../utils/functions/constant.js";
-import { TBiFunction, TConditionalParameterOptions, TFunction, TKeysOfType, TPositiveNumber, TReadableArray, isDefined, isNullOrUndefined } from "../utils/index.js";
 import { TComparisonDirection, TComparisonFunction, TComparisonResult, TStrictComparisonResult } from "./types.js";
 
 type TCompareValuesOptions = {

package/src/time/TimeDuration.ts

@@ -1,6 +1,6 @@
 import Deferred, { DeferredCanceledError, ICancelable, ICancelablePromise } from "../async/Deferred.js";
-import { TComparisonResult } from "../sorting/index.js";
-import { TIntervalHandle, TMaybe, TTimeoutHandle, ensureNonNegativeNumber, ensurePositiveNumber, pad, randomInterval } from "../utils/index.js";
+import { TComparisonResult } from "../sorting/_index.js";
+import { TIntervalHandle, TMaybe, TTimeoutHandle, ensureNonNegativeNumber, ensurePositiveNumber, pad, randomInterval } from "../utils/_index.js";
 import TimeBase from "./TimeBase";
 import TimeInstant from "./TimeInstant";
 import TimeUnit from "./TimeUnit";

package/src/time/TimeFrequency.ts

@@ -1,4 +1,4 @@
-import { TPositiveNumber } from "../utils";
+import { TPositiveNumber } from "../utils/_index";
 import TimeDuration from "./TimeDuration";
 
 export default class TimeFrequency {

package/src/time/TimeInstant.ts

@@ -1,6 +1,6 @@
 import { format } from "small-date";
 import { ICancelable, ICancelablePromise } from "../async/Deferred.js";
-import { TComparisonResult } from "../sorting/index.js";
+import { TComparisonResult } from "../sorting/_index.js";
 import TimeBase from "./TimeBase";
 import TimeDuration from "./TimeDuration";
 import { TTimeInstantBuilder, TTimeInstantCreationParameters, createTimeInstantFromParameters, timeInstantBuilder } from "./TimeInstantBuilder.js";
@@ -178,14 +178,34 @@ export class TimeInstant extends TimeBase<TimeInstant> {
 		return new Date( this.ms + new Date().getTimezoneOffset() * 60 * 1000 );
 	}
 
+	/**
+	 * @deprecated use {@link TimeInstant#isInThePast2} instead.
+	 */
 	public get isInThePast(): boolean {
 		return this.ms < Date.now();
 	}
 
+	/**
+	 * @deprecated use {@link TimeInstant#isInTheFuture2} instead.
+	 */
 	public get isInTheFuture(): boolean {
 		return this.ms > Date.now();
 	}
 
+	/**
+	 * @returns true if the instant is in the past, false otherwise
+	 */
+	public isInThePast2(): boolean {
+		return this.ms < Date.now();
+	}
+
+	/**
+	 * @returns true if the instant is in the future, false otherwise
+	 */
+	public isInTheFuture2(): boolean {
+		return this.ms > Date.now();
+	}
+
 	public isAfter( other: TimeInstant ): boolean {
 		return this.ms > other.ms;
 	}

package/src/time/TimeRange.ts

@@ -1,4 +1,4 @@
-import { TimeDuration } from "./index.js";
+import { TimeDuration } from "./_index.js";
 import TimeInstant from "./TimeInstant.js";
 
 export class TimeRange {

package/src/time/_index.ts

@@ -0,0 +1,9 @@
+
+export { default as RandomTimeDuration } from './RandomTimeDuration.js';
+export { TPredefinedTimeDuration, TValidTimeDuration, TimeDuration, isAllowedTimeDuration } from './TimeDuration.js';
+export { default as TimeFrequency } from './TimeFrequency.js';
+export * from './TimeInstant.js';
+export * from './TimeRange.js';
+export { default as TimeUnit } from './TimeUnit.js';
+export * from './types.js';
+

package/src/time/types.ts

@@ -1,4 +1,4 @@
-import { TDigit, TDigit1_9, TNumber0_1000, TParseableInt } from "../utils";
+import { TDigit, TDigit1_9, TNumber0_1000, TParseableInt } from "../utils/_index";
 
 export type TOneDigit = `${TDigit}`;
 export type TTwoDigits = `${TDigit}${TDigit}`;

package/src/upgrade/DataUpgrader.ts

@@ -1,6 +1,5 @@
 
-import { jsonCloneDeep } from "../utils";
-import { isDefined, isNumber, isPositiveNumber, TJsonSerializable } from "../utils/index.js";
+import { isDefined, isNumber, isPositiveNumber, jsonCloneDeep, TJsonSerializable } from "../utils/_index.js";
 import { EmptyUpgradeError, UnavailableUpgradeError } from "./errors";
 import getTransitionsPath from "./getTransitionsPath";
 import { TPossibleFromVersion, TPossibleVersion, TTransitionMatrix, TUpgradable, TUpgradeFunction, TVersionMap } from "./types";

package/src/upgrade/getTransitionsPath.ts

@@ -1,5 +1,5 @@
 
-import { TMaybe } from "../utils";
+import { TMaybe } from "../utils/_index";
 import { TTransition, TTransitionMatrix, TUpgradable } from "./types";
 
 const DEBUG_ENABLED = false;

package/src/upgrade/types.ts

@@ -1,5 +1,5 @@
 
-import { TFunction, TJsonObject, TPromisable } from "../utils";
+import { TFunction, TJsonObject, TPromisable } from "../utils/_index";
 
 export type TUpgradable = TJsonObject & { $version: number };
 

package/src/utils/_index.ts

@@ -0,0 +1,16 @@
+
+export * from './arrays.js';
+export * from './booleans.js';
+export { TCssDeclarationRulesDictionary, TCssSelectorDeclarationRulesDictionary, cssDeclarationRulesDictionaryToCss } from './css.js';
+export * from './empties.js';
+export * from './errors.js';
+export * from './functions.js';
+export * from './json.js';
+export * from './nulls.js';
+export * from './numbers.js';
+export * from './primitives.js';
+export * from './promises.js';
+export * from './random.js';
+export * from './records.js';
+export * from './strings.js';
+

package/src/utils/arrays/groupBy.ts

@@ -1,5 +1,5 @@
 
-import { TFunction, TKeysOfType, TReadableArray } from "..";
+import { TFunction, TKeysOfType, TReadableArray } from "../_index";
 
 export function groupByString<V, K extends TKeysOfType<V, string>>( arr: TReadableArray<V>, field: K ): Record<V[ K ] & string, V[]> {
 	return groupByStringWith( arr, t => t[ field ] as string );

package/src/utils/arrays/indexBy.ts

@@ -1,5 +1,5 @@
 
-import { TFunction, TKeysOfType } from "..";
+import { TFunction, TKeysOfType } from "../_index";
 
 export function indexByString<V, K extends TKeysOfType<V, string>>( arr: V[], field: K ): Record<V[K] & string, V> {
 	return indexByStringWith( arr, t => t[ field ] as string );

package/src/utils/arrays.ts

@@ -1,4 +1,4 @@
-import type { TComparisonFunction } from "../sorting/index.js";
+import type { TComparisonFunction } from "../sorting/_index.js";
 import type { TAccumulator, TBiPredicate, TPredicate, TTransformer } from "./functions.js";
 import { isNullOrUndefined, type TMaybe } from "./nulls.js";
 

package/src/utils/css.ts

@@ -1,27 +1,36 @@
-import { isFunction, type TProducer } from "./index.ts";
+import { isFunction, repeat, type TProducer } from "./_index.ts";
 import { type TKeysOfType } from "./records.ts";
 
-export type TCSSRuleDeclarationKey = TKeysOfType<CSSStyleDeclaration, string> & string;
-export type TCSSVariableDeclarationKey = `--${string}`;
-export type TCSSGenericDeclarationKey = TCSSRuleDeclarationKey | TCSSVariableDeclarationKey;
-export type TCSSDeclarationRulesDictionary = Partial<Record<TCSSGenericDeclarationKey, string>>;
-// export type TCSSDeclarationProduceableRulesDictionary = Partial<Record<TCSSGenericDeclarationKey, TProduceable<string>>>;
+export type TCssRuleDeclarationKey = TKeysOfType<CSSStyleDeclaration, string> & string;
+export type TCssVariableDeclarationKey = `--${string}`;
+export type TCssGenericDeclarationKey = TCssRuleDeclarationKey | TCssVariableDeclarationKey;
+export type TCssDeclarationRulesDictionary = Partial<Record<TCssGenericDeclarationKey, string>>;
+export type TCssSelectorDeclarationRulesDictionary = {
+	[ selector: string ]: TCssDeclarationRulesDictionary | TCssSelectorDeclarationRulesDictionary;
+}
+
 type TProduceable<T> = T | TProducer<T>;
 
 const newLine = '\n', tabulation = '\t', colon = ':', semiColon = ';', space = ' ', openBracket = '{', closeBracket = '}';
 
-export function cssDeclarationRulesDictionaryToCss( syleDeclarationRulesForSelectors: Record<string, TCSSDeclarationRulesDictionary> ) {
+export function cssDeclarationRulesDictionaryToCss( syleDeclarationRulesForSelectorsProduceable: TProduceable<TCssSelectorDeclarationRulesDictionary>, indent = 0 ) {
+	const syleDeclarationRulesForSelectors = produceableToValue( syleDeclarationRulesForSelectorsProduceable );
 	return Object.entries( syleDeclarationRulesForSelectors ).map( ( [ selector, styleDeclarationRules ] ) => {
-		const cssRules = cssSelectorDeclarationRulesDictionaryToCss( styleDeclarationRules );
+		const cssRules = cssSelectorDeclarationRulesDictionaryToCss( styleDeclarationRules, indent + 1 );
 		if ( !cssRules.length ) return null;
-		return selector + space + openBracket + newLine + cssRules.map( rule => tabulation + rule + semiColon ).join( newLine ) + newLine + closeBracket;
+		return repeat( tabulation, indent ) + selector + space + openBracket + newLine + cssRules.join( newLine ) + newLine + closeBracket;
 	} ).filter( Boolean ).join( newLine + newLine );
 }
 
 /* exported for test purposes only */
-export function cssSelectorDeclarationRulesDictionaryToCss( styleDeclarationRulesProduceable: TCSSDeclarationRulesDictionary ): string[] {
-	const styleDeclarationRules = produceableToValue( styleDeclarationRulesProduceable );
-	return Object.entries( styleDeclarationRules ).map( ( [ key, value ] ) => pascalCaseToKebabCase(key) + colon + space + produceableToValue( value ) );
+export function cssSelectorDeclarationRulesDictionaryToCss( styleDeclarationRules: TCssDeclarationRulesDictionary | TCssSelectorDeclarationRulesDictionary, indent = 0 ): string[] {
+	return Object.entries( styleDeclarationRules ).map( ( [ key, value ]: [ string, string | TCssSelectorDeclarationRulesDictionary ] ) => {
+		if ( typeof value === 'string' ) {
+			return repeat( tabulation, indent ) + pascalCaseToKebabCase( key ) + colon + space + value + semiColon;
+		} else {
+			return repeat( tabulation, indent ) + key + space + openBracket + newLine + cssSelectorDeclarationRulesDictionaryToCss( value, indent + 1 ).join( newLine ) + newLine + repeat( tabulation, indent ) + closeBracket;
+		}
+	} );
 }
 
 function pascalCaseToKebabCase( s: string ) {

package/src/utils/functions/constant.ts

@@ -5,6 +5,7 @@ export default constant;
 export const constantNull = constant( null );
 export const constantTrue = constant( true );
 export const constantFalse = constant( false );
+export const constantUndefined = constant( void 0 );
 export const alwaysTrue = constantTrue;
 export const alwaysFalse = constantFalse;
 export const constantZero = constant( 0 );

package/src/utils/functions/iff.ts

@@ -1,4 +1,4 @@
-import { TPredicate } from "..";
+import { TPredicate } from "../_index";
 
 type TBooleanOrPredicate = boolean | TPredicate<void>;
 type TIff<T> = {

package/src/utils/functions.ts

@@ -1,3 +1,4 @@
+import { identity } from './_index.js';
 import { constantTrue } from './functions.js';
 
 export * from './functions/constant.js';
@@ -61,4 +62,28 @@ export function xor<T>( a: TPredicate<T>, b: TPredicate<T> ): TPredicate<T> {
 	return ( t: T ) => a( t ) !== b( t );
 }
 
+export function pipedInvoke<T, A>( op1: TFunction<T, A> ): TFunction<T, A>;
+export function pipedInvoke<T, A, B>( op1: TFunction<T, A>, op2: TFunction<A, B> ): TFunction<T, B>;
+export function pipedInvoke<T, A, B, C>( op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C> ): TFunction<T, C>;
+export function pipedInvoke<T, A, B, C, D>( op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D> ): TFunction<T, D>;
+export function pipedInvoke<T, A, B, C, D, E>( op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E> ): TFunction<T, E>;
+export function pipedInvoke<T, A, B, C, D, E, F>( op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>, op6: TFunction<E, F> ): TFunction<T, F>;
+export function pipedInvoke<T, A, B, C, D, E, F, G>( op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>, op6: TFunction<E, F>, op7: TFunction<F, G> ): TFunction<T, G>;
+export function pipedInvoke<T, A, B, C, D, E, F, G, H>( op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>, op6: TFunction<E, F>, op7: TFunction<F, G>, op8: TFunction<G, H> ): TFunction<T, H>;
+export function pipedInvoke<T, A, B, C, D, E, F, G, H, I>( op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>, op6: TFunction<E, F>, op7: TFunction<F, G>, op8: TFunction<G, H>, op9: TFunction<H, I> ): TFunction<T, I>;
+export function pipedInvoke<T, A, B, C, D, E, F, G, H, I>( op1: TFunction<T, A>, op2: TFunction<A, B>, op3: TFunction<B, C>, op4: TFunction<C, D>, op5: TFunction<D, E>, op6: TFunction<E, F>, op7: TFunction<F, G>, op8: TFunction<G, H>, op9: TFunction<H, I>, ...operations: TFunction<any, any>[] ): TFunction<T, unknown>;
+export function pipedInvoke( ...fns: Array<TFunction<any, any>>): TFunction<any, any> { return pipedInvokeFromArray( fns ) }
 
+export function pipedInvokeFromArray<T, R>( fns: Array<TFunction<any, any>>): TFunction<any, any> {
+	if ( fns.length === 0 ) {
+		return identity as TFunction<any, any>;
+	}
+
+	if ( fns.length === 1 ) {
+		return fns[ 0 ];
+	}
+
+	return function piped( input: T ): R {
+		return fns.reduce( ( prev: any, fn: TFunction<T, R> ) => fn( prev ), input as any );
+	};
+}

package/src/utils/numbers.ts

@@ -94,6 +94,9 @@ export function clamp( n: number, min: number, max: number ): number {
 		return n;
 	}
 }
+export function clampInt0_100( n: number ) {
+	return clamp( Math.round( n ), 0, 100 ) as TNumber0_100;
+}
 
 export function tryToParseNumber( numberStr: string ) {
 	return withTryCatch( () => {

package/src/utils/promises.ts

@@ -33,5 +33,6 @@ export async function awaitAtMost<T>( p: Promise<T>, t: TimeDuration ): Promise<
 			return value;
 		throw new TimeoutError();
 	} );
-
 }
+
+export const NEVER = new Promise( _resolve => { /* never end */ } );

package/src/utils/records/entries.ts

@@ -1,4 +1,4 @@
-import { TFunction } from "..";
+import { TFunction } from "../_index";
 
 export function dictToEntries<V, K extends string = string>( obj: Record<K, V> ): [K, V][] {
 	return Object.entries( obj ) as [K, V][];

package/src/async/index.ts

@@ -1,7 +0,0 @@
-
-export * from './CancelableDeferred.ts';
-export * from './Deferred';
-export * from './RateThrottler';
-export * from './Semaphore';
-
-

package/src/time/index.ts

@@ -1,9 +0,0 @@
-
-export { default as RandomTimeDuration } from './RandomTimeDuration';
-export { TPredefinedTimeDuration, TValidTimeDuration, TimeDuration, isAllowedTimeDuration } from './TimeDuration';
-export { default as TimeFrequency } from './TimeFrequency';
-export * from './TimeInstant';
-export * from './TimeRange.js';
-export { default as TimeUnit } from './TimeUnit';
-export * from './types';
-