Merge pull request #801 from Cratis:feature/time_span

Introducing TimeSpan for TypeScript with serialization support

Author: einari

Source/JavaScript/JsonSerializer.ts

@@ -6,6 +6,7 @@ import { DerivedType } from './DerivedType';
 import { Field } from './Field';
 import { Fields } from './Fields';
 import { Guid } from './Guid';
+import { TimeSpan } from './TimeSpan';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
@@ -16,7 +17,8 @@ const typeConverters: Map<Constructor, typeSerializer> = new Map<Constructor, ty
     [String, (value: string) => value],
     [Boolean, (value: boolean) => value],
     [Date, (value: Date) => value.toISOString()],
-    [Guid, (value: Guid) => value?.toString() ?? '']
+    [Guid, (value: Guid) => value?.toString() ?? ''],
+    [TimeSpan, (value: TimeSpan) => value?.toString() ?? '']
 ]);
 
 const typeSerializers: Map<Constructor, typeSerializer> = new Map<Constructor, typeSerializer>([
@@ -25,6 +27,7 @@ const typeSerializers: Map<Constructor, typeSerializer> = new Map<Constructor, t
     [Boolean, (value: any) => value],
     [Date, (value: any) => new Date(value)],
     [Guid, (value: any) => Guid.parse(value.toString())],
+    [TimeSpan, (value: any) => TimeSpan.parse(value.toString())],
 ]);
 
 const serializeValueForType = (type: Constructor, value: any) => {

Source/JavaScript/TimeSpan.ts

@@ -0,0 +1,162 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from './fieldDecorator';
+
+const timeSpanRegex = /^(-)?(?:(\d+)\.)?(\d{1,2}):(\d{2}):(\d{2})(?:\.(\d{1,7}))?$/;
+
+/**
+ * Represents a time interval.
+ */
+export class TimeSpan {
+   
+    @field(Number)
+    ticks!: number;
+
+    @field(Number)
+    days!: number;
+
+    @field(Number)
+    hours!: number;
+
+    @field(Number)
+    milliseconds!: number;
+
+    @field(Number)
+    microseconds!: number;
+
+    @field(Number)
+    nanoseconds!: number;
+
+    @field(Number)
+    minutes!: number;
+
+    @field(Number)
+    seconds!: number;
+
+    @field(Number)
+    totalDays!: number;
+
+    @field(Number)
+    totalHours!: number;
+
+    @field(Number)
+    totalMilliseconds!: number;
+
+    @field(Number)
+    totalMicroseconds!: number;
+
+    @field(Number)
+    totalNanoseconds!: number;
+
+    @field(Number)
+    totalMinutes!: number;
+
+    @field(Number)
+    totalSeconds!: number;
+
+    /**
+     * Parses a C# compatible TimeSpan string and returns a TimeSpan instance.
+     * The string format should match: [-][d.]hh:mm:ss[.fffffff]
+     * @param {string} value String representation of TimeSpan.
+     * @returns {TimeSpan} A TimeSpan instance with all properties populated.
+     * @throws {Error} If the string format is invalid.
+     */
+    static parse(value: string): TimeSpan {
+        const match = timeSpanRegex.exec(value);
+        if (match === null) {
+            throw new Error(`Invalid TimeSpan format: ${value}`);
+        }
+
+        const isNegative = match[1] === '-';
+        const days = match[2] ? parseInt(match[2], 10) : 0;
+        const hours = parseInt(match[3], 10);
+        const minutes = parseInt(match[4], 10);
+        const seconds = parseInt(match[5], 10);
+        const fractionalSeconds = match[6] ? match[6].padEnd(7, '0') : '0000000';
+
+        const ticksPerDay = 864000000000;
+        const ticksPerHour = 36000000000;
+        const ticksPerMinute = 600000000;
+        const ticksPerSecond = 10000000;
+
+        const ticks =
+            days * ticksPerDay +
+            hours * ticksPerHour +
+            minutes * ticksPerMinute +
+            seconds * ticksPerSecond +
+            parseInt(fractionalSeconds, 10);
+
+        const finalTicks = isNegative ? -ticks : ticks;
+
+        const timeSpan = new TimeSpan();
+        timeSpan.ticks = finalTicks;
+        timeSpan.days = Math.floor(Math.abs(finalTicks) / ticksPerDay) * (isNegative ? -1 : 1);
+        timeSpan.hours = Math.floor((Math.abs(finalTicks) / ticksPerHour) % 24);
+        timeSpan.minutes = Math.floor((Math.abs(finalTicks) / ticksPerMinute) % 60);
+        timeSpan.seconds = Math.floor((Math.abs(finalTicks) / ticksPerSecond) % 60);
+        timeSpan.milliseconds = Math.floor((Math.abs(finalTicks) / 10000) % 1000);
+        timeSpan.microseconds = Math.floor((Math.abs(finalTicks) / 10) % 1000);
+        timeSpan.nanoseconds = Math.floor((Math.abs(finalTicks) % 10) * 100);
+        timeSpan.totalDays = finalTicks / ticksPerDay;
+        timeSpan.totalHours = finalTicks / ticksPerHour;
+        timeSpan.totalMinutes = finalTicks / ticksPerMinute;
+        timeSpan.totalSeconds = finalTicks / ticksPerSecond;
+        timeSpan.totalMilliseconds = finalTicks / 10000;
+        timeSpan.totalMicroseconds = finalTicks / 10;
+        timeSpan.totalNanoseconds = finalTicks * 100;
+
+        return timeSpan;
+    }
+
+    /**
+     * Converts the TimeSpan to a C# compatible string format.
+     * Returns the TimeSpan in format: [-][d.]hh:mm:ss[.fffffff]
+     * @returns {string} C# compatible TimeSpan string representation.
+     */
+    toString(): string {
+        const isNegative = this.ticks < 0;
+        const absTicks = Math.abs(this.ticks);
+
+        const ticksPerDay = 864000000000;
+        const ticksPerHour = 36000000000;
+        const ticksPerMinute = 600000000;
+        const ticksPerSecond = 10000000;
+
+        const days = Math.floor(absTicks / ticksPerDay);
+        const hours = Math.floor((absTicks / ticksPerHour) % 24);
+        const minutes = Math.floor((absTicks / ticksPerMinute) % 60);
+        const seconds = Math.floor((absTicks / ticksPerSecond) % 60);
+        const fractionalTicks = absTicks % ticksPerSecond;
+
+        const parts: string[] = [];
+
+        if (isNegative) {
+            parts.push('-');
+        }
+
+        if (days > 0) {
+            parts.push(`${days}.`);
+        }
+
+        parts.push(`${hours.toString().padStart(2, '0')}:`);
+        parts.push(`${minutes.toString().padStart(2, '0')}:`);
+        parts.push(`${seconds.toString().padStart(2, '0')}`);
+
+        if (fractionalTicks > 0) {
+            const fractionalStr = fractionalTicks.toString().padStart(7, '0').replace(/0+$/, '');
+            parts.push(`.${fractionalStr}`);
+        }
+
+        return parts.join('');
+    }
+
+    /**
+     * Converts the TimeSpan to a JSON string that works in JSON serialization.
+     * Returns the TimeSpan in C# compatible format: [-][d.]hh:mm:ss[.fffffff]
+     * @returns {string} C# compatible TimeSpan string representation.
+     */
+    toJSON(): string {
+        return this.toString();
+    }
+}

Source/JavaScript/for_TimeSpan/when_calculating_total_values.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { TimeSpan } from '../TimeSpan';
+
+describe('when calculating total values', () => {
+    const timeSpanString = '1.02:30:45';
+    const parsed = TimeSpan.parse(timeSpanString);
+
+    it('should have correct total hours', () => parsed.totalHours.should.equal(26.5125));
+    it('should have correct total minutes', () => parsed.totalMinutes.should.equal(1590.75));
+    it('should have correct total seconds', () => parsed.totalSeconds.should.equal(95445));
+    it('should have correct total milliseconds', () => parsed.totalMilliseconds.should.equal(95445000));
+});

Source/JavaScript/for_TimeSpan/when_converting_simple_time_to_string.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { TimeSpan } from '../TimeSpan';
+
+describe('when converting simple time to string', () => {
+    const originalString = '00:30:15';
+    const parsed = TimeSpan.parse(originalString);
+    const convertedBack = parsed.toString();
+
+    it('should match original string', () => convertedBack.should.equal(originalString));
+});

Source/JavaScript/for_TimeSpan/when_converting_to_json.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { TimeSpan } from '../TimeSpan';
+
+describe('when converting to json', () => {
+    const originalString = '3.08:45:30.5';
+    const parsed = TimeSpan.parse(originalString);
+    const json = parsed.toJSON();
+
+    it('should return string format', () => json.should.equal(originalString));
+});

Source/JavaScript/for_TimeSpan/when_converting_to_string.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { TimeSpan } from '../TimeSpan';
+
+describe('when converting to string', () => {
+    const originalString = '5.12:30:45.1234567';
+    const parsed = TimeSpan.parse(originalString);
+    const convertedBack = parsed.toString();
+
+    it('should match original string', () => convertedBack.should.equal(originalString));
+});

Source/JavaScript/for_TimeSpan/when_parsing_negative_time.ts

@@ -0,0 +1,15 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { TimeSpan } from '../TimeSpan';
+
+describe('when parsing negative time', () => {
+    const timeSpanString = '-2.03:15:30';
+    const parsed = TimeSpan.parse(timeSpanString);
+
+    it('should have negative days', () => parsed.days.should.equal(-2));
+    it('should have correct hours', () => parsed.hours.should.equal(3));
+    it('should have correct minutes', () => parsed.minutes.should.equal(15));
+    it('should have correct seconds', () => parsed.seconds.should.equal(30));
+    it('should have negative ticks', () => parsed.ticks.should.be.lessThan(0));
+});

Source/JavaScript/for_TimeSpan/when_parsing_simple_time.ts

@@ -0,0 +1,15 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { TimeSpan } from '../TimeSpan';
+
+describe('when parsing simple time', () => {
+    const timeSpanString = '01:30:45';
+    const parsed = TimeSpan.parse(timeSpanString);
+
+    it('should have correct hours', () => parsed.hours.should.equal(1));
+    it('should have correct minutes', () => parsed.minutes.should.equal(30));
+    it('should have correct seconds', () => parsed.seconds.should.equal(45));
+    it('should have zero days', () => parsed.days.should.equal(0));
+    it('should have zero milliseconds', () => parsed.milliseconds.should.equal(0));
+});

Source/JavaScript/for_TimeSpan/when_parsing_time_with_days.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { TimeSpan } from '../TimeSpan';
+
+describe('when parsing time with days', () => {
+    const timeSpanString = '5.12:30:45';
+    const parsed = TimeSpan.parse(timeSpanString);
+
+    it('should have correct days', () => parsed.days.should.equal(5));
+    it('should have correct hours', () => parsed.hours.should.equal(12));
+    it('should have correct minutes', () => parsed.minutes.should.equal(30));
+    it('should have correct seconds', () => parsed.seconds.should.equal(45));
+});

Source/JavaScript/for_TimeSpan/when_parsing_time_with_fractional_seconds.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { TimeSpan } from '../TimeSpan';
+
+describe('when parsing time with fractional seconds', () => {
+    const timeSpanString = '01:30:45.1234567';
+    const parsed = TimeSpan.parse(timeSpanString);
+
+    it('should have correct hours', () => parsed.hours.should.equal(1));
+    it('should have correct minutes', () => parsed.minutes.should.equal(30));
+    it('should have correct seconds', () => parsed.seconds.should.equal(45));
+    it('should have correct milliseconds', () => parsed.milliseconds.should.equal(123));
+    it('should have correct microseconds', () => parsed.microseconds.should.equal(456));
+    it('should have correct nanoseconds', () => parsed.nanoseconds.should.equal(700));
+});