@zelgadis87/utils-core 5.3.3 → 5.3.4

package/src/time/TimeInstant.ts

@@ -4,7 +4,7 @@ import TimeBase from "./TimeBase";
 import TimeDuration from "./TimeDuration";
 import { TTimeInstantBuilder, TTimeInstantCreationParameters, createTimeInstantFromParameters, timeInstantBuilder, type TTimeInstantParameters } from "./TimeInstantBuilder.js";
 import { TimeUnit } from "./TimeUnit";
-import { TDayOfMonth, TDayOfWeek, THourOfDay, TIso8601DateString, TIso8601DateUtcString, TMillisecondOfSecond, TMinuteOfHour, TMonth, TSecondOfMinute, TWeekNumber, type TFourDigitsYear, type TYear } from "./types";
+import { TDayOfMonth, THourOfDay, TIso8601DateUtcString, TMillisecondOfSecond, TMinuteOfHour, TMonth, TSecondOfMinute, TWeekNumber, type TYear } from "./types";
 
 export class TimeInstant extends TimeBase<TimeInstant> {
 
@@ -287,8 +287,8 @@ export class TimeInstant extends TimeBase<TimeInstant> {
 	}
 
 	public static fromIso8601( str: string ) {
-		// Regex to capture: YYYY-MM-DDTHH:mm:ss.sssZ or YYYY-MM-DDTHH:mm:ss.sss±HH:mm
-		const iso8601Regex = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})(Z|[+-]\d{2}:\d{2})?$/;
+		// Regex to capture: YYYY-MM-DDTHH:mm:ss[.sss]Z or YYYY-MM-DDTHH:mm:ss[.sss]±HH:mm
+		const iso8601Regex = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{3})|)(Z|[+-]\d{2}:\d{2})?$/;
 		const match = str.match( iso8601Regex );
 
 		if ( !match ) {
@@ -304,7 +304,7 @@ export class TimeInstant extends TimeBase<TimeInstant> {
 		const hours = parseInt( hourStr, 10 );
 		const minutes = parseInt( minuteStr, 10 );
 		const seconds = parseInt( secondStr, 10 );
-		const milliseconds = parseInt( millisecondStr, 10 );
+		const milliseconds = millisecondStr ? parseInt( millisecondStr, 10 ) : 0;
 
 		// Validate each component using standalone validation functions
 		if ( !isValidYear( year ) )
@@ -641,7 +641,7 @@ function parseTimeInstant( dateString: string, pattern: string, base: TimeInstan
 	return TimeInstant.fromParameters( params );
 }
 
-function parseTimeInstantComponents( dateString: string, pattern: string, config: { locale?: string, timeZone?: string } = {} ): Partial<TTimeInstantParameters> {
+export function parseTimeInstantComponents( dateString: string, pattern: string, config: { locale?: string, timeZone?: string } = {} ): Partial<TTimeInstantParameters> {
 	// Create a regex pattern from the format pattern
 	let regexPattern = pattern;
 	const tokens: { type: string; length: number; position: number }[] = [];
@@ -663,39 +663,39 @@ function parseTimeInstantComponents( dateString: string, pattern: string, config
 
 			// Create appropriate regex for each token type
 			switch ( type ) {
-			case 'y':
-				return match.length === 2 ? '(\\d{2})' : '(\\d{4})';
-			case 'M':
-				if ( match.length === 1 ) return '(\\d{1,2})';
-				if ( match.length === 2 ) return '(\\d{2})';
-				if ( match.length === 3 ) return '([A-Za-z.]{1,7})';
-				return '([A-Za-z]+)';
-			case 'd':
-				return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
-			case 'H':
-			case 'h':
-				return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
-			case 'm':
-			case 's':
-				return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
-			case 'S':
-				return `(\\d{${match.length}})`;
-			case 'a':
-				return '([aApP][mM])';
-			case 'D':
-				if ( match.length === 1 ) return '([A-Za-z])';
-				if ( match.length === 2 ) return '([A-Za-z]{3})';
-				return '([A-Za-z]+)';
-			case 'G':
-				if ( match.length === 1 ) return '([A-Za-z])';
-				if ( match.length === 2 ) return '([A-Za-z]{2})';
-				return '([A-Za-z\\s]+)';
-			case 'Z':
-				return match.length === 1 ? '([A-Za-z0-9+\\-:]+)' : '([A-Za-z\\s]+)';
-			case 'P':
-				return '([A-Za-z\\s]+)';
-			default:
-				return match;
+				case 'y':
+					return match.length === 2 ? '(\\d{2})' : '(\\d{4})';
+				case 'M':
+					if ( match.length === 1 ) return '(\\d{1,2})';
+					if ( match.length === 2 ) return '(\\d{2})';
+					if ( match.length === 3 ) return '([A-Za-z.]{1,7})';
+					return '([A-Za-z]+)';
+				case 'd':
+					return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
+				case 'H':
+				case 'h':
+					return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
+				case 'm':
+				case 's':
+					return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
+				case 'S':
+					return `(\\d{${match.length}})`;
+				case 'a':
+					return '([aApP][mM])';
+				case 'D':
+					if ( match.length === 1 ) return '([A-Za-z])';
+					if ( match.length === 2 ) return '([A-Za-z]{3})';
+					return '([A-Za-z]+)';
+				case 'G':
+					if ( match.length === 1 ) return '([A-Za-z])';
+					if ( match.length === 2 ) return '([A-Za-z]{2})';
+					return '([A-Za-z\\s]+)';
+				case 'Z':
+					return match.length === 1 ? '([A-Za-z0-9+\\-:]+)' : '([A-Za-z\\s]+)';
+				case 'P':
+					return '([A-Za-z\\s]+)';
+				default:
+					return match;
 			}
 		} );
 	} ).join( '' );
@@ -718,70 +718,70 @@ function parseTimeInstantComponents( dateString: string, pattern: string, config
 		const value = matches[ index + 1 ];
 
 		switch ( token.type ) {
-		case 'y':
-			if ( token.length === 2 ) {
-				const shortYear = parseInt( value, 10 );
-				result.year = shortYear < 50 ? 2000 + shortYear : 1900 + shortYear;
-			} else {
-				result.year = parseInt( value, 10 );
-			}
-			break;
-		case 'M':
-			switch ( token.length ) {
-			case 1:
-			case 2:
-				result.month = parseInt( value, 10 ) as TMonth;
+			case 'y':
+				if ( token.length === 2 ) {
+					const shortYear = parseInt( value, 10 );
+					result.year = shortYear < 50 ? 2000 + shortYear : 1900 + shortYear;
+				} else {
+					result.year = parseInt( value, 10 );
+				}
 				break;
-			case 3: {
-				const normalizedValue = normalizeMonthName( value );
-				const monthIndex = getMonthNames( locale ).short.findIndex( name =>
-					name.toLowerCase() === normalizedValue.toLowerCase()
-				);
-				if ( monthIndex === -1 )
-					throw new Error( `Invalid short month name in date string: ${dateString}` );
-				result.month = ( monthIndex + 1 ) as TMonth;
+			case 'M':
+				switch ( token.length ) {
+					case 1:
+					case 2:
+						result.month = parseInt( value, 10 ) as TMonth;
+						break;
+					case 3: {
+						const normalizedValue = normalizeMonthName( value );
+						const monthIndex = getMonthNames( locale ).short.findIndex( name =>
+							name.toLowerCase() === normalizedValue.toLowerCase()
+						);
+						if ( monthIndex === -1 )
+							throw new Error( `Invalid short month name in date string: ${dateString}` );
+						result.month = ( monthIndex + 1 ) as TMonth;
+						break;
+					}
+					case 4: {
+						const normalizedValue = normalizeMonthName( value );
+						const monthIndex = getMonthNames( locale ).long.findIndex( name =>
+							name.toLowerCase() === normalizedValue.toLowerCase()
+						);
+						if ( monthIndex === -1 )
+							throw new Error( `Invalid full month name in date string: ${dateString}` );
+						result.month = ( monthIndex + 1 ) as TMonth;
+						break;
+					}
+					default:
+						throw new Error( `Invalid month pattern: ${token}` );
+				}
 				break;
-			}
-			case 4: {
-				const normalizedValue = normalizeMonthName( value );
-				const monthIndex = getMonthNames( locale ).long.findIndex( name =>
-					name.toLowerCase() === normalizedValue.toLowerCase()
-				);
-				if ( monthIndex === -1 )
-					throw new Error( `Invalid full month name in date string: ${dateString}` );
-				result.month = ( monthIndex + 1 ) as TMonth;
+			case 'd':
+				result.date = parseInt( value, 10 ) as TDayOfMonth;
+				break;
+			case 'H':
+				result.hours = parseInt( value, 10 ) as THourOfDay;
+				break;
+			case 'h':
+				hourValue = parseInt( value, 10 );
+				is12Hour = true;
+				break;
+			case 'm':
+				result.minutes = parseInt( value, 10 ) as TMinuteOfHour;
+				break;
+			case 's':
+				result.seconds = parseInt( value, 10 ) as TSecondOfMinute;
+				break;
+			case 'S':
+				let ms = parseInt( value, 10 );
+				// Normalize to milliseconds based on length
+				if ( token.length === 1 ) ms *= 100;
+				else if ( token.length === 2 ) ms *= 10;
+				result.milliseconds = ms as TMillisecondOfSecond;
+				break;
+			case 'a':
+				isPM = value.toLowerCase().includes( 'p' );
 				break;
-			}
-			default:
-				throw new Error( `Invalid month pattern: ${token}` );
-			}
-			break;
-		case 'd':
-			result.date = parseInt( value, 10 ) as TDayOfMonth;
-			break;
-		case 'H':
-			result.hours = parseInt( value, 10 ) as THourOfDay;
-			break;
-		case 'h':
-			hourValue = parseInt( value, 10 );
-			is12Hour = true;
-			break;
-		case 'm':
-			result.minutes = parseInt( value, 10 ) as TMinuteOfHour;
-			break;
-		case 's':
-			result.seconds = parseInt( value, 10 ) as TSecondOfMinute;
-			break;
-		case 'S':
-			let ms = parseInt( value, 10 );
-			// Normalize to milliseconds based on length
-			if ( token.length === 1 ) ms *= 100;
-			else if ( token.length === 2 ) ms *= 10;
-			result.milliseconds = ms as TMillisecondOfSecond;
-			break;
-		case 'a':
-			isPM = value.toLowerCase().includes( 'p' );
-			break;
 		}
 	} );
 
@@ -821,3 +821,276 @@ function parseTimeInstantComponents( dateString: string, pattern: string, config
 
 	return result;
 }
+
+// Basic patterns that don't require Intl (24-hour format only)
+export type TBasicTimePattern =
+	// Year patterns
+	| 'y' | 'yy' | 'yyyy'
+	// Month patterns (numeric only)
+	| 'M' | 'MM'
+	// Day patterns
+	| 'd' | 'dd'
+	// Hour patterns (24-hour only)
+	| 'H' | 'HH'
+	// Minute patterns
+	| 'm' | 'mm'
+	// Second patterns
+	| 's' | 'ss'
+	// Millisecond patterns
+	| 'S' | 'SS' | 'SSS'
+	// Combination patterns (basic only)
+	| 'yyyy-MM-dd'
+	| 'yyyy-MM-dd HH:mm'
+	| 'yyyy-MM-dd HH:mm:ss'
+	| 'yyyy-MM-dd HH:mm:ss.SSS'
+	| 'yyyy/MM/dd'
+	| 'yyyy/MM/dd HH:mm'
+	| 'yyyy/MM/dd HH:mm:ss'
+	| 'yyyy/MM/dd HH:mm:ss.SSS'
+	| 'MM/dd/yyyy'
+	| 'MM/dd/yyyy HH:mm'
+	| 'MM/dd/yyyy HH:mm:ss'
+	| 'MM/dd/yyyy HH:mm:ss.SSS'
+	| 'dd/MM/yyyy'
+	| 'dd/MM/yyyy HH:mm'
+	| 'dd/MM/yyyy HH:mm:ss'
+	| 'dd/MM/yyyy HH:mm:ss.SSS'
+	| 'HH:mm:ss'
+	| 'HH:mm';
+
+/**
+	* Parses a date string using only basic patterns that don't require Intl.
+	* This is a safer alternative to parseTimeInstantComponents that works even when Intl is not available.
+	*
+	* @param dateString The date string to parse
+	* @param pattern A basic pattern that doesn't require Intl (strongly typed)
+	* @returns Partial time instant parameters that were parsed from the string
+	* @throws Error if the string doesn't match the pattern or contains invalid values
+	*/
+export function parseTimeInstantBasicComponents(
+	dateString: string,
+	pattern: TBasicTimePattern
+): Partial<TTimeInstantParameters> {
+
+	// Check if Intl is available, if so warn the user about the existing function
+	const isIntlAvailable = typeof Intl !== 'undefined' && typeof Intl.DateTimeFormat !== 'undefined';
+	if ( isIntlAvailable )
+		console.warn( 'Intl is available, use parseTimeInstantComponents instead of parseTimeInstantBasicComponents.' );
+
+	const result: Partial<TTimeInstantParameters> = {};
+
+	let patternIndex = 0;
+	let dateStringIndex = 0;
+
+	// Helper function to check if a character is a pattern token
+	const isPatternChar = ( char: string ): boolean => [ 'y', 'M', 'd', 'H', 'm', 's', 'S' ].includes( char );
+
+	// Token extraction rules dictionary
+	const tokenRules: Record<string, {
+		maxLength?: number;
+		validator?: (value: string) => boolean;
+		description?: string;
+	}> = {
+		'': { maxLength: undefined }, // Default rule
+		'H': {
+			maxLength: 2,
+			validator: (value) => /^\d{1,2}$/.test(value) && parseInt(value, 10) >= 0 && parseInt(value, 10) <= 23,
+			description: 'Hour (0-23, 1-2 digits)'
+		},
+		'HH': {
+			maxLength: 2,
+			validator: (value) => /^\d{2}$/.test(value) && parseInt(value, 10) >= 0 && parseInt(value, 10) <= 23,
+			description: 'Hour (00-23, exactly 2 digits)'
+		},
+		'M': {
+			maxLength: 2,
+			validator: (value) => /^\d{1,2}$/.test(value) && parseInt(value, 10) >= 1 && parseInt(value, 10) <= 12,
+			description: 'Month (1-12, 1-2 digits)'
+		},
+		'MM': {
+			maxLength: 2,
+			validator: (value) => /^\d{2}$/.test(value) && parseInt(value, 10) >= 1 && parseInt(value, 10) <= 12,
+			description: 'Month (01-12, exactly 2 digits)'
+		},
+		'd': {
+			maxLength: 2,
+			validator: (value) => /^\d{1,2}$/.test(value) && parseInt(value, 10) >= 1 && parseInt(value, 10) <= 31,
+			description: 'Day (1-31, 1-2 digits)'
+		},
+		'dd': {
+			maxLength: 2,
+			validator: (value) => /^\d{2}$/.test(value) && parseInt(value, 10) >= 1 && parseInt(value, 10) <= 31,
+			description: 'Day (01-31, exactly 2 digits)'
+		},
+		'm': {
+			maxLength: 2,
+			validator: (value) => /^\d{1,2}$/.test(value) && parseInt(value, 10) >= 0 && parseInt(value, 10) <= 59,
+			description: 'Minutes (0-59, 1-2 digits)'
+		},
+		'mm': {
+			maxLength: 2,
+			validator: (value) => /^\d{2}$/.test(value) && parseInt(value, 10) >= 0 && parseInt(value, 10) <= 59,
+			description: 'Minutes (00-59, exactly 2 digits)'
+		},
+		's': {
+			maxLength: 2,
+			validator: (value) => /^\d{1,2}$/.test(value) && parseInt(value, 10) >= 0 && parseInt(value, 10) <= 59,
+			description: 'Seconds (0-59, 1-2 digits)'
+		},
+		'ss': {
+			maxLength: 2,
+			validator: (value) => /^\d{2}$/.test(value) && parseInt(value, 10) >= 0 && parseInt(value, 10) <= 59,
+			description: 'Seconds (00-59, exactly 2 digits)'
+		},
+		'S': {
+			maxLength: 3,
+			validator: (value) => /^\d{1,3}$/.test(value) && parseInt(value, 10) >= 0 && parseInt(value, 10) <= 999,
+			description: 'Milliseconds (0-999, 1-3 digits)'
+		},
+		'SS': {
+			maxLength: 2,
+			validator: (value) => /^\d{2}$/.test(value) && parseInt(value, 10) >= 0 && parseInt(value, 10) <= 99,
+			description: 'Milliseconds (0-99, exactly 2 digits)'
+		},
+		'SSS': {
+			maxLength: 3,
+			validator: (value) => /^\d{3}$/.test(value) && parseInt(value, 10) >= 0 && parseInt(value, 10) <= 999,
+			description: 'Milliseconds (000-999, exactly 3 digits)'
+		},
+		'y': {
+			maxLength: 4,
+			validator: (value) => /^\d{1,4}$/.test(value) && parseInt(value, 10) >= 0 && parseInt(value, 10) <= 9999,
+			description: 'Year (0-9999, 1-4 digits)'
+		},
+		'yy': {
+			maxLength: 2,
+			validator: (value) => /^\d{2}$/.test(value),
+			description: 'Year (2 digits)'
+		},
+		'yyyy': {
+			maxLength: 4,
+			validator: (value) => /^\d{4}$/.test(value),
+			description: 'Year (4 digits)'
+		}
+	};
+
+	// Helper function to extract a token value from the date string using token rules
+	const extractValue = ( tokenType: string, tokenLength: number ): string => {
+		const tokenKey = tokenType.repeat( tokenLength );
+		const rule = tokenRules[ tokenKey ] || tokenRules[ '' ];
+		
+		// Extract consecutive digits up to maxLength
+		let endIndex = dateStringIndex;
+		let digitCount = 0;
+		const maxChars = rule.maxLength || tokenLength;
+		
+		while ( endIndex < dateString.length && /\d/.test( dateString[ endIndex ] ) && digitCount < maxChars ) {
+			endIndex++;
+			digitCount++;
+		}
+		
+		const value = dateString.substring( dateStringIndex, endIndex );
+		dateStringIndex = endIndex;
+		
+		// Validate the extracted value if a validator is provided
+		if ( rule.validator && !rule.validator( value ) ) {
+			// Extract field name from description for better error messages
+			const fieldName = (rule.description || tokenKey).split(' ')[0].toLowerCase();
+			throw new Error( `Invalid ${fieldName} value: "${value}"` );
+		}
+		
+		return value;
+	};
+
+	// Helper function to parse and validate a numeric value
+	const parseNumericValue = ( value: string, min: number, max: number, field: string ): number => {
+		const num = parseInt( value, 10 );
+		if ( isNaN( num ) || num < min || num > max )
+			throw new Error( `Invalid ${field} value: ${value}` );
+		return num;
+	};
+
+	while ( patternIndex < pattern.length ) {
+		const patternChar = pattern[ patternIndex ];
+
+		if ( isPatternChar( patternChar ) ) {
+
+			// Start of a token - determine its full length
+			let tokenLength = 0;
+			while ( patternIndex + tokenLength < pattern.length &&
+				pattern[ patternIndex + tokenLength ] === patternChar ) {
+				tokenLength++;
+			}
+
+			// Extract and parse the corresponding value from the date string
+			const value = extractValue( patternChar, tokenLength );
+
+			// Check if we got enough characters for this token (after extraction)
+			if ( value.length < tokenLength ) {
+				throw new Error( `Date string "${dateString}" does not match pattern "${pattern}"` );
+			}
+
+			// Debug: log pattern processing (commented out for production)
+			// console.log( `Processing patternChar="${patternChar}" with tokenLength=${tokenLength}, value="${value}"` );
+
+			switch ( patternChar ) {
+				case 'y': {
+					if ( tokenLength === 2 ) {
+						// 2-digit year
+						const shortYear = parseNumericValue( value, 0, 99, 'year' );
+						result.year = shortYear < 50 ? 2000 + shortYear : 1900 + shortYear;
+					} else {
+						// 4-digit year
+						result.year = parseNumericValue( value, 0, 9999, 'year' );
+					}
+					break;
+				}
+				case 'M':
+					result.month = parseNumericValue( value, 1, 12, 'month' ) as TMonth;
+					break;
+				case 'd':
+					result.date = parseNumericValue( value, 1, 31, 'day' ) as TDayOfMonth;
+					break;
+				case 'H':
+					result.hours = parseNumericValue( value, 0, 23, 'hours' ) as THourOfDay;
+					break;
+				case 'm':
+					result.minutes = parseNumericValue( value, 0, 59, 'minutes' ) as TMinuteOfHour;
+					break;
+				case 's':
+					result.seconds = parseNumericValue( value, 0, 59, 'seconds' ) as TSecondOfMinute;
+					break;
+				case 'S': {
+					let ms = parseInt( value, 10 );
+					if ( isNaN( ms ) )
+						throw new Error( `Invalid milliseconds value: ${value}` );
+					
+					// Normalize to milliseconds based on length
+					if ( tokenLength === 1 ) ms *= 100;
+					else if ( tokenLength === 2 ) ms *= 10;
+					result.milliseconds = ms as TMillisecondOfSecond;
+					break;
+				}
+				default:
+					throw new Error( `Unsupported pattern character: ${patternChar}` );
+			}
+
+			patternIndex += tokenLength;
+		} else {
+			// Non-pattern character (separator like '-', '/', ':', ' ', '.')
+			if ( dateStringIndex >= dateString.length ||
+				dateString[ dateStringIndex ] !== patternChar ) {
+				throw new Error( `Date string "${dateString}" does not match pattern "${pattern}"` );
+			}
+			patternIndex++;
+			dateStringIndex++;
+		}
+	}
+
+	// After processing the entire pattern, check if we consumed the entire date string
+	if ( dateStringIndex < dateString.length ) {
+		throw new Error( `Date string "${dateString}" does not match pattern "${pattern}"` );
+	}
+
+	return result;
+}