@zelgadis87/utils-core 5.0.1 → 5.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@zelgadis87/utils-core",
-  "version": "5.0.1",
+  "version": "5.0.3",
   "author": "Zelgadis87",
   "license": "ISC",
   "private": false,
@@ -22,15 +22,15 @@
     "@stylistic/eslint-plugin-ts": "4.2.0",
     "@typescript-eslint/eslint-plugin": "8.26.1",
     "@typescript-eslint/parser": "8.26.1",
-    "@vitest/coverage-v8": "3.0.8",
-    "@vitest/ui": "3.0.8",
-    "esbuild": "0.19.2",
+    "@vitest/coverage-v8": "3.2.4",
+    "@vitest/ui": "3.2.4",
+    "esbuild": "0.25.8",
     "eslint": "9.22.0",
-    "nx": "21.1.2",
+    "nx": "21.3.5",
     "rimraf": "6.0.1",
-    "typescript": "5.8.2",
+    "typescript": "5.8.3",
     "typescript-eslint": "8.26.1",
-    "vitest": "3.0.8"
+    "vitest": "3.2.4"
   },
   "dependencies": {
     "small-date": "^2.0.1"

package/src/time/RandomTimeDuration.ts

@@ -1,6 +1,6 @@
 import { randomNumberInInterval } from "../utils/random.js";
 import TimeDuration from "./TimeDuration.js";
-import TimeUnit from "./TimeUnit.js";
+import { TimeUnit } from "./TimeUnit.js";
 
 function randomize( unit: TimeUnit ) {
 	return ( a: number, b: number ) => {

package/src/time/TimeBase.ts

@@ -1,4 +1,12 @@
-import TimeUnit from "./TimeUnit";
+import { TimeUnit } from "./TimeUnit";
+
+export type TTimeInUnits = {
+	milliseconds: number;
+	seconds: number;
+	minutes: number;
+	hours: number;
+	days: number;
+}
 
 export default abstract class TimeBase<T> {
 
@@ -13,22 +21,37 @@ export default abstract class TimeBase<T> {
 
 	protected abstract create( value: number, unit: TimeUnit ): T;
 
+	/**
+	 * Total number of milliseconds, rounded down.
+	 */
 	public get ms(): number {
 		return Math.floor( this._ms / TimeUnit.MILLISECONDS.multiplier );
 	}
 
+	/**
+	 * Total number of seconds, rounded down.
+	 */
 	public get seconds(): number {
 		return Math.floor( this._ms / TimeUnit.SECONDS.multiplier );
 	}
 
+	/**
+	 * Total number of minutes, rounded down.
+	 */
 	public get minutes(): number {
 		return Math.floor( this._ms / TimeUnit.MINUTES.multiplier );
 	}
 
+	/**
+	 * Total number of hours, rounded down.
+	 */
 	public get hours(): number {
 		return Math.floor( this._ms / TimeUnit.HOURS.multiplier );
 	}
 
+	/**
+	 * Total number of days, rounded down.
+	 */
 	public get days(): number {
 		return Math.floor( this._ms / TimeUnit.DAYS.multiplier );
 	}
@@ -85,20 +108,21 @@ export default abstract class TimeBase<T> {
 		return this._ms / unit.multiplier;
 	}
 
-	protected toUnits(): { days: number, hours: number, minutes: number, seconds: number } {
+	protected toUnits(): TTimeInUnits {
 		return {
-			days: Math.floor( ( this._ms / TimeUnit.DAYS.multiplier ) ),
-			hours: Math.floor( ( this._ms / TimeUnit.HOURS.multiplier ) % 24 ),
-			minutes: Math.floor( ( this._ms / TimeUnit.MINUTES.multiplier ) % 60 ),
-			seconds: Math.floor( ( this._ms / TimeUnit.SECONDS.multiplier ) % 60 ),
+			milliseconds: this.ms % TimeUnit.SECONDS.multiplier,
+			seconds: Math.floor( this.seconds % 60 ),
+			minutes: Math.floor( this.minutes % 60 ),
+			hours: Math.floor( this.hours % 24 ),
+			days: Math.floor( this.days ),
 		};
 	}
 
-	protected static toMs( units: { days?: number, hours?: number, minutes?: number, seconds?: number, ms?: number } ): number {
+	protected static unitsToMs( units: Partial<TTimeInUnits> ): number {
 		if ( !units )
 			throw new Error( 'Invalid units given' );
 		let ms = 0
-		ms += units.ms ?? 0 * TimeUnit.MILLISECONDS.multiplier;
+		ms += ( units.milliseconds ?? 0 ) * TimeUnit.MILLISECONDS.multiplier;
 		ms += ( units.seconds ?? 0 ) * TimeUnit.SECONDS.multiplier;
 		ms += ( units.minutes ?? 0 ) * TimeUnit.MINUTES.multiplier;
 		ms += ( units.hours ?? 0 ) * TimeUnit.HOURS.multiplier;

package/src/time/TimeDuration.ts

@@ -1,9 +1,9 @@
 import Deferred, { DeferredCanceledError, ICancelable, ICancelablePromise } from "../async/Deferred.js";
 import { TComparisonResult } from "../sorting/_index.js";
 import { TIntervalHandle, TMaybe, TTimeoutHandle, ensureNonNegativeNumber, ensurePositiveNumber, pad } from "../utils/_index.js";
-import TimeBase from "./TimeBase";
+import TimeBase, { type TTimeInUnits } from "./TimeBase";
 import TimeInstant from "./TimeInstant";
-import TimeUnit from "./TimeUnit";
+import { TimeUnit } from "./TimeUnit";
 
 export class TimeDuration extends TimeBase<TimeDuration> {
 
@@ -183,6 +183,10 @@ export class TimeDuration extends TimeBase<TimeDuration> {
 		return this.ms > 0;
 	}
 
+	public override toUnits() {
+		return super.toUnits();
+	}
+
 	/**
 		* This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
 		*/
@@ -198,7 +202,7 @@ export class TimeDuration extends TimeBase<TimeDuration> {
 		const match = humanTime.trim().match( /^(?:([0-9]+)d|)\s*(?:([0-9]+)h|)\s*(?:([0-9]+)m|)\s*(?:([0-9]+)s|)$/ );
 		if ( match ) {
 			const [ _, days, hours, minutes, seconds ] = match;
-			return new TimeDuration( TimeBase.toMs( { days: Number( days ?? 0 ), hours: Number( hours ?? 0 ), minutes: Number( minutes ?? 0 ), seconds: Number( seconds ?? 0 ) } ), TimeUnit.MILLISECONDS );
+			return new TimeDuration( TimeBase.unitsToMs( { days: Number( days ?? 0 ), hours: Number( hours ?? 0 ), minutes: Number( minutes ?? 0 ), seconds: Number( seconds ?? 0 ) } ), TimeUnit.MILLISECONDS );
 		}
 		throw new Error( 'Failed to parse time: ' + humanTime );
 	}
@@ -263,6 +267,10 @@ export class TimeDuration extends TimeBase<TimeDuration> {
 		return TimeDuration.ms( ms );
 	}
 
+	public static fromUnits( parameters: Partial<TTimeInUnits> ): TimeDuration {
+		return TimeDuration.ms( TimeBase.unitsToMs( parameters ) );
+	}
+
 }
 
 export type TPredefinedTimeDuration = 0 | 50 | 100 | 150 | 200 | 250 | 300 | 500 | 1000 | 1500 | 2000 | 2500 | 5000;

package/src/time/TimeInstant.ts

@@ -4,7 +4,7 @@ import { TComparisonResult } from "../sorting/_index.js";
 import TimeBase from "./TimeBase";
 import TimeDuration from "./TimeDuration";
 import { TTimeInstantBuilder, TTimeInstantCreationParameters, createTimeInstantFromParameters, timeInstantBuilder } from "./TimeInstantBuilder.js";
-import TimeUnit from "./TimeUnit";
+import { TimeUnit } from "./TimeUnit";
 import { TDayOfMonth, TDayOfWeek, TIso8601DateString, TIso8601DateUtcString, TMonth, TWeekNumber } from "./types";
 
 export class TimeInstant extends TimeBase<TimeInstant> {

package/src/time/TimeUnit.ts

@@ -1,5 +1,5 @@
 
-export default class TimeUnit {
+export class TimeUnit {
 
 	private constructor(
 		public readonly multiplier: number
@@ -29,15 +29,10 @@ export default class TimeUnit {
 		return this.toUnit( value, TimeUnit.DAYS );
 	}
 
-	public toWeeks( value: number ): number {
-		return this.toUnit( value, TimeUnit.WEEKS );
-	}
-
 	public static readonly MILLISECONDS = new TimeUnit( 1 );
 	public static readonly SECONDS = new TimeUnit( 1000 * TimeUnit.MILLISECONDS.multiplier );
 	public static readonly MINUTES = new TimeUnit( 60 * TimeUnit.SECONDS.multiplier );
 	public static readonly HOURS = new TimeUnit( 60 * TimeUnit.MINUTES.multiplier );
 	public static readonly DAYS = new TimeUnit( 24 * TimeUnit.HOURS.multiplier );
-	public static readonly WEEKS = new TimeUnit( 7 * TimeUnit.DAYS.multiplier );
 
 }

package/src/time/_index.ts

@@ -1,9 +1,10 @@
 
 export { default as RandomTimeDuration } from './RandomTimeDuration.js';
-export { TPredefinedTimeDuration, TValidTimeDuration, TimeDuration, isAllowedTimeDuration } from './TimeDuration.js';
+export * from './TimeBase.js';
+export { isAllowedTimeDuration, TimeDuration, TPredefinedTimeDuration, TValidTimeDuration } 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 './TimeUnit.js';
 export * from './types.js';
 

package/src/utils/errors.ts

@@ -17,3 +17,16 @@ export function isError( e: unknown ): e is Error {
 	return e instanceof Error;
 }
 
+export function getMessageFromError( error: Error ): string {
+	const maybeCause = error.cause ? getMessageFromError( asError( error.cause ) ) : null;
+	const cause = maybeCause ? `\ncaused by: ${maybeCause}` : '';
+	return `${error.name}: ${error.message}${cause}`;
+}
+
+export function getStackFromError( error: Error ): string {
+	const maybeCause = error.cause ? getStackFromError( asError( error.cause ) ) : null;
+	const cause = maybeCause ? `\ncaused by: ${maybeCause}` : '';
+	const stack = error.stack && error.stack.includes( error.message ) ? error.stack : error.message + ' ' + ( error.stack ?? '' );
+	return `${error.name}: ${stack}${cause}`;
+}
+

package/src/utils/functions/_index.ts

@@ -0,0 +1,4 @@
+export * from './constant.js';
+export * from './iff.js';
+export * from './predicateBuilder.js';
+

package/src/utils/functions/predicateBuilder.ts

@@ -0,0 +1,25 @@
+
+import { constantTrue, type TPredicate } from "../functions.ts";
+
+export class PredicateBuilder<T> {
+
+	private _currentPredicate: TPredicate<T> = constantTrue;
+
+	public and( predicate: TPredicate<T> ) {
+		const curPredicate = this._currentPredicate.bind( undefined );
+		const newPredicate = ( t: T ) => curPredicate( t ) && predicate( t );
+		this._currentPredicate = newPredicate;
+		return this;
+	}
+
+	public or( predicate: TPredicate<T> ) {
+		const newPredicate = ( t: T ) => this._currentPredicate( t ) || predicate( t );
+		this._currentPredicate = newPredicate;
+		return this;
+	}
+
+	public toPredicate() {
+		return this._currentPredicate;
+	}
+
+}

package/src/utils/functions.ts

@@ -1,8 +1,5 @@
-import { identity } from './_index.js';
-import { constantTrue } from './functions.js';
-
-export * from './functions/constant.js';
-export * from './functions/iff.js';
+import { constantTrue, identity } from './functions/constant.js';
+export * from './functions/_index.js';
 
 export type TFunction<A, R> = ( a: A ) => R;
 export type TTransformer<A, R> = TFunction<A, R>;

package/src/utils/records.ts

@@ -38,3 +38,13 @@ export type TWithRequiredProperty<T, K extends keyof T> = T & {
  * Given a type T, make all fields required instead of optional.
  */
 export type TWithRequiredProperties<T> = Required<T>;
+
+/**
+ * Type that forces a record to contain a few properties, but allows for extraneous properties.
+ */
+export type TWithExtras<R extends Record<any, any>, T extends Record<any, any> = Record<string, unknown>> = R & T;
+
+/**
+ * Types that improves the human readability of a Typescript type.
+ */
+export type TPrettify<T> = { [ K in keyof T ]: T[ K ]; } & {};