@thisisagile/easy-domain 15.29.3

package/src/structs/Money.ts

@@ -0,0 +1,37 @@
+import { Struct, isEmpty, text, required } from '@thisisagile/easy';
+import { Currency } from '../enums/Currency';
+
+export class Money extends Struct {
+  @required() readonly currency = Currency.byId<Currency>(this.state.currency);
+  @required() readonly value = this.state.value as number;
+
+  add(amount: number): Money {
+    return money(this.currency, this.value + amount);
+  }
+  subtract(amount: number): Money {
+    return money(this.currency, this.value - amount);
+  }
+  times(n: number): Money {
+    return money(this.currency, this.value * n);
+  }
+
+  toString(): string {
+    return text(this.currency?.code)
+      .with(' ', this.value?.toFixed(this.currency?.digits ?? 2))
+      .toString();
+  }
+
+  static zero(currency: Currency): Money {
+    return Money.amount(currency);
+  }
+
+  static amount(currency: Currency, value: number = 0): Money {
+    return money(currency, value);
+  }
+}
+
+export const money = (currency: Currency, value: number): Money => new Money({ currency: currency.id, value });
+
+export const isMoney = (m?: unknown): m is Money => {
+  return !isEmpty(m) && m instanceof Money;
+};

package/src/structs/Name.ts

@@ -0,0 +1,13 @@
+import { Struct, Json, text, required } from '@thisisagile/easy';
+
+export class Name extends Struct {
+  @required() readonly first: string = this.state.first;
+  readonly middle: string = this.state.middle;
+  @required() readonly last: string = this.state.last;
+
+  toString(): string {
+    return text(this.first, '').add(this.middle, ' ').add(this.last, ' ').toString();
+  }
+}
+
+export const name = (n?: Json): Name => new Name(n);

package/src/structs/Weight.ts

@@ -0,0 +1,34 @@
+import { UnitOfWeight } from '../enums/UnitOfWeight';
+import { Struct, required } from '@thisisagile/easy';
+
+export class Weight extends Struct {
+  @required() readonly value = this.state.value as number;
+  readonly uow = UnitOfWeight.byId<UnitOfWeight>(this.state.uow, UnitOfWeight.G);
+
+  /**
+    @deprecated use inGrams getter instead
+   */
+  sizeInG(): number {
+    return this.inGrams;
+  }
+
+  get inGrams(): number {
+    return this.value * this.uow.gMultiplier;
+  }
+
+  gte(w: Weight): boolean {
+    return this.inGrams >= w.inGrams;
+  }
+  lte(w: Weight): boolean {
+    return this.inGrams <= w.inGrams;
+  }
+
+  between(lower: Weight, upper = weight(Number.MAX_VALUE, this.uow)) {
+    return this.gte(lower) && this.lte(upper);
+  }
+  sum(add: Weight): Weight {
+    return weight((this.inGrams + add.inGrams) / this.uow.gMultiplier, this.uow);
+  }
+}
+
+export const weight = (value: number, uow?: UnitOfWeight): Weight => new Weight({ value, uow });

package/src/values/EAN.ts

@@ -0,0 +1,12 @@
+import { isEAN as validateEAN } from 'validator';
+import { asString, isEmpty, Value } from '@thisisagile/easy';
+
+export class EAN extends Value {
+  get isValid(): boolean {
+    return isEAN(this.value);
+  }
+}
+
+export const isEAN = (ean?: unknown): boolean => {
+  return !isEmpty(ean) && validateEAN(asString(ean));
+};

package/src/values/Email.ts

@@ -0,0 +1,20 @@
+import { isEmail as validateEmail } from 'validator';
+import { asString, isEmpty, text, Value } from '@thisisagile/easy';
+
+export class Email extends Value {
+  constructor(email?: unknown) {
+    super(asString(email).trim().toLowerCase());
+  }
+
+  get isValid(): boolean {
+    return isEmail(this.value);
+  }
+
+  get name(): string {
+    return text(this.value.split('@')[0]).replace('.', ' ').title.toString();
+  }
+}
+
+export const email = (email?: unknown): Email => new Email(email);
+
+export const isEmail = (e?: unknown): boolean => !isEmpty(e) && validateEmail(asString(e));

package/src/values/IBAN.ts

@@ -0,0 +1,12 @@
+import { isIBAN as validateIBAN } from 'validator';
+import { asString, isEmpty, Value } from '@thisisagile/easy';
+
+export class IBAN extends Value {
+  get isValid(): boolean {
+    return isIBAN(this.value);
+  }
+}
+
+export const isIBAN = (iban?: unknown): boolean => {
+  return !isEmpty(iban) && validateIBAN(asString(iban));
+};

package/src/values/PostalCode.ts

@@ -0,0 +1,17 @@
+import { Id, text, Value } from '@thisisagile/easy';
+import { Country } from '../enums/Country';
+import { isPostalCode, PostalCodeLocale } from 'validator';
+
+export class PostalCode extends Value {
+  constructor(
+    postalCode?: unknown,
+    readonly country: Country | Id = Country.NL
+  ) {
+    super(text(postalCode).replace(' ', '').toString());
+  }
+  get isValid(): boolean {
+    return isPostalCode(this.value, (this.country instanceof Country ? this.country.id : text(this.country).upper) as PostalCodeLocale);
+  }
+}
+
+export const postalCode = (postalCode?: unknown, country: Country | Id = Country.NL) => new PostalCode(postalCode, country);

package/src/values/Slug.ts

@@ -0,0 +1,14 @@
+import { isNotEmpty, text, Value } from '@thisisagile/easy';
+import { isSlug } from 'validator';
+
+export class Slug extends Value {
+  constructor(slug?: unknown) {
+    super(text(slug).slug.toString());
+  }
+
+  get isValid(): boolean {
+    return isNotEmpty(this.value) && isSlug(this.value);
+  }
+}
+
+export const toSlug = (slug?: unknown): Slug => new Slug(slug);

package/src/values/Url.ts

@@ -0,0 +1,73 @@
+import { isURL as validateUrl } from 'validator';
+import { asString, isEmpty, Value } from '@thisisagile/easy';
+
+export interface UrlOptions {
+  /**
+   * @default ['http','https','ftp']
+   */
+  protocols?: string[];
+  /**
+   * @default true
+   */
+  require_tld?: boolean;
+  /**
+   * @default false
+   */
+  require_protocol?: boolean;
+  /**
+   * @default true
+   */
+  require_host?: boolean;
+  /**
+   * if set as true isURL will check if port is present in the URL
+   * @default false
+   */
+  require_port?: boolean;
+  /**
+   * @default true
+   */
+  require_valid_protocol?: boolean;
+  /**
+   * @default false
+   */
+  allow_underscores?: boolean;
+  /**
+   * @default false
+   */
+  host_whitelist?: Array<string | RegExp>;
+  /**
+   * @default false
+   */
+  host_blacklist?: Array<string | RegExp>;
+  /**
+   * @default false
+   */
+  allow_trailing_dot?: boolean;
+  /**
+   * @default false
+   */
+  allow_protocol_relative_urls?: boolean;
+  /**
+   * @default false
+   */
+  disallow_auth?: boolean;
+}
+
+export class Url extends Value {
+  constructor(
+    value: unknown,
+    readonly options?: UrlOptions
+  ) {
+    super(asString(value));
+  }
+
+  get isValid(): boolean {
+    return isUrl(this.value, this.options);
+  }
+}
+
+export const url = (url: unknown, options?: UrlOptions): Url => new Url(url, options);
+
+export const isUrl = (url?: unknown, options?: UrlOptions): boolean => {
+  return !isEmpty(url) && validateUrl(asString(url), options);
+};