@cratis/fundamentals 7.16.7 → 7.17.0

package/ConceptAs.ts

@@ -1,11 +1,14 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { typeKey } from './typeKey';
 
 /**
  * Expresses a Concept as another type, usually a primitive such as string or number.
  * @template T The type of the underlying value.
  */
 export abstract class ConceptAs<T> {
+    static readonly [typeKey] = 'ConceptAs';
+
     /**
      * Initializes a new instance of ConceptAs.
      * @param {T} value The value to initialize the concept with.

package/DateOnly.ts

@@ -0,0 +1,112 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from './fieldDecorator';
+import { typeKey } from './typeKey';
+
+const dateOnlyRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+/**
+ * Represents a date with no time and no time zone - a day on a calendar.
+ * @remarks
+ * Deliberately not a JavaScript `Date`. A `Date` is an instant, and a calendar date is not one: turning
+ * `2026-05-12` into a `Date` produces UTC midnight, which every browser-local getter west of UTC reads back as
+ * the 11th. That is a wrong answer that looks right, and it is only wrong for users in some time zones - which is
+ * how it survives development in others.
+ *
+ * Holding the three parts the server sent means there is no instant to convert and nothing to shift. Where a
+ * `Date` is genuinely wanted - to feed a date picker, or to do arithmetic - {@link toDate} constructs one in the
+ * local time zone, and the choice is then visible at the call site making it.
+ */
+export class DateOnly {
+    static readonly [typeKey] = 'DateOnly';
+
+    /**
+     * The year.
+     */
+    @field(Number)
+    year!: number;
+
+    /**
+     * The month, 1 through 12.
+     */
+    @field(Number)
+    month!: number;
+
+    /**
+     * The day of the month, 1 through 31.
+     */
+    @field(Number)
+    day!: number;
+
+    /**
+     * Creates a {@link DateOnly} from its parts.
+     * @param year The year.
+     * @param month The month, 1 through 12.
+     * @param day The day of the month.
+     * @returns The {@link DateOnly}.
+     */
+    static from(year: number, month: number, day: number): DateOnly {
+        const dateOnly = new DateOnly();
+        dateOnly.year = year;
+        dateOnly.month = month;
+        dateOnly.day = day;
+        return dateOnly;
+    }
+
+    /**
+     * Parses the ISO-8601 calendar date the server sends, `yyyy-MM-dd`.
+     * @param value The value to parse.
+     * @returns The {@link DateOnly}.
+     */
+    static parse(value: string): DateOnly {
+        const match = dateOnlyRegex.exec(value);
+        if (match === null) {
+            throw new Error(`Invalid DateOnly format: ${value}`);
+        }
+
+        return DateOnly.from(parseInt(match[1], 10), parseInt(match[2], 10), parseInt(match[3], 10));
+    }
+
+    /**
+     * Creates a {@link DateOnly} for the calendar date a {@link Date} falls on in the local time zone.
+     * @param date The date to take the calendar date of.
+     * @returns The {@link DateOnly}.
+     * @remarks
+     * Reads the local parts rather than the UTC ones, because the calendar date a moment falls on is a question
+     * only a time zone can answer, and the local one is the one the person looking at the screen is in.
+     */
+    static fromDate(date: Date): DateOnly {
+        return DateOnly.from(date.getFullYear(), date.getMonth() + 1, date.getDate());
+    }
+
+    /**
+     * Converts to a {@link Date} at midnight in the local time zone.
+     * @returns The {@link Date}.
+     * @remarks
+     * Local rather than UTC, so the date a caller reads back with `getDate()` is the one they started with. This
+     * invents a time that was never sent, which is why it is a method to call rather than what the value is.
+     */
+    toDate(): Date {
+        return new Date(this.year, this.month - 1, this.day);
+    }
+
+    /**
+     * Gets the ISO-8601 representation, `yyyy-MM-dd` - the same form the server sent.
+     * @returns The string.
+     */
+    toString(): string {
+        const month = this.month.toString().padStart(2, '0');
+        const day = this.day.toString().padStart(2, '0');
+        return `${this.year.toString().padStart(4, '0')}-${month}-${day}`;
+    }
+
+    /**
+     * Determines whether this is the same calendar date as another.
+     * @param other The other date.
+     * @returns True when they are the same date.
+     */
+    equals(other: DateOnly | undefined | null): boolean {
+        return !!other && this.year === other.year && this.month === other.month && this.day === other.day;
+    }
+}

package/Guid.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { IEquatable } from './IEquatable';
+import { typeKey } from './typeKey';
 
 const guidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 const lookUpTable: string[] = [];
@@ -22,6 +23,8 @@ const getString = (num: number) => {
  * @class Guid
  */
 export class Guid implements IEquatable {
+    static readonly [typeKey] = 'Guid';
+
 
     /**
      * Gets an empty {Guid}

package/JsonSerializer.ts

@@ -1,16 +1,19 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { ConceptAs } from './ConceptAs';
 import { Constructor } from './Constructor';
 import { DerivedType } from './DerivedType';
+import { registerModuleInstance } from './duplicateInstanceGuard';
 import { Field } from './Field';
 import { Fields } from './Fields';
+import { conceptAsTypeKey, declaredTypeKey, typeKeyOf, valueMapTypeKey } from './typeKey';
 import { ValueMap } from './ValueMap';
 import { 
     JsonConverter, 
     DateJsonConverter, 
+    DateOnlyJsonConverter,
     GuidJsonConverter, 
+    TimeOnlyJsonConverter,
     TimeSpanJsonConverter, 
     PointJsonConverter,
     LineStringJsonConverter,
@@ -22,10 +25,19 @@ import {
 
 type typeSerializer = (value: any) => any;
 
+// A second copy of this package in the same realm builds its own registry here, and brings its own
+// class objects. Convertible values still cross between the copies, because a type is recognized by
+// the key it declares - but a converter registered on one copy reaches only that one, and a version
+// pinned at the top level never reaches a nested copy. Announce it where the state that cannot be
+// shared is built.
+registerModuleInstance();
+
 // Initialize converters
 const converters: JsonConverter[] = [
     new DateJsonConverter(),
+    new DateOnlyJsonConverter(),
     new GuidJsonConverter(),
+    new TimeOnlyJsonConverter(),
     new TimeSpanJsonConverter(),
     new PointJsonConverter(),
     new LineStringJsonConverter(),
@@ -33,14 +45,44 @@ const converters: JsonConverter[] = [
     new ValueMapJsonConverter()
 ];
 
-// Build converter maps from the converters
+// Converters are found by the key a type declares, and only by the constructor when it declares none.
+// Keying on the constructor alone is what made a second copy of this package silently fatal: each copy
+// brings its own Guid, ConceptAs and ValueMap class objects, so neither recognized the other's. A key
+// crosses that boundary; a class object does not. A consumer's own type has no key and is found by
+// constructor, which is exact and needs nothing to cross.
+const keyedConverters: Map<string, JsonConverter> = new Map<string, JsonConverter>();
 const typeConverters: Map<Constructor, JsonConverter> = new Map<Constructor, JsonConverter>();
-const typeSerializers: Map<Constructor, JsonConverter> = new Map<Constructor, JsonConverter>();
 
-for (const converter of converters) {
+const registerConverterFor = (converter: JsonConverter) => {
+    const key = declaredTypeKey(converter.type);
+    if (key !== undefined) {
+        keyedConverters.set(key, converter);
+    }
+
     typeConverters.set(converter.type, converter);
-    typeSerializers.set(converter.type, converter);
-}
+};
+
+converters.forEach(registerConverterFor);
+
+/**
+ * Finds the converter registered for a type, if any.
+ * @param {Constructor} type The type to convert.
+ * @returns {JsonConverter | undefined} The converter, or undefined when the type has none.
+ */
+const converterFor = (type: Constructor | undefined): JsonConverter | undefined => {
+    if (!type) return undefined;
+
+    const key = declaredTypeKey(type);
+    const keyed = key === undefined ? undefined : keyedConverters.get(key);
+    return keyed ?? typeConverters.get(type);
+};
+
+/**
+ * Checks whether a type is a ValueMap, including one from another copy of this package.
+ * @param {Constructor} type The type to check.
+ * @returns {boolean} True when the type is a ValueMap.
+ */
+const isValueMap = (type: Constructor | undefined): boolean => declaredTypeKey(type) === valueMapTypeKey;
 
 // Add primitive type converters that don't need a full JsonConverter class
 const primitiveConverters: Map<Constructor, typeSerializer> = new Map<Constructor, typeSerializer>([
@@ -59,28 +101,19 @@ const primitiveSerializers: Map<Constructor, typeSerializer> = new Map<Construct
  * Checks if a constructor is a ConceptAs type.
  * @param {Constructor} type The constructor to check.
  * @returns {boolean} True if the type extends ConceptAs.
+ * @remarks
+ * Reads the key rather than walking the prototype chain looking for this copy's ConceptAs. The key is a
+ * static and a static is inherited, so every type deriving from ConceptAs carries it - including one
+ * deriving from another copy's ConceptAs, which a prototype walk could never recognize.
  */
-const isConceptAs = (type: Constructor): boolean => {
-    if (!type || !type.prototype) return false;
-    
-    // Check if the prototype chain includes ConceptAs
-    let proto = type.prototype;
-    while (proto) {
-        // Check if this prototype is ConceptAs.prototype
-        if (proto === ConceptAs.prototype) {
-            return true;
-        }
-        proto = Object.getPrototypeOf(proto);
-    }
-    return false;
-};
+const isConceptAs = (type: Constructor): boolean => typeKeyOf(type) === conceptAsTypeKey;
 
 const serializeValueForType = (type: Constructor, value: any) => {
     if (!value) return value;
 
     // If it's a ConceptAs instance, unwrap it and serialize the inner value recursively
     // This follows the C# pattern: recognize as concept, unwrap, then call serializer
-    if (value instanceof ConceptAs) {
+    if (isConceptAs(value.constructor)) {
         const innerValue = value.value;
         // Recursively serialize the inner value to handle complex types
         // Use .constructor directly which works reliably for both primitives and objects
@@ -88,8 +121,8 @@ const serializeValueForType = (type: Constructor, value: any) => {
     }
 
     // Check if there's a registered converter
-    if (typeConverters.has(type)) {
-        const converter = typeConverters.get(type)!;
+    const converter = converterFor(type);
+    if (converter) {
         return converter.write(value);
     }
     
@@ -108,8 +141,8 @@ const deserializeValueFromType = (type: Constructor, value: any) => {
     }
     
     // Check if there's a registered converter
-    if (typeSerializers.has(type)) {
-        const converter = typeSerializers.get(type)!;
+    const converter = converterFor(type);
+    if (converter) {
         return converter.read(value);
     }
     
@@ -122,7 +155,7 @@ const deserializeValueFromType = (type: Constructor, value: any) => {
 };
 
 const deserializeValueFromField = (field: Field, value: any) => {
-    if (field.type === ValueMap) {
+    if (isValueMap(field.type)) {
         return deserializeValueMapFromField(field, value);
     }
 
@@ -132,8 +165,8 @@ const deserializeValueFromField = (field: Field, value: any) => {
     }
 
     // Check if there's a registered converter
-    if (typeSerializers.has(field.type)) {
-        const converter = typeSerializers.get(field.type)!;
+    const converter = converterFor(field.type);
+    if (converter) {
         return converter.read(value);
     }
     
@@ -186,8 +219,8 @@ const deserializeMapKey = (keyType: Constructor, key: string): any => {
     }
 
     // Check if there's a converter for this type
-    if (typeSerializers.has(keyType)) {
-        const converter = typeSerializers.get(keyType)!;
+    const converter = converterFor(keyType);
+    if (converter) {
         return converter.read(key);
     }
 
@@ -199,13 +232,11 @@ const deserializeMapValue = (valueType: Constructor | undefined, value: any): an
         return value;
     }
 
-    // Check if there's a converter for this type
-    if (typeSerializers.has(valueType)) {
-        const converter = typeSerializers.get(valueType)!;
-        return converter.read(value);
-    }
-
-    return JsonSerializer.deserialize(valueType, JSON.stringify(value));
+    // A map value is an ordinary value of its declared type, so read it the way any other value of that
+    // type is read. Resolving it here instead left out the concept and primitive cases, and the
+    // primitive one lost data without a sound: a string value went through JsonSerializer.deserialize,
+    // which built an empty String object because a primitive has no fields to populate.
+    return deserializeValueFromType(valueType, value);
 };
 
 const deserializeValueMapFromField = (field: Field, value: any): ValueMap<any, any> => {
@@ -227,8 +258,16 @@ const deserializeValueMapFromField = (field: Field, value: any): ValueMap<any, a
 };
 
 const convertTypesOnInstance = (instance: any) => {
+    // A concept unwraps to its underlying value wherever it is reached, not only when it is reached
+    // through a declared field. An array element and a map value arrive here rather than at
+    // serializeValueForType, and without this they were written as the object a concept happens to be -
+    // {"value": ...} where the receiver declared the underlying type.
+    if (isConceptAs(instance.constructor)) {
+        return serializeValueForType(instance.constructor as Constructor, instance);
+    }
+
     // Check if there's a converter for this type
-    if (typeConverters.has(instance.constructor)) {
+    if (converterFor(instance.constructor)) {
         return serializeValueForType(instance.constructor, instance);
     }
     
@@ -277,6 +316,27 @@ ValueMapJsonConverter.setHelpers(serializeMapKey, convertTypesOnInstance);
 export class JsonSerializer {
     static readonly DerivedTypeIdProperty: string = "_derivedTypeId";
 
+    /**
+     * Register a converter for the type it declares through its `type` property.
+     * @param {JsonConverter} converter The converter to register.
+     * @remarks
+     * The converter is used for both directions - `read` on the way in, `write` on the way out - and
+     * takes the place of any converter already registered for the same type, including the built-in
+     * ones. Replacing a built-in changes the payloads the application produces and consumes, which is
+     * the caller's to decide; nothing here second-guesses it.
+     *
+     * Two shapes resolve ahead of the converters, so a converter registered for them is not reached:
+     *
+     * - A type deriving from `ConceptAs` is unwrapped to its underlying value in both directions, and
+     *   converted as that value's type. Register for the underlying type to reach a concept.
+     * - A `ValueMap` is read back from the declaring field's generic arguments rather than through a
+     *   converter. Note the asymmetry: writing a `ValueMap` *does* go through the registered converter,
+     *   so replacing that one changes only the outbound half.
+     */
+    static registerConverter(converter: JsonConverter): void {
+        registerConverterFor(converter);
+    }
+
     /**
      * Serialize with strong type information.
      * @param {*} value The value to serialize.
@@ -318,7 +378,7 @@ export class JsonSerializer {
     static deserializeFromInstance<TResult extends object>(targetType: Constructor<TResult>, instance: any): TResult {
         const fields = Fields.getFieldsForType(targetType as Constructor);
 
-        if (typeSerializers.has(targetType)) {
+        if (converterFor(targetType)) {
             return deserializeValueFromType(targetType, instance);
         }
 
@@ -331,6 +391,15 @@ export class JsonSerializer {
                 } else {
                     value = deserializeValueFromField(field, value);
                 }
+            } else if (field.enumerable && value === undefined) {
+                // A collection that is absent from the payload deserializes to an empty one rather than to
+                // undefined. The declared type says the field is an array, and a producer that leaves an
+                // empty collection out - which the Chronicle sink does deliberately, so that a parallel
+                // replay cannot overwrite children a sibling event already wrote - would otherwise hand back
+                // a value contradicting its own type, putting a null guard on every reader of every
+                // collection. An explicit null is left alone: that is the producer saying "no collection"
+                // rather than "an empty one".
+                value = [];
             }
 
             deserialized[field.name] = value;

package/TimeOnly.ts

@@ -0,0 +1,108 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from './fieldDecorator';
+import { typeKey } from './typeKey';
+
+const timeOnlyRegex = /^(\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,7}))?$/;
+
+/**
+ * Represents a time of day with no date and no time zone.
+ * @remarks
+ * Deliberately not a JavaScript `Date`. A `Date` needs a date, and a time of day has none: `new Date('14:30:45')`
+ * is not an instant pinned to some default day, it is `Invalid Date`. The value is destroyed outright rather than
+ * merely shifted, which makes this the starker of the two temporal cases.
+ */
+export class TimeOnly {
+    static readonly [typeKey] = 'TimeOnly';
+
+    /**
+     * The hour, 0 through 23.
+     */
+    @field(Number)
+    hour!: number;
+
+    /**
+     * The minute, 0 through 59.
+     */
+    @field(Number)
+    minute!: number;
+
+    /**
+     * The second, 0 through 59.
+     */
+    @field(Number)
+    second!: number;
+
+    /**
+     * The millisecond, 0 through 999.
+     */
+    @field(Number)
+    millisecond!: number;
+
+    /**
+     * Creates a {@link TimeOnly} from its parts.
+     * @param hour The hour.
+     * @param minute The minute.
+     * @param second The second.
+     * @param millisecond The millisecond.
+     * @returns The {@link TimeOnly}.
+     */
+    static from(hour: number, minute: number, second: number = 0, millisecond: number = 0): TimeOnly {
+        const timeOnly = new TimeOnly();
+        timeOnly.hour = hour;
+        timeOnly.minute = minute;
+        timeOnly.second = second;
+        timeOnly.millisecond = millisecond;
+        return timeOnly;
+    }
+
+    /**
+     * Parses the ISO-8601 time of day the server sends, `HH:mm`, `HH:mm:ss` or `HH:mm:ss.fffffff`.
+     * @param value The value to parse.
+     * @returns The {@link TimeOnly}.
+     * @remarks
+     * The seconds and the fraction are both optional because the server omits them when they are zero, and the
+     * fraction carries up to seven digits where JavaScript holds three - so it is truncated rather than rounded,
+     * which keeps a parse followed by a render from moving the value forward.
+     */
+    static parse(value: string): TimeOnly {
+        const match = timeOnlyRegex.exec(value);
+        if (match === null) {
+            throw new Error(`Invalid TimeOnly format: ${value}`);
+        }
+
+        const fraction = match[4] ? match[4].padEnd(3, '0').substring(0, 3) : '0';
+
+        return TimeOnly.from(
+            parseInt(match[1], 10),
+            parseInt(match[2], 10),
+            match[3] ? parseInt(match[3], 10) : 0,
+            parseInt(fraction, 10));
+    }
+
+    /**
+     * Gets the ISO-8601 representation, `HH:mm:ss` - or `HH:mm:ss.fff` when there is a fractional part.
+     * @returns The string.
+     */
+    toString(): string {
+        const hour = this.hour.toString().padStart(2, '0');
+        const minute = this.minute.toString().padStart(2, '0');
+        const second = this.second.toString().padStart(2, '0');
+        const time = `${hour}:${minute}:${second}`;
+        return this.millisecond > 0 ? `${time}.${this.millisecond.toString().padStart(3, '0')}` : time;
+    }
+
+    /**
+     * Determines whether this is the same time of day as another.
+     * @param other The other time.
+     * @returns True when they are the same time.
+     */
+    equals(other: TimeOnly | undefined | null): boolean {
+        return !!other &&
+            this.hour === other.hour &&
+            this.minute === other.minute &&
+            this.second === other.second &&
+            this.millisecond === other.millisecond;
+    }
+}

package/TimeSpan.ts

@@ -1,6 +1,8 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+import { typeKey } from './typeKey';
+
 import { field } from './fieldDecorator';
 
 const timeSpanRegex = /^(-)?(?:(\d+)\.)?(\d{1,2}):(\d{2}):(\d{2})(?:\.(\d{1,7}))?$/;
@@ -9,6 +11,8 @@ const timeSpanRegex = /^(-)?(?:(\d+)\.)?(\d{1,2}):(\d{2}):(\d{2})(?:\.(\d{1,7}))
  * Represents a time interval.
  */
 export class TimeSpan {
+    static readonly [typeKey] = 'TimeSpan';
+
    
     @field(Number)
     ticks!: number;

package/ValueMap.ts

@@ -1,10 +1,13 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { typeKey } from './typeKey';
 
 /**
  * Represents a map that compares object keys by value.
  */
 export class ValueMap<TKey, TValue> {
+    static readonly [typeKey] = 'ValueMap';
+
     private readonly _entries: Array<[TKey, TValue]> = [];
 
     /**

package/dist/ConceptAs.d.ts

@@ -1,5 +1,7 @@
+import { typeKey } from './typeKey';
 export declare abstract class ConceptAs<T> {
     readonly value: T;
+    static readonly [typeKey] = "ConceptAs";
     constructor(value: T);
     valueOf(): T;
     toString(): string;

package/dist/ConceptAs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConceptAs.d.ts","sourceRoot":"","sources":["../ConceptAs.ts"],"names":[],"mappings":"AAOA,8BAAsB,SAAS,CAAC,CAAC;IAKjB,QAAQ,CAAC,KAAK,EAAE,CAAC;gBAAR,KAAK,EAAE,CAAC;IAM7B,OAAO,IAAI,CAAC;IAQZ,QAAQ,IAAI,MAAM;CAGrB"}
+{"version":3,"file":"ConceptAs.d.ts","sourceRoot":"","sources":["../ConceptAs.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,8BAAsB,SAAS,CAAC,CAAC;IAOjB,QAAQ,CAAC,KAAK,EAAE,CAAC;IAN7B,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,eAAe;gBAMnB,KAAK,EAAE,CAAC;IAM7B,OAAO,IAAI,CAAC;IAQZ,QAAQ,IAAI,MAAM;CAGrB"}

package/dist/ConceptAs.js

@@ -1,5 +1,7 @@
+import { typeKey } from './typeKey';
 export class ConceptAs {
     value;
+    static [typeKey] = 'ConceptAs';
     constructor(value) {
         this.value = value;
     }

package/dist/ConceptAs.js.map

@@ -1 +1 @@
-{"version":3,"file":"ConceptAs.js","sourceRoot":"","sources":["../ConceptAs.ts"],"names":[],"mappings":"AAOA,MAAM,OAAgB,SAAS;IAKN;IAArB,YAAqB,KAAQ;QAAR,UAAK,GAAL,KAAK,CAAG;IAAG,CAAC;IAMjC,OAAO;QACH,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAMD,QAAQ;QACJ,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;CACJ"}
+{"version":3,"file":"ConceptAs.js","sourceRoot":"","sources":["../ConceptAs.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,MAAM,OAAgB,SAAS;IAON;IANrB,MAAM,CAAU,CAAC,OAAO,CAAC,GAAG,WAAW,CAAC;IAMxC,YAAqB,KAAQ;QAAR,UAAK,GAAL,KAAK,CAAG;IAAG,CAAC;IAMjC,OAAO;QACH,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAMD,QAAQ;QACJ,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC"}

package/dist/DateOnly.d.ts

@@ -0,0 +1,14 @@
+import { typeKey } from './typeKey';
+export declare class DateOnly {
+    static readonly [typeKey] = "DateOnly";
+    year: number;
+    month: number;
+    day: number;
+    static from(year: number, month: number, day: number): DateOnly;
+    static parse(value: string): DateOnly;
+    static fromDate(date: Date): DateOnly;
+    toDate(): Date;
+    toString(): string;
+    equals(other: DateOnly | undefined | null): boolean;
+}
+//# sourceMappingURL=DateOnly.d.ts.map

package/dist/DateOnly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DateOnly.d.ts","sourceRoot":"","sources":["../DateOnly.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC,qBAAa,QAAQ;IACjB,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,cAAc;IAMvC,IAAI,EAAG,MAAM,CAAC;IAMd,KAAK,EAAG,MAAM,CAAC;IAMf,GAAG,EAAG,MAAM,CAAC;IASb,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ;IAa/D,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ;IAiBrC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,QAAQ;IAWrC,MAAM,IAAI,IAAI;IAQd,QAAQ,IAAI,MAAM;IAWlB,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO;CAGtD"}

package/dist/DateOnly.js

@@ -0,0 +1,51 @@
+import { __decorate, __metadata } from "tslib";
+import { field } from './fieldDecorator';
+import { typeKey } from './typeKey';
+const dateOnlyRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
+export class DateOnly {
+    static [typeKey] = 'DateOnly';
+    year;
+    month;
+    day;
+    static from(year, month, day) {
+        const dateOnly = new DateOnly();
+        dateOnly.year = year;
+        dateOnly.month = month;
+        dateOnly.day = day;
+        return dateOnly;
+    }
+    static parse(value) {
+        const match = dateOnlyRegex.exec(value);
+        if (match === null) {
+            throw new Error(`Invalid DateOnly format: ${value}`);
+        }
+        return DateOnly.from(parseInt(match[1], 10), parseInt(match[2], 10), parseInt(match[3], 10));
+    }
+    static fromDate(date) {
+        return DateOnly.from(date.getFullYear(), date.getMonth() + 1, date.getDate());
+    }
+    toDate() {
+        return new Date(this.year, this.month - 1, this.day);
+    }
+    toString() {
+        const month = this.month.toString().padStart(2, '0');
+        const day = this.day.toString().padStart(2, '0');
+        return `${this.year.toString().padStart(4, '0')}-${month}-${day}`;
+    }
+    equals(other) {
+        return !!other && this.year === other.year && this.month === other.month && this.day === other.day;
+    }
+}
+__decorate([
+    field(Number),
+    __metadata("design:type", Number)
+], DateOnly.prototype, "year", void 0);
+__decorate([
+    field(Number),
+    __metadata("design:type", Number)
+], DateOnly.prototype, "month", void 0);
+__decorate([
+    field(Number),
+    __metadata("design:type", Number)
+], DateOnly.prototype, "day", void 0);
+//# sourceMappingURL=DateOnly.js.map

package/dist/DateOnly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DateOnly.js","sourceRoot":"","sources":["../DateOnly.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,MAAM,aAAa,GAAG,2BAA2B,CAAC;AAclD,MAAM,OAAO,QAAQ;IACjB,MAAM,CAAU,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC;IAMvC,IAAI,CAAU;IAMd,KAAK,CAAU;IAMf,GAAG,CAAU;IASb,MAAM,CAAC,IAAI,CAAC,IAAY,EAAE,KAAa,EAAE,GAAW;QAChD,MAAM,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC;QAChC,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAC;QACrB,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC;QACvB,QAAQ,CAAC,GAAG,GAAG,GAAG,CAAC;QACnB,OAAO,QAAQ,CAAC;IACpB,CAAC;IAOD,MAAM,CAAC,KAAK,CAAC,KAAa;QACtB,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,4BAA4B,KAAK,EAAE,CAAC,CAAC;QACzD,CAAC;QAED,OAAO,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IACjG,CAAC;IAUD,MAAM,CAAC,QAAQ,CAAC,IAAU;QACtB,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IAClF,CAAC;IASD,MAAM;QACF,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;IACzD,CAAC;IAMD,QAAQ;QACJ,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACrD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACjD,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,KAAK,IAAI,GAAG,EAAE,CAAC;IACtE,CAAC;IAOD,MAAM,CAAC,KAAkC;QACrC,OAAO,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,KAAK,KAAK,CAAC,GAAG,CAAC;IACvG,CAAC;;AAnFD;IADC,KAAK,CAAC,MAAM,CAAC;;sCACA;AAMd;IADC,KAAK,CAAC,MAAM,CAAC;;uCACC;AAMf;IADC,KAAK,CAAC,MAAM,CAAC;;qCACD"}

package/dist/Guid.d.ts

@@ -1,6 +1,8 @@
 import { IEquatable } from './IEquatable';
+import { typeKey } from './typeKey';
 export declare class Guid implements IEquatable {
     readonly bytes: number[] | Uint8Array | undefined;
+    static readonly [typeKey] = "Guid";
     static readonly empty: Guid;
     private _stringVersion;
     constructor(bytes: number[] | Uint8Array | undefined);