@hkdigital/lib-sveltekit 0.0.31

package/dist/util/time.js__

@@ -0,0 +1,330 @@
+/**
+ * time.js
+ *
+ * @description
+ * This file contains time related functionality
+ *
+ * @example
+ *
+ *   import { delay, now } from './time.js';
+ *
+ *   async function test()
+ *   {
+ *     console.log( `Current timestamp [${now()}]` );
+ *
+ *     await delay( 1000 );
+ *
+ *     console.log( `Current timestamp [${now()}]` );
+ *   }
+ */
+
+/**
+ * FIXME: use Intl.DateTimeFormat instead of custom conversions
+ *
+ *  e.g.
+ *   return new Intl.DateTimeFormat('nl-NL', {
+ *     month: "long",
+ *    timeZone: 'Europe/Amsterdam'
+ *   }).format(d);
+ */
+
+/* ------------------------------------------------------------------ Imports */
+
+// import { expectPositiveNumber } from './expect.js';
+// import { HkPromise } from './promises.js';
+
+/* ---------------------------------------------------------------- Internals */
+
+/* ------------------------------------------------------------------ Exports */
+
+/**
+ * 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, 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;
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * 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 = TIME_2020_01_01) {
+  return Date.now() - sinceMs;
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * 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) {
+  const days = Math.floor(timeMs / DAY_MS);
+
+  let restMs = timeMs - days * DAY_MS;
+
+  const hours = Math.floor(restMs / HOUR_MS);
+
+  restMs = restMs - hours * HOUR_MS;
+
+  const minutes = Math.floor(restMs / MINUTE_MS);
+
+  restMs = restMs - minutes * MINUTE_MS;
+
+  const seconds = Math.floor(restMs / SECOND_MS);
+
+  restMs = restMs - seconds * SECOND_MS;
+
+  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')}:`;
+  }
+
+  str += `${minutes.toString().padStart(2, '0')}:`;
+  str += `${seconds.toString().padStart(2, '0')}.`;
+  str += `${restMs.toString().padEnd(3, '0')}`;
+
+  return str;
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * 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) {
+  if (dateOrTimestamp instanceof Date) {
+    return dateOrTimestamp;
+  }
+
+  if (typeof dateOrTimestamp === 'number') {
+    return new Date(dateOrTimestamp);
+  }
+
+  throw new Error('Missing or invalid parameter [dateOrTimestamp]');
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * 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) {
+  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);
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * 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) {
+  return MONTH_NAME_LABELS_EN[toDate(dateOrTimestamp).getMonth()];
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * 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) {
+  return DAY_NAME_LABELS_EN[toDate(dateOrTimestamp).getDay()];
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * 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) {
+  let d;
+
+  if (dateOrTimestamp) {
+    d = toDate(dateOrTimestamp);
+  } else {
+    // today, now
+    d = new Date();
+  }
+
+  d.setHours(0);
+  d.setMinutes(0);
+  d.setSeconds(0);
+  d.setMilliseconds(0);
+
+  return d.getTime();
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * 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) {
+  let d;
+
+  if (dateOrTimestamp) {
+    d = toDate(dateOrTimestamp);
+  } else {
+    // today, now
+    d = new Date();
+  }
+
+  d.setHours(23);
+  d.setMinutes(59);
+  d.setSeconds(59);
+  d.setMilliseconds(999);
+
+  return d.getTime();
+}

package/dist/valibot/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./user.js";
+export default v;
+import * as v from 'valibot';

package/dist/valibot/index.js

@@ -0,0 +1,30 @@
+/**
+ * The following namespace style import can be used to acces the named exports
+ * and als the JSdoc typedefs
+ *
+ * @example
+ *
+ * import * as Zods from '<path-to>/zod/all.js';
+ *
+ * JSdoc:
+ * `@param {Zods.Name} name
+ * `@param {Zods.Timeout} t
+ *
+ * Assert style:
+ * Zods.String.parse(name);
+ *
+ * Parse style:
+ * const name = Zods.Name.parse('Jens ');
+ *
+ * Use default export 'z':
+ * // eslint-disable-next-line no-unused-vars
+ * import z, * as Zods from '<path-to>/zod/all.js';
+ *
+ * z.string().parse(name);
+ */
+
+import * as v from 'valibot';
+
+export * from './user.js';
+
+export default v;

package/dist/valibot/user.d.ts

@@ -0,0 +1,6 @@
+export const Name: v.SchemaWithPipe<[v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, undefined>]>;
+export const Fullname: v.SchemaWithPipe<[v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, undefined>]>;
+export const Username: v.SchemaWithPipe<[v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, undefined>]>;
+export const Surname: v.SchemaWithPipe<[v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, undefined>]>;
+export const PhoneNumber: v.SchemaWithPipe<[v.StringSchema<undefined>, v.TrimAction, v.RegexAction<string, undefined>]>;
+import * as v from 'valibot';

package/dist/valibot/user.js

@@ -0,0 +1,23 @@
+// > Imports
+
+import * as v from 'valibot';
+
+import {
+	RE_FULLNAME,
+	RE_NAME,
+	RE_USERNAME,
+	RE_SURNAME,
+	RE_PHONENUMBER
+} from '../constants/regexp/index.js';
+
+// > Exports
+
+export const Name = v.pipe(v.string(), v.trim(), v.regex(RE_NAME));
+
+export const Fullname = v.pipe(v.string(), v.trim(), v.regex(RE_FULLNAME));
+
+export const Username = v.pipe(v.string(), v.trim(), v.regex(RE_USERNAME));
+
+export const Surname = v.pipe(v.string(), v.trim(), v.regex(RE_SURNAME));
+
+export const PhoneNumber = v.pipe(v.string(), v.trim(), v.regex(RE_PHONENUMBER));

package/dist/zod/all.d.ts

@@ -0,0 +1,6 @@
+export * from "./generic.js";
+export * from "./javascript.js";
+export * from "./user.js";
+export * from "./web.js";
+export default z;
+import { z } from 'zod';

package/dist/zod/all.js

@@ -0,0 +1,33 @@
+/**
+ * The following namespace style import can be used to acces the named exports
+ * and als the JSdoc typedefs
+ *
+ * @example
+ *
+ * import * as Zods from '<path-to>/zod/all.js';
+ *
+ * JSdoc:
+ * `@param {Zods.Name} name
+ * `@param {Zods.Timeout} t
+ *
+ * Assert style:
+ * Zods.String.parse(name);
+ *
+ * Parse style:
+ * const name = Zods.Name.parse('Jens ');
+ *
+ * Use default export 'z':
+ * // eslint-disable-next-line no-unused-vars
+ * import z, * as Zods from '<path-to>/zod/all.js';
+ *
+ * z.string().parse(name);
+ */
+
+import { z } from 'zod';
+
+export * from './generic.js';
+export * from './javascript.js';
+export * from './user.js';
+export * from './web.js';
+
+export default z;

package/dist/zod/generic.d.ts

@@ -0,0 +1,6 @@
+export type Label = string;
+export const Label: z.ZodString;
+export type LabelOrSymbol = string | Symbol;
+/** @typedef {string} Label */
+export const LabelOrSymbol: z.ZodUnion<[z.ZodString, z.ZodSymbol]>;
+import { z } from 'zod';

package/dist/zod/generic.js

@@ -0,0 +1,11 @@
+// > Imports
+
+import { z } from 'zod';
+
+// > Exports
+
+export const Label = z.string().min(1).max(80);
+/** @typedef {string} Label */
+
+export const LabelOrSymbol = z.union([z.string().min(1).max(80), z.symbol()]);
+/** @typedef {string|Symbol} LabelOrSymbol */

package/dist/zod/javascript.d.ts

@@ -0,0 +1,8 @@
+export type Timeout = number | NodeJS.Timeout;
+export const Timeout: z.ZodNumber;
+export type TimeoutOrUndefined = number | NodeJS.Timeout | undefined;
+/** @typedef {number|NodeJS.Timeout} Timeout */
+export const TimeoutOrUndefined: z.ZodUnion<[z.ZodNumber, z.ZodUndefined]>;
+declare const _default: {};
+export default _default;
+import { z } from 'zod';

package/dist/zod/javascript.js

@@ -0,0 +1,32 @@
+/**
+ * The following namespace style import can be used to acces the named exports
+ * and als the JSdoc typedefs
+ *
+ * import z, * as Zods from '<path-to>/all.js';
+ *
+ * @example
+ *
+ *  JSdoc:
+ *  `@param {Type.Name} name
+ *
+ *  Assert style:
+ *  Type.String.parse(name);
+ *
+ *  Parse style:
+ *  const name = Type.Name.parse('Jens ');
+ */
+
+// > Imports
+
+import { z } from 'zod';
+
+// > Exports
+
+export const Timeout = z.number();
+/** @typedef {number|NodeJS.Timeout} Timeout */
+
+export const TimeoutOrUndefined = z.union([z.number(), z.undefined()]);
+/** @typedef {number|NodeJS.Timeout|undefined} TimeoutOrUndefined */
+
+// Export default is required for exporting typedefs
+export default {};

package/dist/zod/user.d.ts

@@ -0,0 +1,9 @@
+export type Name = z.infer<typeof Name>;
+export const Name: z.ZodString;
+export type Fullname = z.infer<typeof Fullname>;
+/** @typedef { z.infer<typeof Name> } Name */
+export const Fullname: z.ZodString;
+export type Username = z.infer<typeof Username>;
+/** @typedef { z.infer<typeof Fullname> } Fullname */
+export const Username: z.ZodString;
+import { z } from 'zod';

package/dist/zod/user.js

@@ -0,0 +1,16 @@
+// > Imports
+
+import { z } from 'zod';
+
+import { RE_FULLNAME, RE_NAME, RE_USERNAME } from '../constants/regexp/index.js';
+
+// > Exports
+
+export const Name = z.string().trim().regex(RE_NAME);
+/** @typedef { z.infer<typeof Name> } Name */
+
+export const Fullname = z.string().trim().regex(RE_FULLNAME);
+/** @typedef { z.infer<typeof Fullname> } Fullname */
+
+export const Username = z.string().trim().regex(RE_USERNAME);
+/** @typedef { z.infer<typeof Username> } Username */

package/dist/zod/web.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Parse Url
+ * - Allows relative urls (only the pathname and a search part of an url)
+ * - Require the use of the HTTP(s) protocol in absolute URL's
+ *
+ * @param {object} _
+ * @param {boolean} [_.allowRelative=true]
+ * @param {boolean} [_.requireHttp=true]
+ *
+ * @returns {{ parse:function }}
+ */
+export function UrlOrPath({ allowRelative, requireHttp }?: {
+    allowRelative?: boolean;
+    requireHttp?: boolean;
+}): {
+    parse: Function;
+};
+export type AbsOrRelUrl = string;
+export const AbsOrRelUrl: {
+    parse: Function;
+};

package/dist/zod/web.js

@@ -0,0 +1,57 @@
+// > Imports
+
+import { z } from 'zod';
+
+// > Exports
+
+/**
+ * Parse Url
+ * - Allows relative urls (only the pathname and a search part of an url)
+ * - Require the use of the HTTP(s) protocol in absolute URL's
+ *
+ * @param {object} _
+ * @param {boolean} [_.allowRelative=true]
+ * @param {boolean} [_.requireHttp=true]
+ *
+ * @returns {{ parse:function }}
+ */
+export function UrlOrPath({ allowRelative = true, requireHttp = true } = {}) {
+  // > URL parser
+  return z.string().refine((value) => {
+    let url;
+
+    try {
+      if (!allowRelative) {
+        // > Ensure that URL is absolute
+        url = new URL(value);
+
+        if (requireHttp) {
+          // > Ensure that protocol is http(s)
+          if (url.protocol.startsWith('http')) {
+            return null;
+          }
+        }
+
+        return (
+          `${url.origin}${url.pathname}` +
+          `${url.search.length <= 1 ? '' : url.search}`
+        );
+      } else {
+        // > Parse relative URL
+        // @note removes ../../ parts
+
+        url = new URL(value, 'http://localhost');
+
+        return (
+          `${url.pathname}` + `${url.search.length <= 1 ? '' : url.search}`
+        );
+      }
+      // eslint-disable-next-line no-unused-vars
+    } catch (e) {
+      return null;
+    }
+  });
+}
+
+export const AbsOrRelUrl = UrlOrPath();
+/** @typedef {string} AbsOrRelUrl */