@zelgadis87/utils-core 5.1.4 → 5.2.0

package/package.json

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

package/src/Logger.ts

@@ -1,7 +1,7 @@
 import TimeInstant from "./time/TimeInstant";
 import { noop, padRight } from "./utils/_index.js";
 
-const LEVELS = [ "log", "debug", "info", "warn", "error" ] as const;
+const LEVELS = [ "trace", "log", "debug", "info", "warn", "error" ] as const;
 type TLogLevel = keyof Console & typeof LEVELS[ number ]
 
 const timestamp = () => TimeInstant.now().format( 'HH:mm:ss' );
@@ -27,6 +27,7 @@ export class Logger {
 		this.minLevel = LEVELS.indexOf( ( args?.minLevel ?? "DEBUG" ).toLowerCase() as TLogLevel );
 	}
 
+	public get trace() { return this.logWrap( 'trace' ); }
 	public get log() { return this.logWrap( 'log' ); }
 	public get debug() { return this.logWrap( 'debug' ); }
 	public get info() { return this.logWrap( 'info' ); }

package/src/Optional.ts

@@ -60,6 +60,12 @@ export class Optional<T> implements TOptional<T> {
 		if ( this.isPresent() )
 			callback( this.get() );
 	}
+	public ifPresentThenClear( callback: TConsumer<T> ) {
+		if ( this.isPresent() ) {
+			callback( this.get() );
+			this.clear();
+		}
+	}
 	public apply( callbackIfPresent: TConsumer<T>, callbackIfEmpty: TVoidFunction ) {
 		if ( this.isEmpty() ) {
 			callbackIfEmpty();

package/src/utils/errors/withTryCatch.ts

@@ -2,14 +2,18 @@
 import { asError } from "../errors.js";
 import { identity, type TFunction, type TTransformer } from "../functions.js";
 
-export function withTryCatch<R>( fn: TFunction<void, R>, errMapFn?: TTransformer<Error, Error> ): [ R, undefined ] | [ undefined, Error ] {
+export function withTryCatch<R>( fn: TFunction<void, R>, errMapFn: TTransformer<Error, Error> = identity ): [ R, undefined ] | [ undefined, Error ] {
 	try {
 		return [ fn(), void 0 ] as const;
 	} catch ( e: unknown ) {
-		return [ void 0, ( errMapFn ?? identity )( asError( e ) ) ] as const;
+		return [ void 0, errMapFn( asError( e ) ) ] as const;
 	}
 }
 
-export async function withTryCatchAsync<R>( fn: TFunction<void, Promise<R>>, errMapFn: TTransformer<Error, Error> ): Promise<[ R, undefined ] | [ undefined, Error ]> {
-	return fn().then( ( value: R ) => [ value, void 0 ] as const, ( e: unknown ) => [ void 0, ( errMapFn ?? identity )( asError( e ) ) ] as const );
+export async function withTryCatchAsync<R>( fn: TFunction<void, Promise<R>>, errMapFn: TTransformer<Error, Error> = identity ): Promise<[ R, undefined ] | [ undefined, Error ]> {
+	try {
+		return [ await fn(), void 0 ] as const;
+	} catch ( e: unknown ) {
+		return [ void 0, errMapFn( asError( e ) ) ] as const;
+	}
 }

package/src/utils/errors.ts

@@ -1,3 +1,4 @@
+import { isNullOrUndefined } from './nulls.js';
 
 export * from './errors/withTryCatch.js';
 
@@ -18,15 +19,23 @@ export function isError( e: unknown ): e is 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}`;
+	return `${error.name}: ${error.message}${getCauseMessageFromError( error.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}`;
+	return `${error.name}: ${stack}${getCauseStackFromError( error.cause )}`;
+}
+
+export function getCauseMessageFromError( cause: unknown ) {
+	if ( isNullOrUndefined( cause ) )
+		return '';
+	return `\ncaused by: ${getMessageFromError( asError( cause ) )}`
+}
+
+export function getCauseStackFromError( cause: unknown ) {
+	if ( isNullOrUndefined( cause ) )
+		return '';
+	return `\ncaused by: ${getStackFromError( asError( cause ) )}`
 }
 

package/src/utils/json.ts

@@ -6,7 +6,15 @@ export type TJsonObject = { [ key: string ]: TJsonSerializable }
 export type TJsonSerializable = TJsonPrimitive | TJsonArray | TJsonObject;
 
 export function tryToParseJson<T extends TJsonSerializable>( jsonContent: string ): [ T, undefined ] | [ undefined, Error ] {
-	return withTryCatch( () => JSON.parse( jsonContent ) as T );
+	return withTryCatch( () => parseJson<T>( jsonContent ) );
+}
+
+export function parseJson<T extends TJsonSerializable>( jsonContent: string ): T {
+	return JSON.parse( jsonContent ) as T;
+}
+
+export function stringifyJson( jsonSerializable: TJsonSerializable, minify = false ): string {
+	return JSON.stringify( jsonSerializable, undefined, minify ? undefined : 2 );
 }
 
 export function jsonCloneDeep<A extends TJsonSerializable>( a: A ): A {

package/src/utils/strings.ts

@@ -1,5 +1,5 @@
 import { range } from "./arrays.js";
-import { ensureDefined, isNullOrUndefined, TMaybe } from "./nulls.js";
+import { ensureDefined, isDefined, isNullOrUndefined, TMaybe } from "./nulls.js";
 
 export * from './strings/StringParts.js';
 
@@ -81,8 +81,16 @@ export function pluralize( n: number, singular: string, plural?: string ): strin
 
 }
 
+export function isString( source: unknown ): source is string {
+	return isDefined( source ) && typeof source === "string";
+}
+
+export function isEmpty( source: string ): boolean {
+	return source.trim().length === 0;
+}
+
 export function isNullOrUndefinedOrEmpty( source: TMaybe<string> ): boolean {
-	return isNullOrUndefined( source ) || source.length === 0;
+	return isNullOrUndefined( source ) || isEmpty( source );
 }