inviton-powerduck 0.0.153 → 0.0.155

package/app/powerduck-initializer.ts

@@ -6,6 +6,7 @@ import moment from 'moment';
 import select2 from 'select2';
 import { isNullOrEmpty } from '../common/utils/is-null-or-empty';
 import { LanguageUtils } from '../common/utils/language-utils';
+import TemporalUtils from '../common/utils/temporal-utils';
 import PowerduckState from './powerduck-state';
 
 export interface PoweduckInitFrameworkArgs {
@@ -25,8 +26,8 @@ export default class PowerduckInitializer {
 			window.addEventListener('vite:preloadError', (event) => {
 				const key = `${PowerduckState.getAppPrefix()}errLastReload`;
 				const lastTry = Number(localStorage.getItem(key) || '0');
-				if (new Date().getTime() - lastTry > 3000) {
-					localStorage.setItem(key, new Date().getTime().toString());
+				if (TemporalUtils.dateNowMs() - lastTry > 3000) {
+					localStorage.setItem(key, TemporalUtils.dateNowMs().toString());
 
 					if ((window as any).__routerNextTo != null && !isNullOrEmpty((window as any).__routerNextTo.path)) {
 						location.href = (window as any).__routerNextTo.path;
@@ -39,7 +40,6 @@ export default class PowerduckInitializer {
 
 		if (args != null) {
 			if (args.supportedLanguages?.length as number > 0) {
-				// @ts-ignore
 				LanguageUtils.supportedLanguages = args.supportedLanguages as Language[];
 			}
 		}

package/common/api-http.ts

@@ -1,6 +1,6 @@
 import PowerduckState from './../app/powerduck-state';
 import { AjaxProviderXhr } from './ajax-xhr';
-import { DateWrapper } from './date-wrapper';
+import TemporalUtils from './utils/temporal-utils';
 import { PortalUtils } from './utils/utils';
 
 /**
@@ -262,9 +262,9 @@ export class AppHttpProvider {
 				} else if (keyVal != null && typeof keyVal === 'object') {
 					recIterate(keyVal);
 				} else {
-					if (keyVal != null && keyVal.indexOf && DateWrapper.isSerializedDate(keyVal)) {
+					if (keyVal != null && keyVal.indexOf && TemporalUtils.isSerializedDate(keyVal)) {
 						try {
-							obj[key] = DateWrapper.deserialize(keyVal);
+							obj[key] = TemporalUtils.fromString(keyVal);
 							if (isNaN(obj[key].getTime())) {
 								obj[key] = keyVal;
 							}
@@ -281,10 +281,8 @@ export class AppHttpProvider {
 	}
 
 	private static performAjaxCall<T>(args: AjaxDefinition<T>, url: string): Promise<T> {
-		const mySelf = this;
-
 		return new (window as any).Promise((resolve, reject) => {
-			function tryGetJSON(resp: any): any {
+			const tryGetJSON = (resp: any): any => {
 				try {
 					return JSON.parse(resp);
 				} catch (e) {
@@ -294,12 +292,12 @@ export class AppHttpProvider {
 						return null;
 					}
 				}
-			}
+			};
 
 			const method = (args.type || 'GET').toUpperCase();
 			let data = <any>(args.data || {});
-			const ajaxDefaults = mySelf.ajaxDefaults;
-			const blockUiEnabled = false;
+			const ajaxDefaults = this.ajaxDefaults;
+			let blockUiEnabled = false;
 			const query: string[] = [];
 
 			if ((method == 'GET' || method == 'DELETE') && data != null) {
@@ -321,9 +319,17 @@ export class AppHttpProvider {
 			}
 
 			if (args.blockUi != null) {
-				blockUiEnabled == args.blockUi.enabled;
+				if (typeof args.blockUi.enabled === 'string') {
+					blockUiEnabled = args.blockUi.enabled === 'true';
+				} else {
+					blockUiEnabled = args.blockUi.enabled;
+				}
 			} else if (ajaxDefaults.blockUi != null) {
-				blockUiEnabled == ajaxDefaults.blockUi.enabled;
+				if (typeof ajaxDefaults.blockUi.enabled === 'string') {
+					blockUiEnabled = ajaxDefaults.blockUi.enabled === 'true';
+				} else {
+					blockUiEnabled = ajaxDefaults.blockUi.enabled;
+				}
 			}
 
 			let customAuth = false;
@@ -388,7 +394,7 @@ export class AppHttpProvider {
 			// Start request
 			let retryCount = 0;
 			const requestLoop = () => {
-				const start = new Date().getTime();
+				const start = TemporalUtils.dateNowMs();
 				AppHttpProvider.getRequestProvider()
 					.sendRequest({
 						data,
@@ -401,11 +407,11 @@ export class AppHttpProvider {
 					.then((resp) => {
 						if (blockUiEnabled) {
 							try {
-								mySelf.unblockUi(args);
+								this.unblockUi(args);
 							} catch (e) { }
 						}
 
-						const stop = new Date().getTime();
+						const stop = TemporalUtils.dateNowMs();
 						const jsonData = tryGetJSON(resp.responseText);
 						if (jsonData != null) {
 							AppHttpProvider.postProcessJsObject(jsonData, args.jsonAdapter);

package/common/css/ladda-themeless-zoomin.min.css

@@ -1,89 +1,89 @@
-/*! Ladda http://lab.hakim.se/ladda MIT licensed Copyright (C) 2016 Hakim El Hattab, http://hakim.se ....Lightweight adaptation for Inviton API needs*/
-.ladda-button {
-    position: relative;
-}
-.ladda-button .ladda-spinner {
-    position: absolute;
-    z-index: 2;
-    display: inline-block;
-    width: 32px;
-    height: 32px;
-    top: 50%;
-    margin-top: 0;
-    opacity: 0;
-    pointer-events: none;
-}
-.ladda-button .ladda-label {
-    position: relative;
-    z-index: 3;
-}
-.ladda-button .ladda-progress {
-    position: absolute;
-    width: 0;
-    height: 100%;
-    left: 0;
-    top: 0;
-    background: rgba(0, 0, 0, 0.2);
-    visibility: hidden;
-    opacity: 0;
-    -webkit-transition: 0.1s linear all !important;
-    -moz-transition: 0.1s linear all !important;
-    -ms-transition: 0.1s linear all !important;
-    -o-transition: 0.1s linear all !important;
-    transition: 0.1s linear all !important;
-}
-.ladda-button[data-loading] .ladda-progress {
-    opacity: 1;
-    visibility: visible;
-}
-.ladda-button,
-.ladda-button .ladda-label,
-.ladda-button .ladda-spinner {
-    -webkit-transition: 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) all !important;
-    -moz-transition: 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) all !important;
-    -ms-transition: 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) all !important;
-    -o-transition: 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) all !important;
-    transition: 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) all !important;
-}
-.ladda-button[data-style="zoom-in"],
-.ladda-button[data-style="zoom-in"] .ladda-label,
-.ladda-button[data-style="zoom-in"] .ladda-spinner {
-    -webkit-transition: 0.3s ease all !important;
-    -moz-transition: 0.3s ease all !important;
-    -ms-transition: 0.3s ease all !important;
-    -o-transition: 0.3s ease all !important;
-    transition: 0.3s ease all !important;
-}
-.ladda-button[data-style="zoom-in"] {
-    overflow: hidden;
-}
-.ladda-button[data-style="zoom-in"] .ladda-spinner {
-    left: 50%;
-    margin-left: -16px;
-    -webkit-transform: scale(0.2);
-    -moz-transform: scale(0.2);
-    -ms-transform: scale(0.2);
-    -o-transform: scale(0.2);
-    transform: scale(0.2);
-}
-.ladda-button[data-style="zoom-in"] .ladda-label {
-    position: relative;
-    display: inline-block;
-}
-.ladda-button[data-style="zoom-in"][data-loading] .ladda-label {
-    opacity: 0;
-    -webkit-transform: scale(2.2);
-    -moz-transform: scale(2.2);
-    -ms-transform: scale(2.2);
-    -o-transform: scale(2.2);
-    transform: scale(2.2);
-}
-.ladda-button[data-style="zoom-in"][data-loading] .ladda-spinner {
-    opacity: 1;
-    margin-left: 0;
-    -webkit-transform: none;
-    -moz-transform: none;
-    -ms-transform: none;
-    -o-transform: none;
-    transform: none;
-}
+/*! Ladda http://lab.hakim.se/ladda MIT licensed Copyright (C) 2016 Hakim El Hattab, http://hakim.se ....Lightweight adaptation for Inviton API needs*/
+.ladda-button {
+    position: relative;
+}
+.ladda-button .ladda-spinner {
+    position: absolute;
+    z-index: 2;
+    display: inline-block;
+    width: 32px;
+    height: 32px;
+    top: 50%;
+    margin-top: 0;
+    opacity: 0;
+    pointer-events: none;
+}
+.ladda-button .ladda-label {
+    position: relative;
+    z-index: 3;
+}
+.ladda-button .ladda-progress {
+    position: absolute;
+    width: 0;
+    height: 100%;
+    left: 0;
+    top: 0;
+    background: rgba(0, 0, 0, 0.2);
+    visibility: hidden;
+    opacity: 0;
+    -webkit-transition: 0.1s linear all !important;
+    -moz-transition: 0.1s linear all !important;
+    -ms-transition: 0.1s linear all !important;
+    -o-transition: 0.1s linear all !important;
+    transition: 0.1s linear all !important;
+}
+.ladda-button[data-loading] .ladda-progress {
+    opacity: 1;
+    visibility: visible;
+}
+.ladda-button,
+.ladda-button .ladda-label,
+.ladda-button .ladda-spinner {
+    -webkit-transition: 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) all !important;
+    -moz-transition: 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) all !important;
+    -ms-transition: 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) all !important;
+    -o-transition: 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) all !important;
+    transition: 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) all !important;
+}
+.ladda-button[data-style="zoom-in"],
+.ladda-button[data-style="zoom-in"] .ladda-label,
+.ladda-button[data-style="zoom-in"] .ladda-spinner {
+    -webkit-transition: 0.3s ease all !important;
+    -moz-transition: 0.3s ease all !important;
+    -ms-transition: 0.3s ease all !important;
+    -o-transition: 0.3s ease all !important;
+    transition: 0.3s ease all !important;
+}
+.ladda-button[data-style="zoom-in"] {
+    overflow: hidden;
+}
+.ladda-button[data-style="zoom-in"] .ladda-spinner {
+    left: 50%;
+    margin-left: -16px;
+    -webkit-transform: scale(0.2);
+    -moz-transform: scale(0.2);
+    -ms-transform: scale(0.2);
+    -o-transform: scale(0.2);
+    transform: scale(0.2);
+}
+.ladda-button[data-style="zoom-in"] .ladda-label {
+    position: relative;
+    display: inline-block;
+}
+.ladda-button[data-style="zoom-in"][data-loading] .ladda-label {
+    opacity: 0;
+    -webkit-transform: scale(2.2);
+    -moz-transform: scale(2.2);
+    -ms-transform: scale(2.2);
+    -o-transform: scale(2.2);
+    transform: scale(2.2);
+}
+.ladda-button[data-style="zoom-in"][data-loading] .ladda-spinner {
+    opacity: 1;
+    margin-left: 0;
+    -webkit-transform: none;
+    -moz-transform: none;
+    -ms-transform: none;
+    -o-transform: none;
+    transform: none;
+}

package/common/enum-translation/day-translator.ts

@@ -1,6 +1,6 @@
 import type { Day } from './../enums/day';
 import PowerduckState from './../../app/powerduck-state';
-import { capitalize } from './../utils/capitalize-string';
+import { capitalize } from '../extensions/string-extensions';
 
 export default class DayTranslator {
 	private static _dayMap: { [index: string]: string } = null as any;
@@ -18,12 +18,13 @@ export default class DayTranslator {
 		this._dayMap = {};
 		const locale = PowerduckState.getCurrentLanguage();
 		for (let i = 7; i < 15; i++) {
+			// eslint-disable-next-line no-restricted-syntax
 			const dayDate = new Date(Date.UTC(
 				2015,
 				5,
 				i,
 			));
-			const dayName = capitalize(dayDate.toLocaleDateString(locale, { weekday: 'long', timeZone: 'UTC' }));
+			const dayName = dayDate.toLocaleDateString(locale, { weekday: 'long', timeZone: 'UTC' })[capitalize]();
 			const dayEnumName = dayDate.toLocaleDateString('en', { weekday: 'long', timeZone: 'UTC' }).toUpperCase();
 			this._dayMap[dayEnumName] = dayName;
 		}

package/common/excel/excel-reader.ts

@@ -1,7 +1,7 @@
 // var XLSX = require("xlsx");
 // import XLSX from "xlsx";
 import * as XLSX from 'xlsx/xlsx.mjs';
-import { DateWrapper } from '../date-wrapper';
+import TemporalUtils from '../utils/temporal-utils';
 import { PortalUtils } from '../utils/utils';
 
 export class ExcelReader {
@@ -52,14 +52,7 @@ export class ExcelReader {
 				let rowVal = sheetRow[i];
 				if (rowVal != null) {
 					if (rowVal != null && rowVal.getUTCFullYear) {
-						rowVal = new DateWrapper(
-							rowVal.getFullYear(),
-							rowVal.getMonth(),
-							rowVal.getDate(),
-							rowVal.getHours(),
-							rowVal.getMinutes(),
-							rowVal.getSeconds(),
-						);
+						rowVal = TemporalUtils.fromDate(rowVal);
 					} else if (PortalUtils.isString(rowVal)) {
 						rowVal = rowVal.trim();
 					}

package/common/extensions/array-extensions.ts

@@ -0,0 +1,116 @@
+/* eslint-disable func-style */
+export const distinct = Symbol('distinct');
+function distinctImpl<T>(this: Array<T>): Array<T> {
+    return [...new Set(this)];
+}
+
+export const groupBy = Symbol('groupBy');
+function groupByImpl<T, K>(this: Array<T>, keySelector: (item: T) => K): Map<K, T[]> {
+    const groups = new Map<K, T[]>();
+    for (const item of this) {
+        const key = keySelector(item);
+        const group = groups.get(key);
+        if (group) {
+            group.push(item);
+        } else {
+            groups.set(key, [item]);
+        }
+    }
+    return groups;
+}
+
+export const remove = Symbol('remove');
+function removeImpl<T>(this: Array<T>, ...items: T[]) {
+    for (let i = 1, len = arguments.length; i < len; i++) {
+        // eslint-disable-next-line prefer-rest-params
+        const item = arguments[i];
+        const itemIndex = this.indexOf(item);
+
+        if (itemIndex > -1) {
+            this.splice(itemIndex, 1);
+        }
+    }
+}
+
+export const sortBy = Symbol('sortBy');
+function sortByImpl<T>(this: T[], propName: string | ((item: T) => string | number)): Array<T> {
+    function dynamicSort(property) {
+        if (propName && {}.toString.call(propName) === '[object Function]') {
+            return function (a, b) {
+                let v1 = (<any>propName)(a);
+                let v2 = (<any>propName)(b);
+
+                if (v1.constructor && v1.call && v1.apply) {
+                    v1 = v1();
+                }
+
+                if (v2.constructor && v2.call && v2.apply) {
+                    v2 = v2();
+                }
+
+                return v1 < v2 ? -1 : v1 > v2 ? 1 : 0;
+            };
+        } else {
+            let propArr: string[] = property;
+            if (typeof property === 'string' || property instanceof String) {
+                propArr = <any>[property];
+            }
+
+            return function (a, b) {
+                for (let i = 0, len = propArr.length; i < len; i++) {
+                    let currProp = propArr[i];
+                    let sortOrder = 1;
+                    if (currProp[0] === '-') {
+                        sortOrder = -1;
+                        currProp = currProp.substr(1);
+                    }
+
+                    let aVal = a[currProp];
+                    let bVal = b[currProp];
+                    if (aVal.constructor && aVal.call && aVal.apply) {
+                        aVal = aVal();
+                    }
+
+                    if (bVal.constructor && bVal.call && bVal.apply) {
+                        bVal = bVal();
+                    }
+
+                    const result = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+                    if (result != 0) {
+                        return result * sortOrder;
+                    }
+                }
+
+                return 0;
+            };
+        }
+    }
+
+    this.sort(dynamicSort(propName));
+    return this;
+}
+
+
+declare global {
+    export interface Array<T> {
+        [distinct]: typeof distinctImpl;
+        [groupBy]: typeof groupByImpl;
+        /**
+         * Removes given items from the Array
+         *
+         * @param items Items that should be removed from the Array
+         */
+        [remove]: typeof removeImpl;
+        /**
+         * Sorts array by given property
+         *
+         * @param propName Property name (or function returning the sort key), the array should be sorted by
+         */
+        [sortBy]: typeof sortByImpl
+    }
+}
+
+(Array as any).prototype[distinct] = distinctImpl;
+(Array as any).prototype[groupBy] = groupByImpl;
+(Array as any).prototype[remove] = removeImpl;
+(Array as any).prototype[sortBy] = sortByImpl;

package/common/extensions/string-extensions.ts

@@ -0,0 +1,92 @@
+export const format = Symbol('format');
+function formatImpl(this: string, ...replaceArgs: Array<string | number>) {
+    var args = arguments;
+    return this.replace(/\{\{|\}\}|\{(\d+)\}/g, function (m, n) {
+        if (m == "{{") { return "{"; }
+        if (m == "}}") { return "}"; }
+        return args[n];
+    });
+};
+
+export const startsWith = Symbol('startsWith');
+function startsWithImpl(this: string, str: string) {
+    return this.indexOf(str) == 0;
+};
+
+export const endsWith = Symbol('endsWith');
+function endsWithImpl(this: string, suffix: string) {
+    return this.indexOf(suffix, this.length - suffix.length) !== -1;
+};
+
+
+export const capitalize = Symbol('capitalize');
+function capitalizeImpl(this: string) {
+    {
+        if (this != null) {
+            if (this.length > 1) {
+                return this.charAt(0).toUpperCase() + this.slice(1);
+            } else {
+                return this.toUpperCase();
+            }
+        } else {
+            return null;
+        }
+    }
+}
+
+export const latinize = Symbol('latinize');
+function latinizeImpl(this: string) {
+    {
+        try {
+            return (<any>this).normalize('NFD').replace(/[\u0300-\u036f]/g, "");
+        } catch (e) {
+            return this as any;
+        }
+    };
+}
+
+
+declare global {
+    export interface String {
+        /**
+         * Replaces one or more format items in the string with the string specification of specified object
+         * 
+         * @param replaceArgs Format objects
+         */
+        [format]: typeof formatImpl;
+
+        /**
+         * Determines if current string starts with given string
+         * 
+         * @param str String that should be checked
+         */
+        [startsWith]: typeof startsWithImpl;
+
+        /**
+         * Determines if current string ends with given string
+         * 
+         * @param str String that should be checked
+         */
+        [endsWith]: typeof endsWithImpl;
+
+        /**
+         * Returns capitalized string (with leading letter ensured in capitals)
+         * 
+         * @param str String that should be capitalized
+         */
+        [capitalize]: typeof capitalizeImpl
+
+        /**
+         * Returns latinized string (with local accents replaced with ASCII ones)
+         * 
+         * @param str String that should be latinized
+         */
+        [latinize]: typeof latinizeImpl
+    }
+}
+
+(String as any).prototype[format] = formatImpl;
+(String as any).prototype[startsWith] = startsWithImpl;
+(String as any).prototype[endsWith] = endsWithImpl;
+(String as any).prototype[capitalize] = capitalizeImpl;
+(String as any).prototype[latinize] = latinizeImpl;

package/common/extensions/temporal-extensions.ts

@@ -0,0 +1,115 @@
+/* eslint-disable func-style */
+import { Temporal } from '@js-temporal/polyfill';
+import PowerduckState from '../../app/powerduck-state';
+
+export const toDisplayString = Symbol('toDisplayString');
+function toDisplayStringImpl(
+	this: Temporal.PlainDateTime,
+	options?: {
+		showTime?: boolean;
+		showSeconds?: boolean;
+		monthLong?: boolean;
+		dayLong?: boolean;
+		hideDay?: boolean;
+		hideMonth?: boolean;
+		hideYear?: boolean;
+		language?: string;
+	} | boolean,
+	showTime?: boolean,
+	showSeconds?: boolean,
+	monthLong?: boolean,
+): string {
+	let opts: any = {};
+	if (typeof options === 'object') {
+		opts = options ?? {};
+	} else {
+		opts = {
+			showTime: options as any,
+			showSeconds: showTime as any,
+			monthLong: showSeconds,
+		};
+	}
+
+	const fmt: Intl.DateTimeFormatOptions = {
+		year: !opts.hideYear ? 'numeric' : undefined,
+		month: !opts.hideMonth ? (opts.monthLong ? 'long' : 'numeric') : undefined,
+		day: !opts.hideDay && !opts.dayLong ? 'numeric' : undefined,
+		weekday: opts.dayLong ? 'long' : undefined,
+	};
+
+	if (showTime || opts.showTime) {
+		fmt.hour = 'numeric';
+		fmt.minute = '2-digit';
+	}
+
+	if (showSeconds || opts.showSeconds) {
+		fmt.second = '2-digit';
+	}
+
+	try {
+		const locale = opts.language || PowerduckState.getCurrentLanguage?.() || undefined;
+		return this.toLocaleString(locale, fmt);
+	} catch {
+		return this.toString();
+	}
+}
+
+export const fromDate = Symbol('fromDate');
+function fromDateImpl(this: typeof Temporal.PlainDateTime, date: Date): Temporal.PlainDateTime {
+	return Temporal.PlainDateTime.from({
+		year: date.getFullYear(),
+		month: date.getMonth() + 1, // JS Date months are 0-based
+		day: date.getDate(),
+		hour: date.getHours(),
+		minute: date.getMinutes(),
+		second: date.getSeconds(),
+	});
+}
+
+export const utcEpochMilliseconds = Symbol('utcEpochMilliseconds');
+function utcEpochMillisecondsImpl(this: Temporal.PlainDateTime): number {
+	return this.toZonedDateTime('UTC').epochMilliseconds;
+}
+
+export const toJsDate = Symbol('toJsDate');
+function toJsDateImpl(this: Temporal.PlainDateTime): Date {
+	// eslint-disable-next-line no-restricted-syntax
+	return new Date(this.toString());
+}
+
+export const toWire = Symbol('toWire');
+function toWireImp(
+	this: Temporal.PlainDateTime,
+	includeTime?: boolean,
+	includeMs?: boolean,
+): string {
+	if (includeTime) {
+		if (includeMs) {
+			return this.toString();
+		} else {
+			return this.toString().split('.')[0];
+		}
+	} else {
+		return this.toPlainDate().toString();
+	}
+}
+
+declare module '@js-temporal/polyfill' {
+	// eslint-disable-next-line ts/no-namespace
+	namespace Temporal {
+		interface PlainDateConstructor {
+			[fromDate]: typeof fromDateImpl;
+		}
+		interface PlainDateTime {
+			[toJsDate]: typeof toJsDateImpl;
+			[toWire]: typeof toWireImp;
+			[toDisplayString]: typeof toDisplayStringImpl;
+			[utcEpochMilliseconds]: typeof utcEpochMillisecondsImpl;
+		}
+	}
+}
+
+(Temporal.PlainDateTime.prototype as any)[toJsDate] = toJsDateImpl;
+(Temporal.PlainDateTime.prototype as any)[toWire] = toWireImp;
+(Temporal.PlainDateTime.prototype as any)[toDisplayString] = toDisplayStringImpl;
+(Temporal.PlainDateTime.prototype as any)[utcEpochMilliseconds] = utcEpochMillisecondsImpl;

package/common/scroll-utils.ts

@@ -1,5 +1,6 @@
 import type { Vue } from 'vue-facing-decorator';
 import PowerduckState from '../app/powerduck-state';
+import TemporalUtils from './utils/temporal-utils';
 
 export default class ScrollUtils {
 	static scrollToFirstPossibleError(context: JQuery) {
@@ -12,7 +13,7 @@ export default class ScrollUtils {
 			if (scrollContext.length > 0) {
 				// Prevents multiple scrolling in one run
 				const lastScroll = (PowerduckState as any)._lastValidationScroll || 0;
-				const now = new Date().getTime();
+				const now = TemporalUtils.dateNowMs();
 				if (now - lastScroll < 800) {
 					return;
 				} else {