shelving 1.152.3 → 1.153.0

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.152.3",
+	"version": "1.153.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/schema/DateSchema.d.ts

@@ -2,19 +2,24 @@ import type { PossibleDate } from "../util/date.js";
 import type { Nullish } from "../util/null.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
+/** `type=""` prop for HTML `<input />` tags that are relevant for dates. */
+export type DateInputType = "time" | "date" | "datetime-local";
 /** Allowed options for `DateSchema` */
 export interface DateSchemaOptions extends SchemaOptions {
     readonly value?: PossibleDate | undefined;
     readonly min?: Nullish<PossibleDate>;
     readonly max?: Nullish<PossibleDate>;
+    readonly input?: DateInputType | undefined;
 }
-/** Define a valid date in YMD format, e.g. `2005-09-12` */
 export declare class DateSchema extends Schema<string> {
     readonly value: PossibleDate;
     readonly min: Date | undefined;
     readonly max: Date | undefined;
-    constructor({ min, max, title, value, ...options }: DateSchemaOptions);
+    readonly input: DateInputType;
+    constructor({ min, max, value, input, ...options }: DateSchemaOptions);
     validate(value?: unknown): string;
+    stringify(value: Date): string;
+    format(value: Date): string;
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */
 export declare const DATE: DateSchema;

package/schema/DateSchema.js

@@ -3,24 +3,31 @@ import { getDate, requireYMD } from "../util/date.js";
 import { formatDate } from "../util/format.js";
 import { NULLABLE } from "./NullableSchema.js";
 import { Schema } from "./Schema.js";
-/** Define a valid date in YMD format, e.g. `2005-09-12` */
 export class DateSchema extends Schema {
     min;
     max;
-    constructor({ min, max, title = "Date", value = "now", ...options }) {
-        super({ title, value, ...options });
+    input;
+    constructor({ min, max, value = "now", input = "datetime-local", ...options }) {
+        super({ title: "Date", value, ...options });
         this.min = getDate(min);
         this.max = getDate(max);
+        this.input = input;
     }
     validate(value = this.value) {
         const date = getDate(value);
         if (!date)
             throw new ValueFeedback(value ? "Invalid date" : "Required", value);
         if (this.min && date < this.min)
-            throw new ValueFeedback(`Minimum ${formatDate(this.min)}`, date);
+            throw new ValueFeedback(`Minimum ${this.format(this.min)}`, date);
         if (this.max && date > this.max)
-            throw new ValueFeedback(`Maximum ${formatDate(this.max)}`, date);
-        return requireYMD(date);
+            throw new ValueFeedback(`Maximum ${this.format(this.max)}`, date);
+        return this.stringify(date);
+    }
+    stringify(value) {
+        return requireYMD(value);
+    }
+    format(value) {
+        return formatDate(value);
     }
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */

package/schema/DateTimeSchema.d.ts

@@ -0,0 +1,13 @@
+import { DateSchema, type DateSchemaOptions } from "./DateSchema.js";
+/** Allowed options for `DateSchema` */
+export interface DateTimeSchemaOptions extends DateSchemaOptions {
+}
+/** Define a valid date in ISO 8601 format, e.g. `2005-09-12T18:15:00.000Z` */
+export declare class DateTimeSchema extends DateSchema {
+    format(value: Date): string;
+    stringify(value: Date): string;
+}
+/** Valid datetime, e.g. `2005-09-12T08:00:00Z` (required because falsy values are invalid). */
+export declare const DATETIME: DateTimeSchema;
+/** Valid datetime, e.g. `2005-09-12T21:30:00Z`, or `null` */
+export declare const NULLABLE_DATETIME: import("./NullableSchema.js").NullableSchema<string>;

package/schema/DateTimeSchema.js

@@ -0,0 +1,16 @@
+import { formatDateTime } from "../util/format.js";
+import { DateSchema } from "./DateSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
+/** Define a valid date in ISO 8601 format, e.g. `2005-09-12T18:15:00.000Z` */
+export class DateTimeSchema extends DateSchema {
+    format(value) {
+        return formatDateTime(value);
+    }
+    stringify(value) {
+        return value.toISOString();
+    }
+}
+/** Valid datetime, e.g. `2005-09-12T08:00:00Z` (required because falsy values are invalid). */
+export const DATETIME = new DateTimeSchema({});
+/** Valid datetime, e.g. `2005-09-12T21:30:00Z`, or `null` */
+export const NULLABLE_DATETIME = NULLABLE(DATETIME);

package/schema/StringSchema.d.ts

@@ -1,7 +1,7 @@
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** `type=""` prop for HTML `<input />` tags that are relevant for strings. */
-export type HTMLInputType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
+export type StringInputType = "text" | "password" | "color" | "email" | "number" | "tel" | "search" | "url";
 /** Options for `StringSchema` */
 export interface StringSchemaOptions extends SchemaOptions {
     readonly value?: string | undefined;
@@ -10,7 +10,7 @@ export interface StringSchemaOptions extends SchemaOptions {
     readonly multiline?: boolean | undefined;
     readonly match?: RegExp | undefined;
     readonly case?: "upper" | "lower" | undefined;
-    readonly input?: HTMLInputType | undefined;
+    readonly input?: StringInputType | undefined;
 }
 /**
  * Schema that defines a valid string.
@@ -29,7 +29,7 @@ export interface StringSchemaOptions extends SchemaOptions {
  */
 export declare class StringSchema extends Schema<string> {
     readonly value: string;
-    readonly input: HTMLInputType;
+    readonly input: StringInputType;
     readonly min: number;
     readonly max: number;
     readonly multiline: boolean;

package/schema/TimeSchema.d.ts

@@ -1,26 +1,18 @@
-import type { Nullish } from "../util/null.js";
-import type { PossibleTime } from "../util/time.js";
-import { Time } from "../util/time.js";
-import type { SchemaOptions } from "./Schema.js";
-import { Schema } from "./Schema.js";
+import { type PossibleDate } from "../util/date.js";
+import { DateSchema, type DateSchemaOptions } from "./DateSchema.js";
 /** Allowed options for `TimeSchama` */
-export interface TimeSchemaOptions extends SchemaOptions {
-    readonly value?: PossibleTime | undefined;
-    readonly min?: Nullish<PossibleTime>;
-    readonly max?: Nullish<PossibleTime>;
-    readonly step?: number | undefined;
+export interface TimeSchemaOptions extends DateSchemaOptions {
+    step?: number | undefined;
 }
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
-export declare class TimeSchema extends Schema<string> {
-    readonly value: PossibleTime;
-    readonly min: Time | undefined;
-    readonly max: Time | undefined;
+export declare class TimeSchema extends DateSchema {
+    readonly value: PossibleDate;
     /**
      * Rounding step (in milliseconds, because that's the base unit for time), e.g. `60000` will round to the nearest second.
      * - Note: `<input type="time">` elements expect `step=""` to be  in _seconds_ so you need to multiply this by `1000`
      */
     readonly step: number | undefined;
-    constructor({ min, max, step, title, value, ...options }: TimeSchemaOptions);
+    constructor({ title, step, ...options }: TimeSchemaOptions);
     validate(unsafeValue?: unknown): string;
 }
 /** Valid time, e.g. `2005-09-12` (required because falsy values are invalid). */

package/schema/TimeSchema.js

@@ -1,33 +1,30 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
+import { getDate, requireTime } from "../util/date.js";
+import { formatTime } from "../util/format.js";
 import { roundStep } from "../util/number.js";
-import { Time, getTime } from "../util/time.js";
+import { DateSchema } from "./DateSchema.js";
 import { NULLABLE } from "./NullableSchema.js";
-import { Schema } from "./Schema.js";
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
-export class TimeSchema extends Schema {
-    min;
-    max;
+export class TimeSchema extends DateSchema {
     /**
      * Rounding step (in milliseconds, because that's the base unit for time), e.g. `60000` will round to the nearest second.
      * - Note: `<input type="time">` elements expect `step=""` to be  in _seconds_ so you need to multiply this by `1000`
      */
     step;
-    constructor({ min, max, step = 60, title = "Time", value = "now", ...options }) {
-        super({ title, value, ...options });
-        this.min = getTime(min);
-        this.max = getTime(max);
+    constructor({ title = "Time", step, ...options }) {
+        super({ title, ...options });
         this.step = step;
     }
     validate(unsafeValue = this.value) {
-        const optionalTime = getTime(unsafeValue);
-        if (!optionalTime)
+        const date = getDate(unsafeValue);
+        if (!date)
             throw new ValueFeedback(unsafeValue ? "Invalid time" : "Required", unsafeValue);
-        const roundedTime = typeof this.step === "number" ? new Time(roundStep(optionalTime.time, this.step)) : optionalTime;
-        if (this.max && roundedTime > this.max)
-            throw new ValueFeedback(`Maximum ${this.max.format()}`, roundedTime);
-        if (this.min && roundedTime < this.min)
-            throw new ValueFeedback(`Minimum ${this.min.format()}`, roundedTime);
-        return roundedTime.long;
+        const rounded = typeof this.step === "number" ? new Date(roundStep(date.getTime(), this.step)) : date;
+        if (this.max && rounded > this.max)
+            throw new ValueFeedback(`Maximum ${formatTime(this.max)}`, rounded);
+        if (this.min && rounded < this.min)
+            throw new ValueFeedback(`Minimum ${formatTime(this.min)}`, rounded);
+        return requireTime(rounded);
     }
 }
 /** Valid time, e.g. `2005-09-12` (required because falsy values are invalid). */

package/schema/index.d.ts

@@ -9,6 +9,7 @@ export * from "./ChoiceSchema.js";
 export * from "./ColorSchema.js";
 export * from "./DataSchema.js";
 export * from "./DateSchema.js";
+export * from "./DateTimeSchema.js";
 export * from "./DictionarySchema.js";
 export * from "./EmailSchema.js";
 export * from "./EntitySchema.js";

package/schema/index.js

@@ -11,6 +11,7 @@ export * from "./ChoiceSchema.js";
 export * from "./ColorSchema.js";
 export * from "./DataSchema.js";
 export * from "./DateSchema.js";
+export * from "./DateTimeSchema.js";
 export * from "./DictionarySchema.js";
 export * from "./EmailSchema.js";
 export * from "./EntitySchema.js";

package/util/date.d.ts

@@ -12,18 +12,18 @@ export declare function assertDate(value: unknown, caller?: AnyCaller): asserts
  * Convert an unknown value to a valid `Date` instance, or return `undefined` if it couldn't be converted.
  * - Note: `Date` instances can be invalid (e.g. `new Date("blah blah").getTime()` returns `NaN`). These are detected and will always return `null`
  *
- * Conversion rules:
+ * @param value Any value that we want to parse as a valid date (defaults to `undefined`).
  * - `Date` instance returns unchanged (BUT if the date isn't valid, `undefined` is returned).
  * - `null` or `undefined` or `""` empty string returns `undefined`
  * - The string `"now"` returns the current date (e.g. `new Date()`).
  * - The string `"today"` returns the current date at midnight (e.g. `getMidnight()`).
  * - The string `"tomorrow"` returns tomorrow's date at midnight (e.g. `addDays(getMidnight(), 1)`).
  * - The string `"yesterday"` returns yesterday's date at midnight (e.g. `addDays(getMidnight(), 1)`).
- * - Strings (e.g. `"2003-09-12"` or `"2003 feb 20:09"`) return the corresponding date (using `new Date(string)`).
+ * - Date strings (e.g. `"2003-09-12"` or `"2003 feb 20:09"`) return the corresponding date (using the user's current locale).
+ * - Time strings (e.g. `"18:32"` or `"23:59:59.999"`) return today's date at that time (using the user's current locale).
  * - Numbers are return the corresponding date (using `new Date(number)`, i.e. milliseconds since 01/01/1970).
  * - Anything else returns `undefined`
  *
- * @param value Any value that we want to parse as a valid date (defaults to `undefined`).
  * @returns `Date` instance if the value could be converted to a valid date, and `null` if not.
  */
 export declare function getDate(value: unknown): Date | undefined;
@@ -46,8 +46,12 @@ export declare function getTimestamp(value?: unknown): number | undefined;
 export declare function requireTimestamp(value?: PossibleDate): number;
 /** Convert an unknown value to a YMD date string like "2015-09-12", or `undefined` if it couldn't be converted. */
 export declare function getYMD(value?: unknown): string | undefined;
-/** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `RequiredError` if it couldn't be converted.  */
+/** Convert a possible `Date` instance to a YMD string like "2015-09-12", or throw `RequiredError` if it couldn't be converted.  */
 export declare function requireYMD(value?: PossibleDate, caller?: AnyCaller): string;
+/** Convert an unknown value to a HMS time string like "18:32:00", or `undefined` if it couldn't be converted. */
+export declare function getTime(value?: unknown): string | undefined;
+/** Convert a possible `Date` instance to an HMS string like "18:32:00", or throw `RequiredError` if it couldn't be converted. */
+export declare function requireTime(value?: PossibleDate, caller?: AnyCaller): string;
 /** List of day-of-week strings. */
 export declare const DAYS: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
 /** Type listing day-of-week strings. */

package/util/date.js

@@ -17,18 +17,18 @@ export function assertDate(value, caller = assertDate) {
  * Convert an unknown value to a valid `Date` instance, or return `undefined` if it couldn't be converted.
  * - Note: `Date` instances can be invalid (e.g. `new Date("blah blah").getTime()` returns `NaN`). These are detected and will always return `null`
  *
- * Conversion rules:
+ * @param value Any value that we want to parse as a valid date (defaults to `undefined`).
  * - `Date` instance returns unchanged (BUT if the date isn't valid, `undefined` is returned).
  * - `null` or `undefined` or `""` empty string returns `undefined`
  * - The string `"now"` returns the current date (e.g. `new Date()`).
  * - The string `"today"` returns the current date at midnight (e.g. `getMidnight()`).
  * - The string `"tomorrow"` returns tomorrow's date at midnight (e.g. `addDays(getMidnight(), 1)`).
  * - The string `"yesterday"` returns yesterday's date at midnight (e.g. `addDays(getMidnight(), 1)`).
- * - Strings (e.g. `"2003-09-12"` or `"2003 feb 20:09"`) return the corresponding date (using `new Date(string)`).
+ * - Date strings (e.g. `"2003-09-12"` or `"2003 feb 20:09"`) return the corresponding date (using the user's current locale).
+ * - Time strings (e.g. `"18:32"` or `"23:59:59.999"`) return today's date at that time (using the user's current locale).
  * - Numbers are return the corresponding date (using `new Date(number)`, i.e. milliseconds since 01/01/1970).
  * - Anything else returns `undefined`
  *
- * @param value Any value that we want to parse as a valid date (defaults to `undefined`).
  * @returns `Date` instance if the value could be converted to a valid date, and `null` if not.
  */
 export function getDate(value) {
@@ -46,6 +46,9 @@ export function getDate(value) {
         const date = new Date(value);
         if (Number.isFinite(date.getTime()))
             return date;
+        const time = new Date(`${requireYMD()}T${value}`);
+        if (Number.isFinite(time.getTime()))
+            return time;
     }
 }
 /** Get a date representing this exact moment. */
@@ -95,18 +98,25 @@ export function getYMD(value) {
     if (date)
         return _ymd(date);
 }
-/** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `RequiredError` if it couldn't be converted.  */
+/** Convert a possible `Date` instance to a YMD string like "2015-09-12", or throw `RequiredError` if it couldn't be converted.  */
 export function requireYMD(value, caller = requireYMD) {
     return _ymd(requireDate(value, caller));
 }
 function _ymd(date) {
-    const y = _pad(date.getUTCFullYear(), 4);
-    const m = _pad(date.getUTCMonth() + 1, 2);
-    const d = _pad(date.getUTCDate(), 2);
-    return `${y}-${m}-${d}`;
+    return date.toISOString().slice(0, 10);
+}
+/** Convert an unknown value to a HMS time string like "18:32:00", or `undefined` if it couldn't be converted. */
+export function getTime(value) {
+    const date = getDate(value);
+    if (date)
+        return _hms(date);
+}
+/** Convert a possible `Date` instance to an HMS string like "18:32:00", or throw `RequiredError` if it couldn't be converted. */
+export function requireTime(value, caller = requireTime) {
+    return _hms(requireDate(value, caller));
 }
-function _pad(num, size) {
-    return num.toString(10).padStart(size, "0000");
+function _hms(date) {
+    return date.toISOString().slice(11, 19);
 }
 /** List of day-of-week strings. */
 export const DAYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];

package/util/format.d.ts

@@ -1,7 +1,6 @@
 import { type ImmutableArray } from "./array.js";
 import { type PossibleDate } from "./date.js";
 import { type ImmutableObject } from "./object.js";
-import { type PossibleTime } from "./time.js";
 import { type PossibleURL } from "./url.js";
 /** Format a number range (based on the user's browser language settings). */
 export declare function formatRange(min: number, max: number, options?: Intl.NumberFormatOptions): string;
@@ -30,9 +29,11 @@ export declare function formatObject(obj: ImmutableObject): string;
 /** Format an unknown array as a string. */
 export declare function formatArray(arr: ImmutableArray<unknown>, separator?: string): string;
 /** Format a date in the browser locale. */
-export declare function formatDate(date: PossibleDate): string;
-/** Format a time as a string based on the browser locale settings. */
-export declare function formatTime(time?: PossibleTime, precision?: 2 | 3 | 4 | 5 | 6): string;
+export declare function formatDate(date: PossibleDate, options?: Intl.DateTimeFormatOptions): string;
+/** Format a time in the browser locale (no seconds by default). */
+export declare function formatTime(time?: PossibleDate, options?: Intl.DateTimeFormatOptions): string;
+/** Format a datetime in the browser locale (no seconds by default). */
+export declare function formatDateTime(date: PossibleDate, options?: Intl.DateTimeFormatOptions): string;
 /** Format a URL as a user-friendly string, e.g. `http://shax.com/test?uid=129483` → `shax.com/test` */
 export declare function formatURL(possible: PossibleURL, base?: PossibleURL): string;
 /**
@@ -40,7 +41,7 @@ export declare function formatURL(possible: PossibleURL, base?: PossibleURL): st
  * - Strings return the string.
  * - Booleans return `"Yes"` or `"No"`
  * - Numbers return formatted number with commas etc (e.g. `formatNumber()`).
- * - Dates return formatted date (e.g. `formatDate()`).
+ * - Dates return formatted datetime (e.g. `formatDateTime()`).
  * - Arrays return the array items converted to string (with `toTitle()`), and joined with a comma.
  * - Objects return...
  *   1. `object.name` if it exists, or

package/util/format.js

@@ -3,7 +3,6 @@ import { NNBSP } from "./constants.js";
 import { isDate, requireDate } from "./date.js";
 import { getPercent } from "./number.js";
 import { isObject } from "./object.js";
-import { requireTime } from "./time.js";
 import { requireURL } from "./url.js";
 /** Format a number range (based on the user's browser language settings). */
 export function formatRange(min, max, options) {
@@ -24,8 +23,10 @@ export function formatNumber(num, options) {
 }
 /** Format a number with a longer full-word suffix. */
 export function pluralizeQuantity(num, singular, plural, options) {
-    const o = { ...options, style: "decimal" };
-    const qty = formatNumber(num, o);
+    const qty = formatNumber(num, {
+        ...options,
+        style: "decimal",
+    });
     return `${qty}${NNBSP}${num === 1 ? singular : plural}`;
 }
 /**
@@ -37,8 +38,12 @@ export function pluralizeQuantity(num, singular, plural, options) {
  * @param denumerator The number representing the whole amount.
  */
 export function formatPercent(numerator, denumerator, options) {
-    const fullOptions = { style: "percent", maximumFractionDigits: 0, roundingMode: "trunc", ...options };
-    return formatNumber(getPercent(numerator, denumerator), fullOptions);
+    return formatNumber(getPercent(numerator, denumerator), {
+        maximumFractionDigits: 0,
+        roundingMode: "trunc",
+        ...options,
+        style: "percent",
+    });
 }
 /**
  * Format an unknown object as a string.
@@ -65,12 +70,29 @@ export function formatArray(arr, separator = ", ") {
     return arr.map(formatValue).join(separator);
 }
 /** Format a date in the browser locale. */
-export function formatDate(date) {
-    return requireDate(date, formatDate).toLocaleDateString();
+export function formatDate(date, options) {
+    return requireDate(date, formatDate).toLocaleDateString(undefined, options);
 }
-/** Format a time as a string based on the browser locale settings. */
-export function formatTime(time, precision = 2) {
-    return requireTime(time, formatTime).format(precision);
+/** Format a time in the browser locale (no seconds by default). */
+export function formatTime(time, options) {
+    return requireDate(time, formatTime).toLocaleTimeString(undefined, {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: undefined, // No seconds by default.
+        ...options,
+    });
+}
+/** Format a datetime in the browser locale (no seconds by default). */
+export function formatDateTime(date, options) {
+    return requireDate(date, formatDateTime).toLocaleString(undefined, {
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+        // No seconds by default.
+        ...options,
+    });
 }
 /** Format a URL as a user-friendly string, e.g. `http://shax.com/test?uid=129483` → `shax.com/test` */
 export function formatURL(possible, base) {
@@ -82,7 +104,7 @@ export function formatURL(possible, base) {
  * - Strings return the string.
  * - Booleans return `"Yes"` or `"No"`
  * - Numbers return formatted number with commas etc (e.g. `formatNumber()`).
- * - Dates return formatted date (e.g. `formatDate()`).
+ * - Dates return formatted datetime (e.g. `formatDateTime()`).
  * - Arrays return the array items converted to string (with `toTitle()`), and joined with a comma.
  * - Objects return...
  *   1. `object.name` if it exists, or
@@ -104,7 +126,7 @@ export function formatValue(value) {
     if (typeof value === "function")
         return "Function";
     if (isDate(value))
-        return formatDate(value);
+        return formatDateTime(value);
     if (isArray(value))
         return formatArray(value);
     if (isObject(value))

package/util/index.d.ts

@@ -50,7 +50,6 @@ export * from "./source.js";
 export * from "./start.js";
 export * from "./string.js";
 export * from "./template.js";
-export * from "./time.js";
 export * from "./timeout.js";
 export * from "./transform.js";
 export * from "./undefined.js";

package/util/index.js

@@ -50,7 +50,6 @@ export * from "./source.js";
 export * from "./start.js";
 export * from "./string.js";
 export * from "./template.js";
-export * from "./time.js";
 export * from "./timeout.js";
 export * from "./transform.js";
 export * from "./undefined.js";

package/util/time.d.ts

@@ -1,48 +0,0 @@
-import type { AnyCaller } from "./function.js";
-/** Class representing a time in the day in 24 hour format in the user's current locale. */
-export declare class Time {
-    /** Make a new `Time` instance from a time string. */
-    static from(value: unknown): Time | undefined;
-    readonly time: number;
-    constructor(time: number);
-    /** Get the number of hours in this time. */
-    get h(): number;
-    /** Get the number of minutes in this time. */
-    get m(): number;
-    /** Get the number of seconds in this time. */
-    get s(): number;
-    /** Get the number of seconds in this time. */
-    get ms(): number;
-    /** Get the time as in `hh:mm` format (hours, minutes), e.g. `13.59` */
-    get short(): string;
-    /** Get the time in `hh:mm:ss` format (hours, minutes seconds), e.g. `13.16.19.123` */
-    get medium(): string;
-    /** Get this time in `hh:mm:ss.fff` format (ISO 8601 compatible, hours, minutes, seconds, milliseconds), e.g. `13:16:19.123` */
-    get long(): string;
-    /** Get a date corresponding to this time. */
-    get date(): Date;
-    /**
-     * Format this time using the browser locale settings with a specified amount of precision.
-     * @param precision Reveal additional parts of the time, e.g. `2` shows hours and minutes, `3` also shows seconds, and `4 | 5 | 6` show mlliseconds at increasing precision.
-     */
-    format(precision?: 2 | 3 | 4 | 5 | 6): string;
-    valueOf(): number;
-    toString(): string;
-}
-/** Values that can be converted to times. */
-export type PossibleTime = Time | Date | number | string;
-/** Is an unknown value a `Time` instance. */
-export declare function isTime(value: unknown): value is Time;
-/**
- * Convert a value to a `Time` instance, or return `undefined` if it couldn't be converted.
- * - Works with possible dates, e.g. `now` or `Date` or `2022-09-12 18:32` or `19827263567`
- * - Works with time strings, e.g. `18:32` or `23:59:59.999`
- *
- * @param value Any value that we want to parse as a valid time (defaults to `undefined`).
- */
-export declare function getTime(value: unknown): Time | undefined;
-/**
- * Convert a possible date to a `Time` instance, or throw `ValueError` if it couldn't be converted (defaults to `"now"`).
- * @param value Any value that we want to parse as a valid time (defaults to `"now"`).
- */
-export declare function requireTime(value?: PossibleTime, caller?: AnyCaller): Time;

package/util/time.js

@@ -1,115 +0,0 @@
-import { ValueError } from "../error/ValueError.js";
-import { DAY, HOUR, MINUTE, SECOND } from "./constants.js";
-import { getDate } from "./date.js";
-import { wrapNumber } from "./number.js";
-/** Class representing a time in the day in 24 hour format in the user's current locale. */
-export class Time {
-    /** Make a new `Time` instance from a time string. */
-    static from(value) {
-        if (value === undefined || value === null || value === "")
-            return undefined;
-        if (isTime(value))
-            return value;
-        if (typeof value === "string") {
-            const matches = value.match(TIME_REGEXP);
-            if (matches) {
-                const [, h, m, s, ms] = matches;
-                return new Time(Number.parseInt(h, 10) * HOUR +
-                    Number.parseInt(m, 10) * MINUTE +
-                    (typeof s === "string" ? Number.parseInt(s, 10) * SECOND : 0) +
-                    (typeof ms === "string" ? Number.parseInt(ms, 10) : 0));
-            }
-        }
-        const date = getDate(value);
-        if (date)
-            return new Time(date.getHours() * HOUR + date.getMinutes() * MINUTE + date.getSeconds() * SECOND + date.getMilliseconds());
-    }
-    /* Total number of milliseconds in this time (always a number between `0` and `86400000` because higher/lower numbers wrap into the next/previous day). */
-    time;
-    constructor(time) {
-        this.time = wrapNumber(Math.round(time), 0, DAY);
-    }
-    /** Get the number of hours in this time. */
-    get h() {
-        return Math.trunc(this.time / HOUR);
-    }
-    /** Get the number of minutes in this time. */
-    get m() {
-        return Math.trunc((this.time % HOUR) / MINUTE);
-    }
-    /** Get the number of seconds in this time. */
-    get s() {
-        return Math.trunc((this.time % MINUTE) / SECOND);
-    }
-    /** Get the number of seconds in this time. */
-    get ms() {
-        return this.time % SECOND;
-    }
-    /** Get the time as in `hh:mm` format (hours, minutes), e.g. `13.59` */
-    get short() {
-        return `${_pad(this.h, 2)}:${_pad(this.m, 2)}`;
-    }
-    /** Get the time in `hh:mm:ss` format (hours, minutes seconds), e.g. `13.16.19.123` */
-    get medium() {
-        return `${_pad(this.h, 2)}:${_pad(this.m, 2)}:${_pad(this.s, 2)}`;
-    }
-    /** Get this time in `hh:mm:ss.fff` format (ISO 8601 compatible, hours, minutes, seconds, milliseconds), e.g. `13:16:19.123` */
-    get long() {
-        return `${_pad(this.h, 2)}:${_pad(this.m, 2)}:${_pad(this.s, 2)}.${_pad(this.ms, 3)}`;
-    }
-    /** Get a date corresponding to this time. */
-    get date() {
-        const date = new Date();
-        date.setHours(this.h, this.m, this.s, this.ms);
-        return date;
-    }
-    /**
-     * Format this time using the browser locale settings with a specified amount of precision.
-     * @param precision Reveal additional parts of the time, e.g. `2` shows hours and minutes, `3` also shows seconds, and `4 | 5 | 6` show mlliseconds at increasing precision.
-     */
-    format(precision = 2) {
-        return this.date.toLocaleTimeString(undefined, {
-            hour: "2-digit",
-            minute: "2-digit",
-            second: precision >= 3 ? "2-digit" : undefined,
-            fractionalSecondDigits: precision >= 4 ? (precision - 3) : undefined,
-        });
-    }
-    // Implement `valueOf()`
-    valueOf() {
-        return this.time;
-    }
-    // Implement `toString()`
-    toString() {
-        return this.long;
-    }
-}
-function _pad(num, size) {
-    return num.toString(10).padStart(size, "0000");
-}
-/** Regular expression that matches a time in ISO 8601 format. */
-const TIME_REGEXP = /([0-9]+):([0-9]+)(?::([0-9]+)(?:.([0-9]+))?)?/;
-/** Is an unknown value a `Time` instance. */
-export function isTime(value) {
-    return value instanceof Time;
-}
-/**
- * Convert a value to a `Time` instance, or return `undefined` if it couldn't be converted.
- * - Works with possible dates, e.g. `now` or `Date` or `2022-09-12 18:32` or `19827263567`
- * - Works with time strings, e.g. `18:32` or `23:59:59.999`
- *
- * @param value Any value that we want to parse as a valid time (defaults to `undefined`).
- */
-export function getTime(value) {
-    return Time.from(value);
-}
-/**
- * Convert a possible date to a `Time` instance, or throw `ValueError` if it couldn't be converted (defaults to `"now"`).
- * @param value Any value that we want to parse as a valid time (defaults to `"now"`).
- */
-export function requireTime(value = "now", caller = requireTime) {
-    const time = Time.from(value);
-    if (!time)
-        throw new ValueError("Invalid time", { received: value, caller });
-    return time;
-}