@zelgadis87/utils-core 4.6.2 → 4.8.0

package/package.json

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

package/src/Optional.ts

@@ -12,17 +12,21 @@ export class Optional<T> implements TOptional<T> {
 		this._present = defined;
 	}
 
-	public get rawValue() {
+	public getRawValue(): T | undefined {
 		return this._value;
 	}
 
-	public get(): T | never {
+	public get(): T {
+		return this.getOrElseThrow( () => new ErrorGetEmptyOptional() );
+	}
+
+	public getOrElseThrow( errorProducer: TProducer<Error> ): T {
 		if ( this.isEmpty() )
-			throw new ErrorGetEmptyOptional();
-		return this.rawValue as T;
+			throw errorProducer();
+		return this._value!;
 	}
 
-	public set(t: T) {
+	public set( t: T ) {
 		if ( isNullOrUndefined( t ) )
 			throw new ErrorSetEmptyOptional();
 		this._value = t;
@@ -47,13 +51,13 @@ export class Optional<T> implements TOptional<T> {
 	}
 	public ifPresent( callback: TConsumer<T> ) {
 		if ( this.isPresent() )
-			callback( this.rawValue );
+			callback( this.get() );
 	}
 	public apply( callbackIfPresent: TConsumer<T>, callbackIfEmpty: TVoidFunction ) {
 		if ( this.isEmpty() ) {
 			callbackIfEmpty();
 		} else {
-			callbackIfPresent( this.rawValue! );
+			callbackIfPresent( this.get() );
 		}
 	}
 
@@ -69,9 +73,9 @@ export class Optional<T> implements TOptional<T> {
 		}
 		return this as TPresentOptional<T>;
 	}
-	public orElseThrow( produceError: TProducer<Error> ) {
+	public orElseThrow( errorProducer: TProducer<Error> ) {
 		if ( this.isEmpty() )
-			throw produceError();
+			throw errorProducer();
 		return this as TPresentOptional<T>;
 	}
 
@@ -79,23 +83,15 @@ export class Optional<T> implements TOptional<T> {
 		return this.flatMapTo( t => Optional.ofNullable( mapper( t ) ) );
 	}
 	public flatMapTo<R>( mapper: TFunction<T, TOptional<R>> ) {
-		if ( this.isPresent() ) {
-			const newValue = mapper( this.rawValue );
-			return newValue;
-		}
-		return this as TEmptyOptional<T>;
+		return this.isPresent() ? mapper( this.get() ) : Optional.empty<R>();
 	}
 
 	public filter( predicate: TPredicate<T> ): this | TEmptyOptional<T> {
-		if ( this.isPresent() ) {
-			if ( predicate( this.rawValue ) ) {
-				return this;
-			} else {
-				return Optional.empty();
-			}
-		} else {
+		if ( this.isEmpty() )
 			return this;
-		}
+		if ( predicate( this.get() ) )
+			return this;
+		return Optional.empty();
 	}
 
 	public static empty<T>(): TEmptyOptional<T> {
@@ -114,19 +110,26 @@ export class Optional<T> implements TOptional<T> {
 export default Optional;
 
 export type TOptional<T> = {
-	readonly rawValue: T | undefined;
 
 	/**
-	 * @returns the currently stored value, if any; throws {@link ErrorGetEmptyOptional} otherwise;
-	 */
-	get(): T | never;
+		* @returns the currently stored value, if any; throws {@link ErrorGetEmptyOptional} otherwise;
+		*/
+	get(): T;
+	/**
+		* @returns the currently stored value, if any; returns undefined otherwise;
+		*/
+	getRawValue(): T | undefined;
+	/**
+		* @returns the currently stored value, if any; throws the error generated by errorProducer otherwise;
+		*/
+	getOrElseThrow: ( errorProducer: TProducer<Error> ) => T;
 	/**
-	 * Places a new value inside this optional. Throws {@link ErrorSetEmptyOptional} if t is null or undefined.
-	 */
-	set(t: T): void;
+		* Places a new value inside this optional. Throws {@link ErrorSetEmptyOptional} if t is null or undefined.
+		*/
+	set( t: T ): void;
 	/**
-	 * Clears the current value from this optional, if any.
-	 */
+		* Clears the current value from this optional, if any.
+		*/
 	clear(): void;
 	isEmpty(): boolean;
 	isPresent(): boolean;
@@ -135,9 +138,9 @@ export type TOptional<T> = {
 	ifPresent: ( callback: TConsumer<T> ) => void;
 	apply( callbackIfPresent: TConsumer<T>, callbackIfEmpty: TVoidFunction ): void;
 
-	orElse: ( ( newValue: T | null | undefined ) => TOptional<T> );
+	orElse: ( newValue: T | null | undefined ) => TOptional<T>;
 	orElseGet: ( produceValue: TProducer<T | null | undefined> ) => TOptional<T>;
-	orElseThrow: ( produceError: TProducer<Error> ) => TPresentOptional<T>;
+	orElseThrow: ( errorProducer: TProducer<Error> ) => TPresentOptional<T>;
 
 	mapTo<R>( mapper: TFunction<T, R> ): TOptional<R>;
 	flatMapTo<R>( mapper: TFunction<T, TOptional<R>> ): TOptional<R>;
@@ -145,19 +148,19 @@ export type TOptional<T> = {
 	filter( predicate: TPredicate<T> ): TOptional<T>;
 }
 export type TEmptyOptional<T> = TOptional<T> & {
-	readonly rawValue: undefined;
+	get(): never;
 	isEmpty(): true;
 	isPresent(): false;
 }
 export type TPresentOptional<T> = TOptional<T> & {
-	readonly rawValue: T;
+	get(): T;
 	isEmpty(): false;
 	isPresent(): true;
 }
 
 export class ErrorGetEmptyOptional extends Error {
 	constructor() {
-		super( "Cannot retrieve a value from an EmptyOptional." );
+		super( "Cannot retrieve a value from an empty Optional." );
 	}
 }
 export class ErrorSetEmptyOptional extends Error {

package/src/utils/css.ts

@@ -0,0 +1,33 @@
+import { isFunction, 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>>>;
+type TProduceable<T> = T | TProducer<T>;
+
+const newLine = '\n', tabulation = '\t', colon = ':', semiColon = ';', space = ' ', openBracket = '{', closeBracket = '}';
+
+export function cssDeclarationRulesDictionaryToCss( syleDeclarationRulesForSelectors: Record<string, TCSSDeclarationRulesDictionary> ) {
+	return Object.entries( syleDeclarationRulesForSelectors ).map( ( [ selector, styleDeclarationRules ] ) => {
+		const cssRules = cssSelectorDeclarationRulesDictionaryToCss( styleDeclarationRules );
+		if ( !cssRules.length ) return null;
+		return selector + space + openBracket + newLine + cssRules.map( rule => tabulation + rule + semiColon ).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 ) );
+}
+
+function pascalCaseToKebabCase( s: string ) {
+	return s.split( /([A-Z][a-z]*)/ ).filter( Boolean ).map( n => n.toLowerCase() ).join( '-' );
+}
+
+function produceableToValue<T>( t: TProduceable<T> ): T {
+	return isFunction( t ) ? t() : t;
+}

package/src/utils/index.ts

@@ -1,6 +1,7 @@
 
 export * from './arrays.js';
 export * from './booleans.js';
+export { TCSSDeclarationRulesDictionary, cssDeclarationRulesDictionaryToCss } from './css.js';
 export * from './empties.js';
 export * from './errors.js';
 export * from './functions.js';

package/src/utils/strings/StringParts.ts

@@ -111,4 +111,15 @@ export class StringParts {
 		return new StringParts( ...parts );
 	};
 
+	/**
+	 * Tries to convert a word in PascalCase to an array of words. Will not work if there are spaces or special characters. Does not cope well on uppercase abbreviations (eg, "CSS").
+	 * @param s a string in PascalCase. 
+	 * @returns a StringParts where each sub-word in PascalCase is now a part.
+	 */
+	public static tryToParsePascalCaseWord( s: string ): StringParts {
+		return new StringParts( ...s.split( /([A-Z][a-z]*)/ ).filter( Boolean ).map( n => n.toLowerCase() ) );
+	}
+
 }
+
+