@hkdigital/lib-sveltekit 0.0.47 → 0.0.50

package/README.md

@@ -42,12 +42,11 @@ ncu "@hkdigital/*" -u && pnpm install
 ```
 We use a wildcard to upgrade all installed `node_modules` in the scope `@hkdigital`.
 
-You can also add this command to your project's `package.json`. E.g. add the lines:
+You can also add this command to your project. To do so, add the lines to the bottom of the `scripts` section of your `package.json`.
 
 ```bash
-"scripts": {
-  "upgrade:hklib": "ncu '@hkdigital/*' -u && pnpm install",
-  "upgrade:all": "ncu -u && pnpm install"
+"upgrade:hklib": "ncu '@hkdigital/*' -u && pnpm install",
+"upgrade:all": "ncu -u && pnpm install"
 ```
 
 ### Import JS & Svelte

package/dist/classes/promise/HkPromise.d.ts

@@ -0,0 +1,116 @@
+/**
+ * HkPromise extends the default javascript Promise class
+ */
+export default class HkPromise extends Promise<any> {
+    constructor(initFn: any);
+    /**
+     * Get value of property [resolved]
+     *
+     * @returns {boolean} true if the promise has been resolved
+     */
+    get resolved(): boolean;
+    /**
+     * Get value of property [rejected]
+     *
+     * @returns {boolean} true if the promise was rejected
+     */
+    get rejected(): boolean;
+    /**
+     * Get value of property [pending]
+     *
+     * @returns {boolean} true if the promise is still pending
+     */
+    get pending(): boolean;
+    /**
+     * Get value of property [cancelled]
+     *
+     * @returns {boolean} true if the promise was cancelled
+     */
+    get cancelled(): boolean;
+    /**
+     * Get value of property [timeout]
+     *
+     * @returns {boolean} true if the promise was cancelled due to a timeout
+     */
+    get timeout(): boolean;
+    /**
+     * Resolve the promise
+     *
+     * @param {mixed} [value] - Value to pass to the "then" callbacks
+     *
+     * @returns {object} this
+     */
+    resolve(...args: any[]): object;
+    /**
+     * Resolve the promise if the promise is still pending
+     *
+     * @param {mixed} [value] - Value to pass to the "catch" callbacks
+     *
+     * @returns {object} this
+     */
+    tryResolve(...args: any[]): object;
+    /**
+     * Reject the promise
+     *
+     * @param {Object} [errorOrInfo]
+     *   Object to pass to the "catch" callbacks, usually an Error object
+     *
+     * @returns {object} this
+     */
+    reject(...args: any[]): object;
+    /**
+     * Reject the promise if the promise is still pending
+     *
+     * @param {Object} [errorOrInfo]
+     *   Object to pass to the "catch" callbacks, usually an Error object
+     *
+     * @returns {object} this
+     */
+    tryReject(...args: any[]): object;
+    /**
+     * Reject the promise and set this.cancelled=true
+     *
+     * @param {Object} [errorOrInfo]
+     *   Object to pass to the "catch" callbacks, usually an Error object
+     *
+     * @returns {object} this
+     */
+    cancel(errorOrInfo?: any, ...args: any[]): object;
+    /**
+     * Reject the promise and set this.cancelled=true
+     *
+     * @param {Object} [errorOrInfo]
+     *   Object to pass to the "catch" callbacks, usually an Error object
+     *
+     * @returns {object} this
+     */
+    tryCancel(...args: any[]): object;
+    /**
+     * Specify the number of milliseconds until the promise should time out.
+     * - When a timeout occurs: the promise is cancelled and the following
+     *   properties are both set
+     *
+     *      this.timeout=true
+     *      this.cancelled=true
+     *
+     * @param {number} ms
+     *   Number of milliseconds after which the promise should time out
+     *
+     * @param {string} [message="Timeout"]
+     *   Message of the error that will be thrown when the timeout occurs
+     */
+    setTimeout(ms: number, message?: string): this;
+    /**
+     * Register a callback that is called when the promise resolves
+     *
+     * @param {function} callback
+     */
+    then(...args: any[]): Promise<any>;
+    /**
+     * Register a callback that is called when the promise rejects, is
+     * cancelled or times out
+     *
+     * @param {function} callback
+     */
+    catch(...args: any[]): Promise<any>;
+}

package/dist/classes/promise/HkPromise.js

@@ -0,0 +1,387 @@
+/**
+ * Hkpromise.js
+ *
+ * @description
+ * HkPromise extends the default Promise class. A HkPromise offers some
+ * additional methods, e.g. resolve, reject and setTimeout, which makes it
+ * easier to use than the build in Promise class in some code constructions.
+ *
+ * @example
+ *
+ *   import HkPromise from "./HkPromise.js";
+ *
+ *   function() {
+ *     const promise = new HkPromise();
+ *
+ *     setTimeout( promise.resolve, 1000 );
+ *
+ *     return promise;
+ *   }
+ */
+
+/* ------------------------------------------------------------------ Imports */
+
+import * as expect from '../../util/expect/index.js';
+
+import { noop } from '../../util/function/index.js';
+
+/* ---------------------------------------------------------------- Internals */
+
+const resolved$ = Symbol('resolved');
+const rejected$ = Symbol('rejected');
+const pending$ = Symbol('pending');
+
+const timeout$ = Symbol('timeout');
+const cancelled$ = Symbol('cancelled');
+
+const resolveFn$ = Symbol('resolveFn');
+const rejectFn$ = Symbol('rejectFn');
+
+const timeoutTimer$ = Symbol('timeoutTimer');
+
+const hasThen$ = Symbol('hasThen');
+
+/* ------------------------------------------------------------------- Export */
+
+/**
+ * HkPromise extends the default javascript Promise class
+ */
+export default class HkPromise extends Promise {
+	constructor(initFn) {
+		let _resolveFn;
+		let _rejectFn;
+
+		super((resolveFn, rejectFn) => {
+			//
+			// @note if initFn cannot be called an exception will be thrown:
+			// TypeError: Promise resolve or reject function is not callable
+			//
+			if (initFn) {
+				initFn(resolveFn, rejectFn);
+			}
+
+			_resolveFn = resolveFn;
+			_rejectFn = rejectFn;
+		});
+
+		// @note some values are not initialized on purpose,
+		//       to save time during promise creation
+
+		this[resolveFn$] = _resolveFn;
+		this[rejectFn$] = _rejectFn;
+
+		// this[ resolved$ ] = false;
+		// this[ rejected$ ] = false;
+
+		this[pending$] = true;
+
+		// this[ cancelled$ ] = false;
+		// this[ timeout$ ] = false;
+
+		// this[ timeoutTimer$ ] = undefined;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Get value of property [resolved]
+	 *
+	 * @returns {boolean} true if the promise has been resolved
+	 */
+	get resolved() {
+		return this[resolved$] ? true : false;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Get value of property [rejected]
+	 *
+	 * @returns {boolean} true if the promise was rejected
+	 */
+	get rejected() {
+		return this[rejected$] ? true : false;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Get value of property [pending]
+	 *
+	 * @returns {boolean} true if the promise is still pending
+	 */
+	get pending() {
+		return this[pending$];
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Get value of property [cancelled]
+	 *
+	 * @returns {boolean} true if the promise was cancelled
+	 */
+	get cancelled() {
+		return this[cancelled$] ? true : false;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Get value of property [timeout]
+	 *
+	 * @returns {boolean} true if the promise was cancelled due to a timeout
+	 */
+	get timeout() {
+		return this[timeout$] ? true : false;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Resolve the promise
+	 *
+	 * @param {mixed} [value] - Value to pass to the "then" callbacks
+	 *
+	 * @returns {object} this
+	 */
+	resolve(/* value */) {
+		// -- Check current Promise state
+
+		if (!this[pending$]) {
+			if (this[resolved$]) {
+				throw new Error('Cannot resolve Promise. Promise has already resolved');
+			} else {
+				throw new Error('Cannot resolve Promise. Promise has already been rejected');
+			}
+		}
+
+		// -- Clear timeout timer (if any)
+
+		if (undefined !== this[timeoutTimer$]) {
+			clearTimeout(this[timeoutTimer$]);
+
+			this[timeoutTimer$] = undefined;
+		}
+
+		// -- Set flags and call resolve function
+
+		this[resolved$] = true;
+		this[pending$] = false;
+
+		this[resolveFn$](...arguments);
+
+		return this;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Resolve the promise if the promise is still pending
+	 *
+	 * @param {mixed} [value] - Value to pass to the "catch" callbacks
+	 *
+	 * @returns {object} this
+	 */
+	tryResolve(/* value */) {
+		if (this[pending$]) {
+			this.resolve(...arguments);
+		}
+
+		return this;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Reject the promise
+	 *
+	 * @param {Object} [errorOrInfo]
+	 *   Object to pass to the "catch" callbacks, usually an Error object
+	 *
+	 * @returns {object} this
+	 */
+	reject(/* errorOrInfo */) {
+		if (!this[hasThen$]) {
+			//
+			// No then (or await) has been used
+			// add catch to prevent useless unhandled promise rejection
+			//
+			this.catch(noop);
+		}
+
+		// -- Check current Promise state
+
+		if (!this[pending$]) {
+			if (this[resolved$]) {
+				throw new Error('Cannot reject Promise. Promise has already resolved');
+			} else {
+				throw new Error('Cannot reject Promise. Promise has already been rejected');
+			}
+		}
+
+		// -- Clear timeout timer (if any)
+
+		if (undefined !== this[timeoutTimer$]) {
+			clearTimeout(this[timeoutTimer$]);
+
+			this[timeoutTimer$] = undefined;
+		}
+
+		// -- Set flags and call reject function
+
+		this[rejected$] = true;
+		this[pending$] = false;
+
+		this[rejectFn$](...arguments);
+
+		return this;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Reject the promise if the promise is still pending
+	 *
+	 * @param {Object} [errorOrInfo]
+	 *   Object to pass to the "catch" callbacks, usually an Error object
+	 *
+	 * @returns {object} this
+	 */
+	tryReject(/* errorOrInfo */) {
+		if (this[pending$]) {
+			this.reject(...arguments);
+		}
+
+		return this;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Reject the promise and set this.cancelled=true
+	 *
+	 * @param {Object} [errorOrInfo]
+	 *   Object to pass to the "catch" callbacks, usually an Error object
+	 *
+	 * @returns {object} this
+	 */
+	cancel(errorOrInfo) {
+		if (errorOrInfo) {
+			if (!(errorOrInfo instanceof Object)) {
+				throw new Error('Invalid parameter [errorOrInfo] (expected (error) object');
+			}
+		} else {
+			errorOrInfo = new Error('Cancelled');
+		}
+
+		errorOrInfo.cancelled = true;
+
+		this[cancelled$] = true;
+		this.reject(...arguments);
+
+		return this;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Reject the promise and set this.cancelled=true
+	 *
+	 * @param {Object} [errorOrInfo]
+	 *   Object to pass to the "catch" callbacks, usually an Error object
+	 *
+	 * @returns {object} this
+	 */
+	tryCancel(/*errorOrInfo*/) {
+		if (this[pending$]) {
+			this.cancel(...arguments);
+		}
+
+		return this;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Specify the number of milliseconds until the promise should time out.
+	 * - When a timeout occurs: the promise is cancelled and the following
+	 *   properties are both set
+	 *
+	 *      this.timeout=true
+	 *      this.cancelled=true
+	 *
+	 * @param {number} ms
+	 *   Number of milliseconds after which the promise should time out
+	 *
+	 * @param {string} [message="Timeout"]
+	 *   Message of the error that will be thrown when the timeout occurs
+	 */
+	setTimeout(ms, message = 'Timeout') {
+		expect.number(ms);
+		expect.string(message);
+
+		// -- Check current Promise state
+
+		if (!this[pending$]) {
+			if (this[resolved$]) {
+				throw new Error('Cannot set timeout. Promise has already resolved');
+			} else {
+				throw new Error('Cannot set timeout. Promise has already been rejected');
+			}
+		}
+
+		// -- Clear existing timeout (if any)
+
+		if (undefined !== this[timeoutTimer$]) {
+			clearTimeout(this[timeoutTimer$]);
+		}
+
+		// -- Set timeout
+
+		const err = new Error(message);
+
+		this[timeoutTimer$] = setTimeout(() => {
+			if (!this[pending$]) {
+				// Promise has already been resolved (should not happen)
+				return;
+			}
+
+			this[timeout$] = true;
+			this[cancelled$] = true;
+
+			err.timeout = true;
+			err.cancelled = true;
+
+			this.reject(err);
+		}, ms);
+
+		// return this -> chainable method
+		return this;
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Register a callback that is called when the promise resolves
+	 *
+	 * @param {function} callback
+	 */
+	then(/* callback */) {
+		this[hasThen$] = true;
+
+		return super.then(...arguments);
+	}
+
+	// -------------------------------------------------------------------- Method
+
+	/**
+	 * Register a callback that is called when the promise rejects, is
+	 * cancelled or times out
+	 *
+	 * @param {function} callback
+	 */
+	catch(/* callback */) {
+		return super.catch(...arguments);
+	}
+} // end class

package/dist/classes/promise/index.d.ts

@@ -0,0 +1 @@
+export { default as HkPromise } from "./HkPromise.js";

package/dist/classes/promise/index.js

@@ -0,0 +1 @@
+export { default as HkPromise } from './HkPromise.js';

package/dist/util/function/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Wraps a function so that the callback function will be called only once
+ *
+ * @param {function} callback
+ *
+ * @returns {function} callback wrapped in `once` function
+ */
+export function once(callback: Function): Function;
+/**
+ * Returns a debounced function
+ * - The original function is not called more than once during the
+ *   specified interval
+ *
+ * @param {function} fn
+ * @param {number} [intervalMs=200]
+ *
+ * @returns {function} debounced function
+ */
+export function debounce(fn: Function, intervalMs?: number): Function;
+export function noop(): void;

package/dist/util/{function.js__ → function/index.js}

@@ -16,7 +16,7 @@
 
 /* ------------------------------------------------------------------ Imports */
 
-import * as Types from '$lib/typedef/base.js';
+import * as expect from '../expect/index.js';
 
 /* ------------------------------------------------------------------ Exports */
 
@@ -36,18 +36,16 @@ export const noop = () => {};
  * @returns {function} callback wrapped in `once` function
  */
 export function once(callback) {
-  Types.Number(callback);
+	expect.function(callback);
 
-  expectFunction(callback, 'Missing or invalid parameter [callback]');
+	let ignore = false;
 
-  let ignore = false;
-
-  return function () {
-    if (!ignore) {
-      ignore = true;
-      callback(...arguments);
-    }
-  };
+	return function () {
+		if (!ignore) {
+			ignore = true;
+			callback(...arguments);
+		}
+	};
 }
 
 // -----------------------------------------------------------------------------
@@ -63,40 +61,40 @@ export function once(callback) {
  * @returns {function} debounced function
  */
 export function debounce(fn, intervalMs = 200) {
-  let idleTimer;
-  let lastArguments;
+	let idleTimer;
+	let lastArguments;
 
-  // console.log("debounce");
+	// console.log("debounce");
 
-  return function debounced() {
-    // console.log("debounced");
+	return function debounced() {
+		// console.log("debounced");
 
-    if (idleTimer) {
-      // console.log("idleTimer running");
+		if (idleTimer) {
+			// console.log("idleTimer running");
 
-      // The function has been called recently
-      lastArguments = arguments;
-      return;
-    }
+			// The function has been called recently
+			lastArguments = arguments;
+			return;
+		}
 
-    idleTimer = setTimeout(() => {
-      // console.log("idleTimer finished", lastArguments);
+		idleTimer = setTimeout(() => {
+			// console.log("idleTimer finished", lastArguments);
 
-      idleTimer = null;
+			idleTimer = null;
 
-      if (lastArguments) {
-        //
-        // At least one call has been "debounced"
-        // -> make call with last arguments, so function always receives
-        //    the arguments of the last call to the function
-        //
-        fn(...lastArguments);
-        lastArguments = undefined;
-      }
-    }, intervalMs);
+			if (lastArguments) {
+				//
+				// At least one call has been "debounced"
+				// -> make call with last arguments, so function always receives
+				//    the arguments of the last call to the function
+				//
+				fn(...lastArguments);
+				lastArguments = undefined;
+			}
+		}, intervalMs);
 
-    fn(...arguments);
-  };
+		fn(...arguments);
+	};
 }
 
 // -----------------------------------------------------------------------------

package/dist/util/time/index.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Returns a promise that resolves after a specified timeout
+ * - If the returned promise is rejected, the timeout is cancelled
+ *
+ * @param  {number} delayOrMinDelayMs
+ *   Number of milliseconds to wait before promise resolves
+ *
+ * @param  {number} [maxDelayMs=delayOrMinDelayMs]
+ *   Maximum number of milliseconds to wait before the returned promise
+ *   resolves. If this parameter is set, the delay will be chosen randomly
+ *   between the values [delayOrMinDelayMs, maxDelayMs]
+ *
+ * @returns {Promise} promise that resolves after a specified timeout
+ */
+export function delay(delayOrMinDelayMs: number, maxDelayMs?: number): Promise<any>;
+/**
+ * Get the number of milliseconds since the specified time stamp of the default
+ * reference time stamp TIME_2020_01_01
+ *
+ * @param {number} [sinceMs=TIME_2020_01_01]
+ *
+ * @returns {number} number of milliseconds since the specified time
+ */
+export function sinceMs(sinceMs?: number): number;
+/**
+ * Get a string that represents the time in a readable
+ * string format: [DD:][HH:]MM:SS.mmm
+ *
+ * @param {number} timeMs [description]
+ *
+ * @returns {string} time in human readable format
+ */
+export function timeToString(timeMs: number): string;
+/**
+ * Returns a Date object
+ * - The input can be a Date object or a numeric timestamp
+ *
+ * @param {Date|number} dateOrTimestamp
+ *
+ * @returns {Date} date object
+ */
+export function toDate(dateOrTimestamp: Date | number): Date;
+/**
+ * Get the ISO 8601 week number of the specified date
+ *
+ * @see https://stackoverflow.com
+ *      /questions/6117814/get-week-of-year-in-javascript-like-in-php
+ *
+ * @param {Date|number} dateOrTimestamp
+ *
+ * @returns {number} week number
+ */
+export function getWeekNumber(dateOrTimestamp: Date | number): number;
+/**
+ * Get the name of the month
+ * - Returns the English name of the month
+ *
+ * - Use the output as label in combination with the functions
+ *   text() and translate() for international month names
+ *
+ * e.g.
+ *
+ * setTranslations()
+ * ...
+ *
+ * text( getMonthName( new Date() ) );
+ *
+ * --
+ *
+ * @param {Date|number} dateOrTimestamp
+ *
+ * @returns {string} name of the month (English)
+ */
+export function getMonthName(dateOrTimestamp: Date | number): string;
+/**
+ * Get the name of the day
+ * - Returns the English name of the day
+ *
+ * - Use the output as label in combination with the functions
+ *   text() and translate() for international day names
+ *
+ * e.g.
+ *
+ * setTranslations()
+ * ...
+ *
+ * text( getDayName( new Date() ) );
+ *
+ * --
+ *
+ * @param {Date|number} dateOrTimestamp
+ *
+ * @returns {string} name of the day (English)
+ */
+export function getDayName(dateOrTimestamp: Date | number): string;
+/**
+ * Return the timestamp of the start of the day
+ * - Midnight
+ *
+ * @param {Date|number} dateOrTimestamp
+ *
+ * @returns {number} timestamp of start of the day (00:00:00:0000)
+ */
+export function getTimeAtStartOfDay(dateOrTimestamp: Date | number): number;
+/**
+ * Return the timestamp of the end of the day
+ * - Midnight - 1 millisecond
+ *
+ * @param {Date|number} dateOrTimestamp
+ *
+ * @returns {number} timestamp of start of the day
+ */
+export function getTimeAtEndOfDay(dateOrTimestamp: Date | number): number;
+export const SECOND_MS: 1000;
+export const MINUTE_MS: number;
+export const HOUR_MS: number;
+export const DAY_MS: number;
+export const WEEK_MS: number;
+export const TIME_2020_01_01: 1577836800000;
+export const TIME_2100_01_01: 4102444800000;

package/dist/util/{time.js__ → time/index.js}

@@ -30,13 +30,22 @@
 
 /* ------------------------------------------------------------------ Imports */
 
-// import { expectPositiveNumber } from './expect.js';
-// import { HkPromise } from './promises.js';
+import * as expect from '../expect/index.js';
+import { HkPromise } from '../../classes/promise/index.js';
 
 /* ---------------------------------------------------------------- Internals */
 
 /* ------------------------------------------------------------------ Exports */
 
+export const SECOND_MS = 1000;
+export const MINUTE_MS = 60 * SECOND_MS;
+export const HOUR_MS = 60 * MINUTE_MS;
+export const DAY_MS = 24 * HOUR_MS;
+export const WEEK_MS = 7 * DAY_MS;
+
+export const TIME_2020_01_01 = 1577836800000; // 2020-01-01T00:00:00.000Z
+export const TIME_2100_01_01 = 4102444800000; // 2100-01-01T00:00:00.000Z
+
 /**
  * Returns a promise that resolves after a specified timeout
  * - If the returned promise is rejected, the timeout is cancelled
@@ -52,37 +61,35 @@
  * @returns {Promise} promise that resolves after a specified timeout
  */
 export function delay(delayOrMinDelayMs, maxDelayMs) {
-  if (typeof delayOrMinDelayMs !== 'number') {
-    throw new Error('Invalid or missing parameter [delayOrMinDelayMs]');
-  }
-
-  if (maxDelayMs) {
-    //
-    // maxDelayMs was set -> generate random delay
-    //
-    if (maxDelayMs > delayOrMinDelayMs) {
-      delayOrMinDelayMs = Math.floor(
-        delayOrMinDelayMs + Math.random() * (maxDelayMs - delayOrMinDelayMs)
-      );
-    }
-  }
-
-  const promise = new HkPromise();
-
-  let timer = setTimeout(() => {
-    timer = null;
-    promise.resolve();
-  }, delayOrMinDelayMs);
-
-  // Register catch method to cancel timer when promise is rejected
-  promise.catch(() => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  });
-
-  return promise;
+	expect.number(delayOrMinDelayMs);
+
+	if (maxDelayMs) {
+		//
+		// maxDelayMs was set -> generate random delay
+		//
+		if (maxDelayMs > delayOrMinDelayMs) {
+			delayOrMinDelayMs = Math.floor(
+				delayOrMinDelayMs + Math.random() * (maxDelayMs - delayOrMinDelayMs)
+			);
+		}
+	}
+
+	const promise = new HkPromise();
+
+	let timer = setTimeout(() => {
+		timer = null;
+		promise.resolve();
+	}, delayOrMinDelayMs);
+
+	// Register catch method to cancel timer when promise is rejected
+	promise.catch(() => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+	});
+
+	return promise;
 }
 
 // -----------------------------------------------------------------------------
@@ -96,7 +103,7 @@ export function delay(delayOrMinDelayMs, maxDelayMs) {
  * @returns {number} number of milliseconds since the specified time
  */
 export function sinceMs(sinceMs = TIME_2020_01_01) {
-  return Date.now() - sinceMs;
+	return Date.now() - sinceMs;
 }
 
 // -----------------------------------------------------------------------------
@@ -110,36 +117,36 @@ export function sinceMs(sinceMs = TIME_2020_01_01) {
  * @returns {string} time in human readable format
  */
 export function timeToString(timeMs) {
-  const days = Math.floor(timeMs / DAY_MS);
+	const days = Math.floor(timeMs / DAY_MS);
 
-  let restMs = timeMs - days * DAY_MS;
+	let restMs = timeMs - days * DAY_MS;
 
-  const hours = Math.floor(restMs / HOUR_MS);
+	const hours = Math.floor(restMs / HOUR_MS);
 
-  restMs = restMs - hours * HOUR_MS;
+	restMs = restMs - hours * HOUR_MS;
 
-  const minutes = Math.floor(restMs / MINUTE_MS);
+	const minutes = Math.floor(restMs / MINUTE_MS);
 
-  restMs = restMs - minutes * MINUTE_MS;
+	restMs = restMs - minutes * MINUTE_MS;
 
-  const seconds = Math.floor(restMs / SECOND_MS);
+	const seconds = Math.floor(restMs / SECOND_MS);
 
-  restMs = restMs - seconds * SECOND_MS;
+	restMs = restMs - seconds * SECOND_MS;
 
-  let str = '';
+	let str = '';
 
-  if (days) {
-    str += `${days.toString().padStart(2, '0')}:`;
-    str += `${hours.toString().padStart(2, '0')}:`;
-  } else if (hours) {
-    str += `${hours.toString().padStart(2, '0')}:`;
-  }
+	if (days) {
+		str += `${days.toString().padStart(2, '0')}:`;
+		str += `${hours.toString().padStart(2, '0')}:`;
+	} else if (hours) {
+		str += `${hours.toString().padStart(2, '0')}:`;
+	}
 
-  str += `${minutes.toString().padStart(2, '0')}:`;
-  str += `${seconds.toString().padStart(2, '0')}.`;
-  str += `${restMs.toString().padEnd(3, '0')}`;
+	str += `${minutes.toString().padStart(2, '0')}:`;
+	str += `${seconds.toString().padStart(2, '0')}.`;
+	str += `${restMs.toString().padEnd(3, '0')}`;
 
-  return str;
+	return str;
 }
 
 // -----------------------------------------------------------------------------
@@ -153,15 +160,15 @@ export function timeToString(timeMs) {
  * @returns {Date} date object
  */
 export function toDate(dateOrTimestamp) {
-  if (dateOrTimestamp instanceof Date) {
-    return dateOrTimestamp;
-  }
+	if (dateOrTimestamp instanceof Date) {
+		return dateOrTimestamp;
+	}
 
-  if (typeof dateOrTimestamp === 'number') {
-    return new Date(dateOrTimestamp);
-  }
+	if (typeof dateOrTimestamp === 'number') {
+		return new Date(dateOrTimestamp);
+	}
 
-  throw new Error('Missing or invalid parameter [dateOrTimestamp]');
+	throw new Error('Missing or invalid parameter [dateOrTimestamp]');
 }
 
 // -----------------------------------------------------------------------------
@@ -177,48 +184,48 @@ export function toDate(dateOrTimestamp) {
  * @returns {number} week number
  */
 export function getWeekNumber(dateOrTimestamp) {
-  const date = toDate(dateOrTimestamp);
-
-  //
-  // Create a copy of this date object
-  //
-  const target = new Date(date.valueOf());
-
-  //
-  // ISO week date weeks start on Monday, so correct the day number
-  //
-  const dayNumber = (date.getDay() + 6) % 7;
-
-  //
-  // ISO 8601 states that week 1 is the week with the first Thursday
-  // of that year.
-  //
-  // Set the target date to the Thursday in the target week
-  //
-  target.setDate(target.getDate() - dayNumber + 3);
-
-  //
-  // Store the millisecond value of the target date
-  //
-  const firstThursday = target.valueOf();
-
-  // Set the target to the first Thursday of the year
-  // First, set the target to January 1st
-  target.setMonth(0, 1);
-
-  //
-  // Not a Thursday? Correct the date to the next Thursday
-  //
-  if (target.getDay() !== 4) {
-    target.setMonth(0, 1 + ((4 - target.getDay() + 7) % 7));
-  }
-
-  //
-  // The week number is the number of weeks between the first Thursday
-  // of the year and the Thursday in the target week
-  // (604800000 = 7 * 24 * 3600 * 1000)
-  //
-  return 1 + Math.ceil((firstThursday - target) / 604800000);
+	const date = toDate(dateOrTimestamp);
+
+	//
+	// Create a copy of this date object
+	//
+	const target = new Date(date.valueOf());
+
+	//
+	// ISO week date weeks start on Monday, so correct the day number
+	//
+	const dayNumber = (date.getDay() + 6) % 7;
+
+	//
+	// ISO 8601 states that week 1 is the week with the first Thursday
+	// of that year.
+	//
+	// Set the target date to the Thursday in the target week
+	//
+	target.setDate(target.getDate() - dayNumber + 3);
+
+	//
+	// Store the millisecond value of the target date
+	//
+	const firstThursday = target.valueOf();
+
+	// Set the target to the first Thursday of the year
+	// First, set the target to January 1st
+	target.setMonth(0, 1);
+
+	//
+	// Not a Thursday? Correct the date to the next Thursday
+	//
+	if (target.getDay() !== 4) {
+		target.setMonth(0, 1 + ((4 - target.getDay() + 7) % 7));
+	}
+
+	//
+	// The week number is the number of weeks between the first Thursday
+	// of the year and the Thursday in the target week
+	// (604800000 = 7 * 24 * 3600 * 1000)
+	//
+	return 1 + Math.ceil((firstThursday - target) / 604800000);
 }
 
 // -----------------------------------------------------------------------------
@@ -244,7 +251,8 @@ export function getWeekNumber(dateOrTimestamp) {
  * @returns {string} name of the month (English)
  */
 export function getMonthName(dateOrTimestamp) {
-  return MONTH_NAME_LABELS_EN[toDate(dateOrTimestamp).getMonth()];
+	throw new Error('Not implemented yet');
+	// return MONTH_NAME_LABELS_EN[toDate(dateOrTimestamp).getMonth()];
 }
 
 // -----------------------------------------------------------------------------
@@ -270,7 +278,8 @@ export function getMonthName(dateOrTimestamp) {
  * @returns {string} name of the day (English)
  */
 export function getDayName(dateOrTimestamp) {
-  return DAY_NAME_LABELS_EN[toDate(dateOrTimestamp).getDay()];
+	throw new Error('Not implemented yet');
+	// return DAY_NAME_LABELS_EN[toDate(dateOrTimestamp).getDay()];
 }
 
 // -----------------------------------------------------------------------------
@@ -284,21 +293,21 @@ export function getDayName(dateOrTimestamp) {
  * @returns {number} timestamp of start of the day (00:00:00:0000)
  */
 export function getTimeAtStartOfDay(dateOrTimestamp) {
-  let d;
+	let d;
 
-  if (dateOrTimestamp) {
-    d = toDate(dateOrTimestamp);
-  } else {
-    // today, now
-    d = new Date();
-  }
+	if (dateOrTimestamp) {
+		d = toDate(dateOrTimestamp);
+	} else {
+		// today, now
+		d = new Date();
+	}
 
-  d.setHours(0);
-  d.setMinutes(0);
-  d.setSeconds(0);
-  d.setMilliseconds(0);
+	d.setHours(0);
+	d.setMinutes(0);
+	d.setSeconds(0);
+	d.setMilliseconds(0);
 
-  return d.getTime();
+	return d.getTime();
 }
 
 // -----------------------------------------------------------------------------
@@ -312,19 +321,19 @@ export function getTimeAtStartOfDay(dateOrTimestamp) {
  * @returns {number} timestamp of start of the day
  */
 export function getTimeAtEndOfDay(dateOrTimestamp) {
-  let d;
+	let d;
 
-  if (dateOrTimestamp) {
-    d = toDate(dateOrTimestamp);
-  } else {
-    // today, now
-    d = new Date();
-  }
+	if (dateOrTimestamp) {
+		d = toDate(dateOrTimestamp);
+	} else {
+		// today, now
+		d = new Date();
+	}
 
-  d.setHours(23);
-  d.setMinutes(59);
-  d.setSeconds(59);
-  d.setMilliseconds(999);
+	d.setHours(23);
+	d.setMinutes(59);
+	d.setSeconds(59);
+	d.setMilliseconds(999);
 
-  return d.getTime();
+	return d.getTime();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-sveltekit",
-	"version": "0.0.47",
+	"version": "0.0.50",
 	"author": "Jens Kleinhout, HKdigital (https://hkdigital.nl)",
 	"license": "ISC",
 	"repository": {
@@ -54,6 +54,10 @@
 			"types": "./dist/classes/data/index.d.ts",
 			"svelte": "./dist/classes/data/index.js"
 		},
+		"./classes/promise": {
+			"types": "./dist/classes/promise/index.d.ts",
+			"svelte": "./dist/classes/promise/index.js"
+		},
 		"./classes/streams": {
 			"types": "./dist/classes/streams/index.d.ts",
 			"svelte": "./dist/classes/streams/index.js"
@@ -122,6 +126,10 @@
 			"types": "./dist/util/expect/index.d.ts",
 			"svelte": "./dist/util/expect/index.js"
 		},
+		"./util/function": {
+			"types": "./dist/util/function/index.d.ts",
+			"svelte": "./dist/util/function/index.js"
+		},
 		"./util/is": {
 			"types": "./dist/util/is/index.d.ts",
 			"svelte": "./dist/util/is/index.js"
@@ -146,6 +154,10 @@
 			"types": "./dist/util/svelte/index.d.ts",
 			"svelte": "./dist/util/svelte/index.js"
 		},
+		"./util/time": {
+			"types": "./dist/util/time/index.d.ts",
+			"svelte": "./dist/util/time/index.js"
+		},
 		"./util/svelte/observe": {
 			"types": "./dist/util/svelte/observe/index.d.ts",
 			"svelte": "./dist/util/svelte/observe/index.js"