@haskou/value-objects 6.1.1 → 7.0.0

package/dist/index.cjs

@@ -0,0 +1,1244 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let buffer = require("buffer");
+let uuid = require("uuid");
+//#region src/errors/BaseError.ts
+var BaseError = class BaseError extends Error {
+	isBaseError = true;
+	static isBaseError(error) {
+		return !!error.isBaseError;
+	}
+	constructor(message, prototype = BaseError.prototype) {
+		super(message);
+		this.name = this.constructor.name;
+		Object.setPrototypeOf(this, prototype);
+	}
+	toString() {
+		return `[${this.name}]: ${this.message}`;
+	}
+	getStack() {
+		return this.stack || "";
+	}
+};
+//#endregion
+//#region src/errors/DomainError.ts
+var DomainError = class extends BaseError {
+	isDomainError = true;
+	static isDomainError(error) {
+		return !!error.isDomainError;
+	}
+	constructor(message) {
+		super(message, new.target.prototype);
+	}
+};
+//#endregion
+//#region src/errors/InvalidColorError.ts
+var InvalidColorError = class extends DomainError {
+	constructor(value) {
+		super(`Invalid color value: ${value}. Must be a valid hex color code.`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidDayError.ts
+var InvalidDayError = class extends DomainError {
+	constructor(invalidDay) {
+		super(`Invalid day ${String(invalidDay)}`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidDayFormatError.ts
+var InvalidDayFormatError = class extends DomainError {
+	constructor(invalidDate) {
+		super(`Invalid day ${invalidDate}. Expected YYYY-MM-DD. `);
+	}
+};
+//#endregion
+//#region src/errors/InvalidHourError.ts
+var InvalidHourError = class extends DomainError {
+	constructor() {
+		super(`Invalid hour`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidEmailError.ts
+var InvalidEmailError = class extends DomainError {
+	constructor(value) {
+		super(`Invalid email format: ${value}`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidFormatError.ts
+var InvalidFormatError = class extends DomainError {
+	constructor(value) {
+		super(`Invalid Format Error with value: '${value}'`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidHashError.ts
+var InvalidHashError = class extends DomainError {
+	constructor(type, value) {
+		super(`Invalid ${type} hash: ${value}`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidIntegerError.ts
+var InvalidIntegerError = class extends DomainError {
+	constructor(value) {
+		super(`Invalid integer value ${value}`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidLatitudeError.ts
+var InvalidLatitudeError = class extends DomainError {
+	constructor(value) {
+		super(`Invalid latitude: ${value}. Must be between -90 and 90`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidLongitudeError.ts
+var InvalidLongitudeError = class extends DomainError {
+	constructor(value) {
+		super(`Invalid longitude: ${value}. Must be between -180 and 180`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidMinutesError.ts
+var InvalidMinutesError = class extends DomainError {
+	constructor() {
+		super(`Invalid minutes`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidNumberError.ts
+var InvalidNumberError = class extends DomainError {
+	constructor(invalidNumber) {
+		super(`Invalid number ${String(invalidNumber)}`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidPasswordError.ts
+var InvalidPasswordError = class extends DomainError {
+	constructor(minLength, maxLength) {
+		super(`Password must be between ${minLength} and ${maxLength} characters long and include at least one uppercase letter, one lowercase letter, one number and one symbol.`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidPositiveNumberError.ts
+var InvalidPositiveNumberError = class extends DomainError {
+	constructor() {
+		super(`Value must be greater or equal than 0`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidStringLengthError.ts
+var InvalidStringLengthError = class extends DomainError {
+	constructor(value, length) {
+		super(`String length '${value.length}' exceeds the expected length: '${length}'`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidTimestampIntervalError.ts
+var InvalidTimestampIntervalError = class extends DomainError {
+	constructor(start, end) {
+		super(`Invalid TimestampInterval, start (${start.valueOf()}) must be before the end (${end.valueOf()})`);
+	}
+};
+//#endregion
+//#region src/errors/InvalidLengthError.ts
+var InvalidLengthError = class extends DomainError {
+	constructor(value, length) {
+		super(`Invalid Length Error with value: '${value}' expected length: '${length}'`);
+	}
+};
+//#endregion
+//#region src/errors/NullObjectCreationDisabledError.ts
+var NullObjectCreationDisabledError = class NullObjectCreationDisabledError extends DomainError {
+	constructor(valueObjectName) {
+		super(`[NullObjectCreationDisabledError]: ${valueObjectName} received null or undefined while automatic NullObject creation is disabled`);
+		Object.setPrototypeOf(this, NullObjectCreationDisabledError.prototype);
+	}
+};
+//#endregion
+//#region src/errors/NullObjectError.ts
+var NullObjectError = class NullObjectError extends DomainError {
+	constructor(message) {
+		super(`[NullObjectError]: ${message} is NullObject`);
+		Object.setPrototypeOf(this, NullObjectError.prototype);
+	}
+};
+//#endregion
+//#region src/errors/ValueNotInEnumError.ts
+var ValueNotInEnumError = class extends DomainError {
+	constructor(value, enumerate) {
+		super(`${Object.values(enumerate).join(",")} enum does not include value: ${value}`);
+	}
+};
+//#endregion
+//#region src/patterns/Assert.ts
+function assert(condition, error) {
+	if (condition) return;
+	throw typeof error === "string" ? new DomainError(error) : error;
+}
+//#endregion
+//#region src/value-objects/NullObject.ts
+var NullObject = class NullObject {
+	static setFakeProps(nullObject, klass) {
+		const visited = /* @__PURE__ */ new Set();
+		let proto = klass.prototype;
+		while (proto && proto !== Object.prototype) {
+			const props = Object.getOwnPropertyNames(proto);
+			for (const prop of props) {
+				if (prop === "constructor" || prop === "isNullObject" || prop === "valueOf" || visited.has(prop)) continue;
+				visited.add(prop);
+				nullObject[prop] = () => {
+					throw new NullObjectError(klass.name);
+				};
+			}
+			proto = Object.getPrototypeOf(proto);
+		}
+		Object.setPrototypeOf(nullObject, NullObject.prototype);
+	}
+	static new(klass) {
+		const nullObject = {
+			isNullObject: true,
+			valueOf: () => {}
+		};
+		NullObject.setFakeProps(nullObject, klass);
+		return nullObject;
+	}
+	static isNullObject(nullable) {
+		return !!nullable?.isNullObject;
+	}
+};
+//#endregion
+//#region src/value-objects/ValueObject.ts
+var ValueObject = class ValueObject {
+	static nullObjectCreationEnabled = true;
+	value;
+	static disableNullObjectCreation() {
+		ValueObject.nullObjectCreationEnabled = false;
+	}
+	static enableNullObjectCreation() {
+		ValueObject.nullObjectCreationEnabled = true;
+	}
+	constructor(value) {
+		if (this.isNullish(value)) {
+			if (ValueObject.nullObjectCreationEnabled === false) throw new NullObjectCreationDisabledError(new.target.name);
+			return NullObject.new(new.target);
+		}
+		this.value = value;
+	}
+	isNullish(value) {
+		return value === null || value === void 0;
+	}
+	clone(value) {
+		return new this.constructor(this.isNullish(value) ? this.value : value);
+	}
+	hasValue(other) {
+		const otherValue = other instanceof ValueObject ? other.valueOf() : other;
+		return this.value === otherValue;
+	}
+	isEqual(other) {
+		return other instanceof ValueObject && this.constructor === other.constructor && this.hasValue(other);
+	}
+	isNotEqual(other) {
+		return this.isEqual(other) === false;
+	}
+	valueOf() {
+		return this.value;
+	}
+	toString() {
+		return this.value.toString();
+	}
+};
+//#endregion
+//#region src/value-objects/StringValueObject.ts
+var StringValueObject = class extends ValueObject {
+	constructor(value, maxLength = 512) {
+		super(value?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		this.ensureDoesNotExceedsMaxLength(maxLength);
+	}
+	ensureDoesNotExceedsMaxLength(maxLength) {
+		assert(this.value.length <= maxLength, new InvalidStringLengthError(this.value, maxLength));
+	}
+	isEmpty() {
+		return !this.value;
+	}
+};
+//#endregion
+//#region src/value-objects/NumberValueObject.ts
+var NumberValueObject = class extends ValueObject {
+	constructor(value) {
+		super(value?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		assert(this.isValidNumber(this.value), new InvalidNumberError(this.value));
+	}
+	isValidNumber(value) {
+		return Number.isFinite(value.valueOf());
+	}
+	isZero() {
+		return this.value === 0;
+	}
+	isGreaterThan(other) {
+		return this.value > other.valueOf();
+	}
+	isGreaterOrEqualThan(other) {
+		return this.value >= other.valueOf();
+	}
+	isLessThan(other) {
+		return this.value < other.valueOf();
+	}
+	isLessOrEqualThan(other) {
+		return this.value <= other.valueOf();
+	}
+	add(other) {
+		return this.clone(this.value + other.valueOf());
+	}
+	subtract(other) {
+		return this.clone(this.value - other.valueOf());
+	}
+	multiply(other) {
+		return this.clone(this.value * other.valueOf());
+	}
+	divide(other) {
+		return this.clone(this.value / other.valueOf());
+	}
+};
+//#endregion
+//#region src/value-objects/coordinates/Latitude.ts
+var Latitude = class Latitude extends NumberValueObject {
+	static MIN_VALUE = new NumberValueObject(-90);
+	static MAX_VALUE = new NumberValueObject(90);
+	static isValid(value) {
+		const primitive = value.valueOf();
+		return Number.isFinite(primitive) && primitive >= this.MIN_VALUE.valueOf() && primitive <= this.MAX_VALUE.valueOf();
+	}
+	constructor(value) {
+		assert(Latitude.isValid(value), new InvalidLatitudeError(value.valueOf()));
+		super(value.valueOf());
+	}
+};
+//#endregion
+//#region src/value-objects/coordinates/Longitude.ts
+var Longitude = class Longitude extends NumberValueObject {
+	static MIN_VALUE = new NumberValueObject(-180);
+	static MAX_VALUE = new NumberValueObject(180);
+	static isValid(value) {
+		const primitive = value.valueOf();
+		return Number.isFinite(primitive) && primitive >= this.MIN_VALUE.valueOf() && primitive <= this.MAX_VALUE.valueOf();
+	}
+	constructor(value) {
+		assert(Longitude.isValid(value), new InvalidLongitudeError(value.valueOf()));
+		super(value.valueOf());
+	}
+};
+//#endregion
+//#region src/value-objects/coordinates/Coordinates.ts
+var Coordinates = class Coordinates extends StringValueObject {
+	latitude;
+	longitude;
+	static fromString(value) {
+		const latitude = parseFloat(value.split(",")[0]);
+		const longitude = parseFloat(value.split(",")[1]);
+		return new Coordinates(latitude, longitude);
+	}
+	constructor(latitude, longitude) {
+		super(latitude?.valueOf() + "," + longitude?.valueOf());
+		this.latitude = new Latitude(latitude.valueOf());
+		this.longitude = new Longitude(longitude.valueOf());
+	}
+	getLatitude() {
+		return this.latitude;
+	}
+	getLongitude() {
+		return this.longitude;
+	}
+};
+//#endregion
+//#region src/value-objects/hashes/Hash.ts
+var Hash = class extends ValueObject {
+	constructor(source) {
+		super(source?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+	}
+	toBase64() {
+		return new StringValueObject(buffer.Buffer.from(this.valueOf(), "hex").toString("base64"));
+	}
+};
+//#endregion
+//#region src/value-objects/hashes/MD5Hash.ts
+var MD5Hash = class MD5Hash extends Hash {
+	static isValid(hash) {
+		return !!hash.valueOf().match(/^[a-f0-9]{32}$/);
+	}
+	constructor(source) {
+		super(source?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		assert(MD5Hash.isValid(this.valueOf()), new InvalidHashError("MD5", source.valueOf()));
+	}
+};
+//#endregion
+//#region src/value-objects/hashes/SHA256Hash.ts
+var SHA256Hash = class SHA256Hash extends ValueObject {
+	static isValid(hash) {
+		return !!hash.valueOf().match(/^[a-f0-9]{64}$/i);
+	}
+	constructor(source) {
+		super(source?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		assert(SHA256Hash.isValid(this.valueOf()), new InvalidHashError("SHA256", source.valueOf()));
+	}
+	toBase64() {
+		return new StringValueObject(buffer.Buffer.from(this.valueOf(), "hex").toString("base64"));
+	}
+};
+//#endregion
+//#region src/value-objects/hashes/SHA512Hash.ts
+var SHA512Hash = class SHA512Hash extends ValueObject {
+	static isValid(hash) {
+		return !!hash.valueOf().match(/^[a-f0-9]{128}$/i);
+	}
+	constructor(source) {
+		super(source?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		assert(SHA512Hash.isValid(this.valueOf()), new InvalidHashError("SHA512", source.valueOf()));
+	}
+	toBase64() {
+		return new StringValueObject(buffer.Buffer.from(this.valueOf(), "hex").toString("base64"));
+	}
+};
+//#endregion
+//#region src/value-objects/ids/ShortId.ts
+var ShortId = class ShortId extends ValueObject {
+	static LENGTH = 24;
+	static PATTERN = new RegExp(`[a-zA-Z0-9]{${this.LENGTH}}$`);
+	static generateObjectIdHex() {
+		const random = (0, uuid.parse)((0, uuid.v4)());
+		const bytes = buffer.Buffer.alloc(12);
+		bytes.writeUInt32BE(Math.floor(Date.now() / 1e3), 0);
+		bytes.set(random.subarray(0, 6), 4);
+		bytes.set(random.subarray(9, 11), 10);
+		return bytes.toString("hex");
+	}
+	static generate() {
+		return new ShortId(ShortId.generateObjectIdHex());
+	}
+	constructor(value) {
+		super(value?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		this.ensureIsShortId(this.value);
+	}
+	ensureIsShortId(value) {
+		assert(value.length === ShortId.LENGTH, new InvalidLengthError(this.value, ShortId.LENGTH));
+		assert(ShortId.PATTERN.test(value), new InvalidFormatError(this.value));
+	}
+};
+//#endregion
+//#region src/value-objects/ids/UUID.ts
+var UUID = class UUID extends ValueObject {
+	static LENGTH = 36;
+	static PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+	static SENTINEL_PATTERN = /^(?:00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+	static generate() {
+		return new UUID((0, uuid.v4)());
+	}
+	constructor(value) {
+		super(value?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		this.ensureIsUUID(this.value);
+	}
+	ensureIsUUID(value) {
+		assert(value.length === UUID.LENGTH, new InvalidLengthError(this.value, UUID.LENGTH));
+		assert(UUID.PATTERN.test(value) || UUID.SENTINEL_PATTERN.test(value), new InvalidFormatError(this.value));
+	}
+};
+//#endregion
+//#region src/value-objects/media/Media.ts
+var Media = class Media extends ValueObject {
+	buffer;
+	constructor(value) {
+		super(value?.toString());
+		if (NullObject.isNullObject(this)) return this;
+		this.buffer = buffer.Buffer.isBuffer(value) ? buffer.Buffer.from(value) : void 0;
+	}
+	getBuffer() {
+		return this.buffer === void 0 ? buffer.Buffer.from(this.value) : buffer.Buffer.from(this.buffer);
+	}
+	getSize() {
+		return this.getBuffer().length;
+	}
+	getBase64() {
+		return this.getBuffer().toString("base64");
+	}
+	hasValue(other) {
+		if (other instanceof Media) return this.getBuffer().equals(other.getBuffer());
+		if (buffer.Buffer.isBuffer(other)) return this.getBuffer().equals(other);
+		return super.hasValue(other);
+	}
+};
+//#endregion
+//#region src/value-objects/Integer.ts
+var Integer = class extends NumberValueObject {
+	constructor(value) {
+		super(value?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		this.ensureIsInteger();
+	}
+	ensureIsInteger() {
+		assert(this.value.valueOf() % 1 === 0, new InvalidIntegerError(this.value.valueOf()));
+	}
+};
+//#endregion
+//#region src/value-objects/time/Day.ts
+var Day = class extends Integer {
+	constructor(value) {
+		super(value.valueOf());
+		this.ensureIsValidDay();
+	}
+	ensureIsValidDay() {
+		assert(this.isGreaterOrEqualThan(1), new InvalidDayError(this.value));
+		assert(this.isLessOrEqualThan(31), new InvalidDayError(this.value));
+	}
+};
+//#endregion
+//#region src/value-objects/Enum.ts
+var Enum = class extends ValueObject {
+	value;
+	constructor(value) {
+		super(value);
+		this.value = value;
+		if (NullObject.isNullObject(this)) return this;
+		this.ensureIsValidValue();
+	}
+	ensureIsValidValue() {
+		assert(this.getValues().some((enumValue) => this.hasValue(enumValue)), new ValueNotInEnumError(this.valueOf(), this.getValues()));
+	}
+};
+//#endregion
+//#region src/value-objects/time/DayOfWeek.ts
+let EDaysOfWeek = /* @__PURE__ */ function(EDaysOfWeek) {
+	EDaysOfWeek["MONDAY"] = "monday";
+	EDaysOfWeek["TUESDAY"] = "tuesday";
+	EDaysOfWeek["WEDNESDAY"] = "wednesday";
+	EDaysOfWeek["THURSDAY"] = "thursday";
+	EDaysOfWeek["FRIDAY"] = "friday";
+	EDaysOfWeek["SATURDAY"] = "saturday";
+	EDaysOfWeek["SUNDAY"] = "sunday";
+	return EDaysOfWeek;
+}({});
+const timeStampDayToDaysMap = {
+	["friday"]: 5,
+	["monday"]: 1,
+	["saturday"]: 6,
+	["sunday"]: 0,
+	["thursday"]: 4,
+	["tuesday"]: 2,
+	["wednesday"]: 3
+};
+var DayOfWeek = class DayOfWeek extends Enum {
+	static MONDAY = new DayOfWeek("monday");
+	static TUESDAY = new DayOfWeek("tuesday");
+	static WEDNESDAY = new DayOfWeek("wednesday");
+	static THURSDAY = new DayOfWeek("thursday");
+	static FRIDAY = new DayOfWeek("friday");
+	static SATURDAY = new DayOfWeek("saturday");
+	static SUNDAY = new DayOfWeek("sunday");
+	static fromNumber(day) {
+		const [eDay] = Object.entries(timeStampDayToDaysMap).find(([, value]) => value === day) || [];
+		assert(eDay, new InvalidDayError(eDay));
+		return new DayOfWeek(eDay);
+	}
+	static fromTimestamp(timestamp) {
+		const dayOfWeekNumber = timestamp.getDayOfWeek();
+		return DayOfWeek.fromNumber(dayOfWeekNumber);
+	}
+	getValues() {
+		return Object.values(EDaysOfWeek);
+	}
+	toNumber() {
+		return timeStampDayToDaysMap[this.value];
+	}
+};
+//#endregion
+//#region src/value-objects/time/Month.ts
+var MonthEnum = /* @__PURE__ */ function(MonthEnum) {
+	MonthEnum[MonthEnum["JANUARY"] = 1] = "JANUARY";
+	MonthEnum[MonthEnum["FEBRUARY"] = 2] = "FEBRUARY";
+	MonthEnum[MonthEnum["MARCH"] = 3] = "MARCH";
+	MonthEnum[MonthEnum["APRIL"] = 4] = "APRIL";
+	MonthEnum[MonthEnum["MAY"] = 5] = "MAY";
+	MonthEnum[MonthEnum["JUNE"] = 6] = "JUNE";
+	MonthEnum[MonthEnum["JULY"] = 7] = "JULY";
+	MonthEnum[MonthEnum["AUGUST"] = 8] = "AUGUST";
+	MonthEnum[MonthEnum["SEPTEMBER"] = 9] = "SEPTEMBER";
+	MonthEnum[MonthEnum["OCTOBER"] = 10] = "OCTOBER";
+	MonthEnum[MonthEnum["NOVEMBER"] = 11] = "NOVEMBER";
+	MonthEnum[MonthEnum["DECEMBER"] = 12] = "DECEMBER";
+	return MonthEnum;
+}(MonthEnum || {});
+var Month = class Month extends Enum {
+	static JANUARY = new Month(1);
+	static FEBRUARY = new Month(2);
+	static MARCH = new Month(3);
+	static APRIL = new Month(4);
+	static MAY = new Month(5);
+	static JUNE = new Month(6);
+	static JULY = new Month(7);
+	static AUGUST = new Month(8);
+	static SEPTEMBER = new Month(9);
+	static OCTOBER = new Month(10);
+	static NOVEMBER = new Month(11);
+	static DECEMBER = new Month(12);
+	getValues() {
+		return Object.values(MonthEnum);
+	}
+	getIndex() {
+		return Number(this.valueOf()) - 1;
+	}
+};
+//#endregion
+//#region src/value-objects/time/Year.ts
+var Year = class Year extends Integer {
+	static YEAR_DAYS = 365;
+	static LEAP_YEAR_DAYS = 366;
+	constructor(value) {
+		super(value?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+	}
+	isLeapYear() {
+		return this.getNumberOfDays() === Year.LEAP_YEAR_DAYS;
+	}
+	getNumberOfDays() {
+		return this.value % 4 === 0 && this.value % 100 !== 0 || this.value % 400 === 0 ? Year.LEAP_YEAR_DAYS : Year.YEAR_DAYS;
+	}
+};
+//#endregion
+//#region src/value-objects/time/Timestamp.ts
+var Timestamp = class Timestamp extends ValueObject {
+	static FACTORS = {
+		DAYS: 864e5,
+		HOURS: 36e5,
+		MINUTES: 6e4,
+		SECONDS: 1e3,
+		WEEKS: 6048e5
+	};
+	static valueMilliseconds(value) {
+		if (value instanceof Timestamp || value instanceof Date) return value.valueOf();
+		if (typeof value === "number") return value;
+		if (typeof value === "string") return new Date(value).valueOf();
+		return Date.now().valueOf();
+	}
+	static getLastDayOfUtcMonth(year, month) {
+		const normalizedYear = year + Math.floor(month / 12);
+		const normalizedMonth = (month % 12 + 12) % 12;
+		return [
+			31,
+			new Year(normalizedYear).isLeapYear() ? 29 : 28,
+			31,
+			30,
+			31,
+			30,
+			31,
+			31,
+			30,
+			31,
+			30,
+			31
+		][normalizedMonth];
+	}
+	static ensureCalendarDelta(value) {
+		assert(Number.isInteger(value), new InvalidIntegerError(value));
+	}
+	static createUtcCalendarValue(sourceValue, year, month, day) {
+		const integerValue = Math.floor(sourceValue);
+		const fractionalMilliseconds = sourceValue - integerValue;
+		const source = new Date(integerValue);
+		const target = /* @__PURE__ */ new Date(0);
+		target.setUTCFullYear(year, month, day);
+		target.setUTCHours(source.getUTCHours(), source.getUTCMinutes(), source.getUTCSeconds(), source.getUTCMilliseconds());
+		return target.valueOf() + fractionalMilliseconds;
+	}
+	static new(value) {
+		return new Timestamp(value);
+	}
+	static now() {
+		return new Timestamp();
+	}
+	static fromSeconds(seconds) {
+		return new Timestamp(seconds.valueOf() * Timestamp.FACTORS.SECONDS);
+	}
+	constructor(value) {
+		super(Timestamp.valueMilliseconds(value));
+		assert(Number.isFinite(new Date(this.value).valueOf()), new InvalidNumberError(this.value));
+	}
+	toExactHour() {
+		const date = new Date(this.valueOf());
+		date.setSeconds(0);
+		date.setMinutes(0);
+		date.setMilliseconds(0);
+		const value = Timestamp.new(date.getTime()).value;
+		return this.clone(value);
+	}
+	toMilliseconds() {
+		return this.value;
+	}
+	toSeconds() {
+		return Math.round(this.value / Timestamp.FACTORS.SECONDS);
+	}
+	toDate() {
+		return new Date(this.value);
+	}
+	toString() {
+		return `${this.valueOf()}`;
+	}
+	isBefore(other) {
+		return this.value < other.valueOf();
+	}
+	isAfter(other) {
+		return this.value > other.valueOf();
+	}
+	isBeforeOrEqual(other) {
+		return this.value <= other.valueOf();
+	}
+	isAfterOrEqual(other) {
+		return this.value >= other.valueOf();
+	}
+	addMilliseconds(milliseconds) {
+		const value = this.value + milliseconds.valueOf();
+		return this.clone(value);
+	}
+	addSeconds(seconds) {
+		const value = this.value + seconds.valueOf() * Timestamp.FACTORS.SECONDS;
+		return this.clone(value);
+	}
+	addMinutes(minutes) {
+		const value = this.value + minutes.valueOf() * Timestamp.FACTORS.MINUTES;
+		return this.clone(value);
+	}
+	addHours(hours) {
+		const value = this.value + hours.valueOf() * Timestamp.FACTORS.HOURS;
+		return this.clone(value);
+	}
+	addDays(days) {
+		const value = this.value + days.valueOf() * Timestamp.FACTORS.DAYS;
+		return this.clone(value);
+	}
+	addWeeks(weeks) {
+		const value = this.value + weeks.valueOf() * Timestamp.FACTORS.WEEKS;
+		return this.clone(value);
+	}
+	addMonths(months) {
+		const delta = months.valueOf();
+		Timestamp.ensureCalendarDelta(delta);
+		const source = new Date(Math.floor(this.value));
+		const totalMonths = source.getUTCFullYear() * 12 + source.getUTCMonth() + delta;
+		const targetYear = Math.floor(totalMonths / 12);
+		const targetMonth = totalMonths - targetYear * 12;
+		const targetDay = Math.min(source.getUTCDate(), Timestamp.getLastDayOfUtcMonth(targetYear, targetMonth));
+		return this.clone(Timestamp.createUtcCalendarValue(this.value, targetYear, targetMonth, targetDay));
+	}
+	addYears(years) {
+		const delta = years.valueOf();
+		Timestamp.ensureCalendarDelta(delta);
+		const source = new Date(Math.floor(this.value));
+		const targetYear = source.getUTCFullYear() + delta;
+		const targetMonth = source.getUTCMonth();
+		const targetDay = Math.min(source.getUTCDate(), Timestamp.getLastDayOfUtcMonth(targetYear, targetMonth));
+		return this.clone(Timestamp.createUtcCalendarValue(this.value, targetYear, targetMonth, targetDay));
+	}
+	addDuration(duration) {
+		const value = this.value + duration.valueOf();
+		return this.clone(value);
+	}
+	isSameDay(other) {
+		return this.getCalendarDay().isEqual(other.getCalendarDay());
+	}
+	isSameMonth(other) {
+		return this.getMonthOfYear().isEqual(other.getMonthOfYear());
+	}
+	isSameYear(other) {
+		return this.getYear().isEqual(other.getYear());
+	}
+	getCalendarDay() {
+		return new CalendarDay(this);
+	}
+	getDay() {
+		return new Day(this.toDate().getUTCDate());
+	}
+	getMonth() {
+		return new Month(this.toDate().getUTCMonth() + 1);
+	}
+	getYear() {
+		return new Year(this.toDate().getUTCFullYear());
+	}
+	getHours() {
+		return this.toDate().getUTCHours();
+	}
+	getMinutes() {
+		return this.toDate().getUTCMinutes();
+	}
+	getSeconds() {
+		return this.toDate().getUTCSeconds();
+	}
+	getMilliseconds() {
+		return this.toDate().getUTCMilliseconds();
+	}
+	getDayOfWeek() {
+		return this.toDate().getUTCDay();
+	}
+	getMonthOfYear() {
+		return new MonthOfYear(this.getMonth(), this.getYear());
+	}
+};
+//#endregion
+//#region src/value-objects/PositiveNumber.ts
+var PositiveNumber = class extends NumberValueObject {
+	constructor(value) {
+		super(value?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		this.ensureIsPositive(this.value);
+	}
+	ensureIsPositive(value) {
+		assert(value >= 0, new InvalidPositiveNumberError());
+	}
+};
+//#endregion
+//#region src/value-objects/time/Duration.ts
+var Duration = class Duration extends NumberValueObject {
+	static MILLISECOND_FACTOR = 1e3;
+	static SECOND_UNITS = {
+		DAYS: 86400,
+		HOURS: 3600,
+		MINUTES: 60,
+		MONTHS: 2592e3,
+		SECONDS: 1,
+		WEEKS: 604800,
+		YEARS: 31536e3
+	};
+	static millisecondFactors = {
+		DAYS: new NumberValueObject(this.SECOND_UNITS.DAYS * this.MILLISECOND_FACTOR),
+		HOURS: new NumberValueObject(this.SECOND_UNITS.HOURS * this.MILLISECOND_FACTOR),
+		MINUTES: new NumberValueObject(this.SECOND_UNITS.MINUTES * this.MILLISECOND_FACTOR),
+		MONTHS: new NumberValueObject(this.SECOND_UNITS.MONTHS * this.MILLISECOND_FACTOR),
+		SECONDS: new NumberValueObject(this.SECOND_UNITS.SECONDS * this.MILLISECOND_FACTOR),
+		WEEKS: new NumberValueObject(this.SECOND_UNITS.WEEKS * this.MILLISECOND_FACTOR),
+		YEARS: new NumberValueObject(this.SECOND_UNITS.YEARS * this.MILLISECOND_FACTOR)
+	};
+	static fromDays(days) {
+		return new Duration(new NumberValueObject(days.valueOf()).multiply(this.millisecondFactors.DAYS));
+	}
+	static fromHours(hours) {
+		return new Duration(new NumberValueObject(hours.valueOf()).multiply(this.millisecondFactors.HOURS));
+	}
+	static fromMinutes(minutes) {
+		return new Duration(new NumberValueObject(minutes.valueOf()).multiply(this.millisecondFactors.MINUTES));
+	}
+	static fromSeconds(seconds) {
+		return new Duration(new NumberValueObject(seconds.valueOf()).multiply(this.millisecondFactors.SECONDS));
+	}
+	static fromMilliseconds(milliseconds) {
+		return new Duration(new NumberValueObject(milliseconds.valueOf()));
+	}
+	constructor(milliseconds) {
+		super(milliseconds.valueOf());
+	}
+	getTotalDays() {
+		return new Duration(this).divide(Duration.millisecondFactors.DAYS);
+	}
+	getTotalHours() {
+		return new Duration(this).divide(Duration.millisecondFactors.HOURS);
+	}
+	getTotalMinutes() {
+		return new Duration(this).divide(Duration.millisecondFactors.MINUTES);
+	}
+	getTotalSeconds() {
+		return new Duration(this).divide(Duration.millisecondFactors.SECONDS);
+	}
+	getTotalMilliseconds() {
+		return new NumberValueObject(this.valueOf());
+	}
+	getDays() {
+		return new NumberValueObject(Math.floor(new Duration(this).divide(Duration.millisecondFactors.DAYS).valueOf()));
+	}
+	getHours() {
+		return new NumberValueObject(Math.floor(new Duration(this).divide(Duration.millisecondFactors.HOURS).valueOf()) % 24);
+	}
+	getMinutes() {
+		return new NumberValueObject(Math.floor(new Duration(this).divide(Duration.millisecondFactors.MINUTES).valueOf()) % Duration.SECOND_UNITS.MINUTES);
+	}
+	getSeconds() {
+		return new NumberValueObject(Math.floor(new Duration(this).divide(Duration.millisecondFactors.SECONDS).valueOf()) % Duration.SECOND_UNITS.MINUTES);
+	}
+	getMilliseconds() {
+		return new NumberValueObject(Math.floor(new Duration(this).valueOf()) % Duration.MILLISECOND_FACTOR);
+	}
+};
+//#endregion
+//#region src/value-objects/time/TimestampInterval.ts
+var TimestampInterval = class TimestampInterval extends ValueObject {
+	start;
+	end;
+	static fromPrimitives(primitives) {
+		return new TimestampInterval(new Timestamp(primitives.start), new Timestamp(primitives.end));
+	}
+	constructor(start, end) {
+		super(`${start.valueOf()}-${end.valueOf()}`);
+		this.start = start;
+		this.end = end;
+		assert(start.isBeforeOrEqual(end), new InvalidTimestampIntervalError(start, end));
+	}
+	toPrimitives() {
+		return {
+			end: this.end.valueOf(),
+			start: this.start.valueOf()
+		};
+	}
+	getStart() {
+		return this.start;
+	}
+	getEnd() {
+		return this.end;
+	}
+	getDuration() {
+		return new Duration(new PositiveNumber(this.end.valueOf() - this.start.valueOf()));
+	}
+	getTotalDaysOfWeek(dayOfWeek) {
+		const daysToCheck = Math.trunc(this.getDuration().valueOf() / 864e5);
+		let count = 0;
+		for (let daysChecked = 0; daysChecked <= daysToCheck; daysChecked++) if (new Timestamp(this.start).addDays(daysChecked).getDayOfWeek() === dayOfWeek.toNumber()) count++;
+		return count;
+	}
+	getDaysBetweenInterval() {
+		const days = [];
+		let iteratorTimestamp = new Timestamp(this.getStart());
+		const endTimestamp = new Timestamp(this.getEnd());
+		while (iteratorTimestamp.isBeforeOrEqual(endTimestamp)) {
+			days.push(new CalendarDay(iteratorTimestamp));
+			iteratorTimestamp = iteratorTimestamp.addDays(1);
+		}
+		return days;
+	}
+	getOverlappingInterval(searchInterval) {
+		const start = this.start.isAfter(searchInterval.getStart()) ? this.start : searchInterval.getStart();
+		const end = this.end.isBefore(searchInterval.getEnd()) ? this.end : searchInterval.getEnd();
+		if (start.isAfterOrEqual(end)) return null;
+		return new TimestampInterval(start, end);
+	}
+	includes(timestamp) {
+		return timestamp.isAfterOrEqual(this.start) && timestamp.isBeforeOrEqual(this.end);
+	}
+};
+//#endregion
+//#region src/value-objects/time/MonthOfYear.ts
+var MonthOfYear = class MonthOfYear extends ValueObject {
+	month;
+	year;
+	static fromTimestamp(timestamp) {
+		return new MonthOfYear(timestamp.getMonth(), timestamp.getYear());
+	}
+	static fromString(value) {
+		const [year, month] = value.split("/").map(Number);
+		return new MonthOfYear(month, year);
+	}
+	constructor(month, year) {
+		super(year.valueOf().toString() + "/" + month.valueOf().toString().padStart(2, "0"));
+		this.month = new Month(month.valueOf());
+		this.year = new Year(year.valueOf());
+	}
+	getMonth() {
+		return new Month(this.month.valueOf());
+	}
+	getYear() {
+		return new Year(this.year);
+	}
+	getNumberOfDays() {
+		return new Date(this.year.valueOf(), this.month.valueOf(), 0).getDate();
+	}
+	getTimestampInterval() {
+		const firstMonthDay = "01";
+		const month = this.month.valueOf().toString().padStart(2, "0");
+		const lastDay = this.getNumberOfDays().toString();
+		return new TimestampInterval(new Timestamp(`${this.year}-${month}-${firstMonthDay}`), new Timestamp(`${this.year}-${month}-${lastDay}`));
+	}
+};
+//#endregion
+//#region src/value-objects/time/CalendarDay.ts
+var CalendarDay = class CalendarDay extends ValueObject {
+	year;
+	month;
+	day;
+	static ensureIsValidString(value) {
+		assert(value.match(/^\d{4}-\d{1,2}-\d{1,2}$/), new InvalidDayFormatError(value));
+	}
+	static generateStringValue(timestamp) {
+		const paddedMonth = timestamp.getMonth().toString().padStart(2, "0");
+		const paddedDay = timestamp.getDay().toString().padStart(2, "0");
+		return `${timestamp.getYear().toString()}-${paddedMonth}-${paddedDay}`;
+	}
+	static ensureIsValidDate(value) {
+		assert(Number.isFinite(value.valueOf()), new InvalidDayError(value));
+	}
+	static timestampFromString(value) {
+		CalendarDay.ensureIsValidString(value);
+		const [year, month, day] = value.split("-").map(Number);
+		const date = /* @__PURE__ */ new Date(0);
+		date.setUTCHours(0, 0, 0, 0);
+		date.setUTCFullYear(year, month - 1, day);
+		assert(date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day, new InvalidDayError(value));
+		return new Timestamp(date);
+	}
+	static timestampFromValue(value) {
+		if (typeof value === "string") return CalendarDay.timestampFromString(value);
+		CalendarDay.ensureIsValidDate(value);
+		return new Timestamp(value);
+	}
+	constructor(value) {
+		let timestamp;
+		if (value !== void 0) timestamp = CalendarDay.timestampFromValue(value);
+		else timestamp = new Timestamp();
+		super(CalendarDay.generateStringValue(timestamp));
+		this.year = timestamp.getYear().valueOf();
+		this.month = timestamp.getMonth().getIndex() + 1;
+		this.day = timestamp.getDay().valueOf();
+	}
+	isAfter(date) {
+		return this.valueOf() > date.valueOf();
+	}
+	isBefore(date) {
+		return this.valueOf() < date.valueOf();
+	}
+	getYear() {
+		return this.year;
+	}
+	getMonth() {
+		return new Month(this.month);
+	}
+	getMonthOfYear() {
+		return new MonthOfYear(this.month, this.year);
+	}
+	getDay() {
+		return new Day(this.day);
+	}
+	getDayOfWeek() {
+		return DayOfWeek.fromNumber(this.toTimestamp().getDayOfWeek());
+	}
+	toTimestamp() {
+		const date = /* @__PURE__ */ new Date(0);
+		date.setUTCHours(0, 0, 0, 0);
+		date.setUTCFullYear(this.year, this.month - 1, this.day);
+		return new Timestamp(date);
+	}
+};
+//#endregion
+//#region src/value-objects/time/Hour.ts
+var Hour = class Hour extends StringValueObject {
+	minutes;
+	hours;
+	static addTrailZero(value) {
+		return value < 10 ? `0${value}` : value.toString();
+	}
+	static normalizeMinutes(totalMinutes) {
+		const minutesPerDay = 1440;
+		return (totalMinutes % minutesPerDay + minutesPerDay) % minutesPerDay;
+	}
+	static parseFromNumber(value, minutes) {
+		assert(Number.isInteger(value) && value >= 0 && value <= 23, new InvalidHourError());
+		assert(Number.isInteger(minutes) && minutes >= 0 && minutes <= 59, new InvalidMinutesError());
+		return [Hour.addTrailZero(value), Hour.addTrailZero(minutes)];
+	}
+	static parseFromString(value) {
+		const parts = value.split(":");
+		assert(parts.length === 2 && parts[1] !== "", new InvalidHourError());
+		const [hours, minutes] = parts;
+		assert(/^\d{1,2}$/.test(hours), new InvalidHourError());
+		assert(/^\d{1,2}$/.test(minutes), new InvalidMinutesError());
+		const parsedHours = Number(hours);
+		const parsedMinutes = Number(minutes);
+		assert(parsedHours >= 0 && parsedHours <= 23, new InvalidHourError());
+		assert(parsedMinutes >= 0 && parsedMinutes <= 59, new InvalidMinutesError());
+		return [Hour.addTrailZero(parsedHours), Hour.addTrailZero(parsedMinutes)];
+	}
+	constructor(value, minutes) {
+		const [parsedHours, parsedMinutes] = typeof value === "number" && minutes !== void 0 ? Hour.parseFromNumber(value, minutes) : Hour.parseFromString(value);
+		super(`${parsedHours}:${parsedMinutes}`);
+		this.hours = parsedHours;
+		this.minutes = parsedMinutes;
+	}
+	addMinutes(minutes) {
+		const currentMinutes = Number(this.hours) * 60 + Number(this.minutes);
+		const normalizedMinutes = Hour.normalizeMinutes(currentMinutes + minutes);
+		const newHour = Math.floor(normalizedMinutes / 60);
+		const newMinutes = normalizedMinutes % 60;
+		return new Hour(newHour, newMinutes);
+	}
+	diffInMinutes(other) {
+		let endHour = Number(other.hours);
+		if (other.hours < this.hours || other.hours === this.hours && other.minutes < this.minutes) endHour += 24;
+		return (endHour - Number(this.hours)) * 60 + (Number(other.minutes) - Number(this.minutes));
+	}
+	getMinutes() {
+		return Number(this.minutes);
+	}
+	getHours() {
+		return Number(this.hours);
+	}
+	isGreaterThan(hour) {
+		if (this.hours === hour.hours) return Number(this.minutes) > Number(hour.minutes);
+		return Number(this.hours) > Number(hour.hours);
+	}
+	isLessThan(hour) {
+		if (this.hours === hour.hours) return Number(this.minutes) < Number(hour.minutes);
+		return Number(this.hours) < Number(hour.hours);
+	}
+};
+//#endregion
+//#region src/value-objects/Color.ts
+var Color = class Color extends StringValueObject {
+	static RED = new Color("#FF0000");
+	static GREEN = new Color("#00FF00");
+	static BLUE = new Color("#0000FF");
+	static BLACK = new Color("#000000");
+	static WHITE = new Color("#FFFFFF");
+	static YELLOW = new Color("#FFFF00");
+	static CYAN = new Color("#00FFFF");
+	static MAGENTA = new Color("#FF00FF");
+	static ORANGE = new Color("#FFA500");
+	static PURPLE = new Color("#800080");
+	static PINK = new Color("#FFC0CB");
+	static BROWN = new Color("#A52A2A");
+	constructor(value) {
+		super(value?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		this.ensureIsValidColor();
+	}
+	ensureIsValidColor() {
+		assert(/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(this.value), new InvalidColorError(this.value));
+	}
+	hasValue(other) {
+		const otherValue = other instanceof ValueObject ? other.valueOf() : other;
+		return typeof otherValue === "string" && this.value.toLowerCase() === otherValue.toLowerCase();
+	}
+};
+//#endregion
+//#region src/value-objects/Email.ts
+var Email = class Email extends StringValueObject {
+	static PATTERN = /^[\w+\-.!#$%&'*/=?^`{|}~]+@(?:[\w-]+\.)+(?:[a-z]{2,63}|xn--[a-z0-9](?:[a-z0-9-]{0,57}[a-z0-9])?)$/i;
+	constructor(value) {
+		super(value?.valueOf());
+		if (NullObject.isNullObject(this)) return this;
+		this.ensureIsValidEmail(this.value);
+	}
+	ensureIsValidEmail(value) {
+		assert(Email.PATTERN.test(value), new InvalidEmailError(value));
+	}
+};
+//#endregion
+//#region src/value-objects/Password.ts
+var Password = class Password extends StringValueObject {
+	static MAX_LENGTH = 256;
+	static MIN_LENGTH = 12;
+	constructor(value) {
+		super(value);
+		if (NullObject.isNullObject(this)) return this;
+		assert(this.isValidPassword(), new InvalidPasswordError(Password.MIN_LENGTH, Password.MAX_LENGTH));
+	}
+	isValidPassword() {
+		return this.value.length >= Password.MIN_LENGTH && this.value.length <= Password.MAX_LENGTH && /[A-Z]/.test(this.value) && /[a-z]/.test(this.value) && /[0-9]/.test(this.value) && /[^A-Za-z0-9]/.test(this.value);
+	}
+};
+//#endregion
+//#region src/value-objects/UniqueObjectArray.ts
+var UniqueObjectArray = class UniqueObjectArray {
+	items = [];
+	static fromArray(array) {
+		const uniqueArray = new UniqueObjectArray();
+		for (const item of array) uniqueArray.push(item);
+		return uniqueArray;
+	}
+	includes(item) {
+		return this.items.some((one) => one.isEqual(item));
+	}
+	push(item) {
+		if (!this.includes(item)) {
+			this.items.push(item);
+			return true;
+		}
+		return false;
+	}
+	remove(item) {
+		const index = this.items.findIndex((one) => one.isEqual(item));
+		if (index !== -1) {
+			this.items.splice(index, 1);
+			return true;
+		}
+		return false;
+	}
+	[Symbol.iterator]() {
+		return this.items[Symbol.iterator]();
+	}
+	length() {
+		return this.items.length;
+	}
+	toArray() {
+		return Array.from(this.items);
+	}
+};
+//#endregion
+exports.BaseError = BaseError;
+exports.CalendarDay = CalendarDay;
+exports.Color = Color;
+exports.Coordinates = Coordinates;
+exports.Day = Day;
+exports.DayOfWeek = DayOfWeek;
+exports.DomainError = DomainError;
+exports.Duration = Duration;
+exports.EDaysOfWeek = EDaysOfWeek;
+exports.Email = Email;
+exports.Enum = Enum;
+exports.Hash = Hash;
+exports.Hour = Hour;
+exports.Integer = Integer;
+exports.InvalidColorError = InvalidColorError;
+exports.InvalidDayError = InvalidDayError;
+exports.InvalidDayFormatError = InvalidDayFormatError;
+exports.InvalidEmailError = InvalidEmailError;
+exports.InvalidFormatError = InvalidFormatError;
+exports.InvalidHashError = InvalidHashError;
+exports.InvalidHourError = InvalidHourError;
+exports.InvalidIntegerError = InvalidIntegerError;
+exports.InvalidLatitudeError = InvalidLatitudeError;
+exports.InvalidLengthError = InvalidLengthError;
+exports.InvalidLongitudeError = InvalidLongitudeError;
+exports.InvalidMinutesError = InvalidMinutesError;
+exports.InvalidNumberError = InvalidNumberError;
+exports.InvalidPasswordError = InvalidPasswordError;
+exports.InvalidPositiveNumberError = InvalidPositiveNumberError;
+exports.InvalidStringLengthError = InvalidStringLengthError;
+exports.InvalidTimestampIntervalError = InvalidTimestampIntervalError;
+exports.Latitude = Latitude;
+exports.Longitude = Longitude;
+exports.MD5Hash = MD5Hash;
+exports.Media = Media;
+exports.Month = Month;
+exports.MonthOfYear = MonthOfYear;
+exports.NullObject = NullObject;
+exports.NullObjectCreationDisabledError = NullObjectCreationDisabledError;
+exports.NullObjectError = NullObjectError;
+exports.NumberValueObject = NumberValueObject;
+exports.Password = Password;
+exports.PositiveNumber = PositiveNumber;
+exports.SHA256Hash = SHA256Hash;
+exports.SHA512Hash = SHA512Hash;
+exports.ShortId = ShortId;
+exports.StringValueObject = StringValueObject;
+exports.Timestamp = Timestamp;
+exports.TimestampInterval = TimestampInterval;
+exports.UUID = UUID;
+exports.UniqueObjectArray = UniqueObjectArray;
+exports.ValueNotInEnumError = ValueNotInEnumError;
+exports.ValueObject = ValueObject;
+exports.Year = Year;
+exports.assert = assert;
+exports.timeStampDayToDaysMap = timeStampDayToDaysMap;
+
+//# sourceMappingURL=index.cjs.map