Money

Index

Codec

• __decode__
• __encode__
• __schema__

Comparator

• !=
• ＜
• ＜=
• ==
• ＞
• ＞=
• clamp
• compare
• equals
• max
• min

Constructor

• create

Formatting

• asString

Numeric

• -
• *
• +
• isNegative
• isPositive
• isZero
• negate

Type

• __inspect__
• typeName
• asInstance
• hasInstance

Other

• __call__
• format
• normalize
• parse

Codec

__decode__

• __decode__(this, input, context): Result<Money, CodecError>

• Returns the decoded input, Result.Ok or Result.Error()

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const input: unknown = ...;
  const decoded = Codec.decode(someCodec, input);

__encode__

• __encode__(this, input): unknown

• Returns the encoded input

  interface SomeObject {
    foo: string
  }
  const someCodec: Codec<SomeObject> = ...;
  const someObject: SomeObject = { foo: "bar" }
  const encoded = Codec.decode(someCodec, someObject);

__schema__

• __schema__(this): JSONValue

• Returns the JSONSchema corresponding to the decoded type

  const someCodec: Codec<unknown> = ...;
  const jsonSchema = Codec.schema(someCodec);

Comparator

!=

• !=(this, left, right): boolean

• "Not equal to" operator

  const TEqual: Equal<T>;
  TEqual['!='](value, otherValue); // true
  TEqual['!='](value, value); // false

＜

• ＜(this, left, right): boolean

• "Less than" operator

  type T;
  const TCompare: Comparable<T>;
  const smallerT: T;
  const greaterT: T;
  TCompare['<'](smallerT, smallerT); // false
  TCompare['<'](smallerT, greaterT); // true
  TCompare['<'](greaterT, smallerT); // false

＜=

• ＜=(this, left, right): boolean

• "Less than or equal to" operator

  type T;
  const TCompare: Comparable<T>;
  const smallerT: T;
  const greaterT: T;
  TCompare['<='](smallerT, smallerT); // true
  TCompare['<='](smallerT, greaterT); // true
  TCompare['<='](greaterT, smallerT); // false

==

• ==(this, left, right): boolean

• "Equal to" operator

  type T = // ...
  const TEqual: Equal<T>;
  TEqual['=='](value, value); // true
  TEqual['=='](value, otherValue); // false

＞

• ＞(this, left, right): boolean

• "Greater than" operator

  type T;
  const TCompare: Comparable<T>;
  const smallerT: T;
  const greaterT: T;
  TCompare['>'](smallerT, smallerT); // false
  TCompare['>'](smallerT, greaterT); // false
  TCompare['>'](greaterT, smallerT); // true

＞=

• ＞=(this, left, right): boolean

• "Greater than or equal to" operator

  type T;
  const TCompare: Comparable<T>;
  const smallerT: T;
  const greaterT: T;
  TCompare['>='](smallerT, smallerT); // true
  TCompare['>='](smallerT, greaterT); // false
  TCompare['>='](greaterT, smallerT); // true

clamp

• clamp(this, value, minValue, maxValue): Money

• Clamp value between minValue and maxValue

  type T;
  const TCompare: Comparable<T>;
  TCompare.clamp(value, min, max); // min if value < min, max if value > max, otherwise value itself

compare

• compare(this, left, right): Ordering

• Return an Ordering that represents comparison result

  type T;
  const TCompare: Comparable<T>;
  const sorted = [3, 1, 1].sort(TCompare.compare);

  See more at Order

equals

• equals(this, left, right): boolean

• Alias to '=='

  type T = // ...
  const TEqual: Equal<T>;
  TEqual.equals(value, value); // true
  TEqual.equals(value, otherValue); // false

max

• max(this, left, right): Money

• "maximum" operator

  type T;
  const TCompare: Comparable<T>;
  const smallerT: T;
  const greaterT: T;
  TCompare.max(smallerT, greaterT); // greaterT

min

• min(this, left, right): Money

• "minimum" operator

  type T;
  const TCompare: Comparable<T>;
  const smallerT: T;
  const greaterT: T;
  TCompare.min(smallerT, greaterT); // smallerT

Constructor

create

• create(this, properties): Money

• Construct a new model

Formatting

asString

• asString(this, self): string

• Converts the given value to a String.

  Number.asString(123); // '123'

Numeric

-

• -(this, left, right): Result<Money, ArgumentError>

• Subtract operator

  Money['-'](EUR(2), EUR(1));// Result.Ok(EUR(1))
  Money['-'](EUR(1), USD(2));// Result.Error(new ArgumentError({ message: 'Incompatible currencies EUR and USD' }))

*

• *(this, money, multiplier): Money

• Multiply operator

  Money['*'](EUR(2), BigDecimal('2'));// EUR("4")

+

• +(this, left, right): Result<Money, ArgumentError>

• Addition operator

  Money['+'](EUR(1), EUR(2));// Result.Ok(EUR(1))
  Money['+'](EUR(1), USD(2));// Result.Error(new ArgumentError({ message: 'Incompatible currencies EUR and USD' }))

isNegative

• isNegative(this, self): boolean

• Returns true if the number is negative and false if the number is zero or positive.

isPositive

• isPositive(this, self): boolean

• Returns true if the number is positive and false if the number is zero or negative.

isZero

• isZero(this, self): boolean

• Returns true if self is equal to the additive identity.

  Money.isZero(EUR('0')); // true
  Money.isZero(EUR('1')); // false

negate

• negate(this, self): Money

• Negates the given value.

  Number.negate(5); // -5
  Number.negate(Number.negate(5)); // 5

Type

__inspect__

__inspect__: Option<(anyValue, depth, options, inspect) => string>

When defined, returns a custom string representation. To be useful, it should be bound to a prototype (ex: Struct)

import { inspect } from 'node:util';

interface Foo {
  foo: boolean;
}
const Foo = Struct.define<Foo>({
  typeName: 'Foo',
  __inspect__: (self) => `Foo { ${String(self.foo)} }`,
});
const myStruct = Struct.create(Foo, { foo: true });// 'Foo { true }'
inspect(myStruct);// 'Foo { true }'

readonlytypeName

typeName: Money

The factory type constant

asInstance

• asInstance(this, anyValue): Option<Money>

• Try to convert anyValue to enum value or else returns Option.None

  const StringType: Type<string>;
  StringType.asInstance('foo'); // Option.Some('foo')
  StringType.asInstance(12); // Option.None

hasInstance

• hasInstance(this, anyValue): anyValue is Money

• Return true if the given value is an instance of the class.

  const StringType: Type<string>;
  StringType.hasInstance('foo'); // true
  StringType.hasInstance(42); // false

Other

__call__

• __call__(properties): Money

format

• format(self): string

• Returns a formatted representation of money

  Money.format(EUR('1.10'));// '1.10EUR';

normalize

• normalize(self): Money

• Normalizes a BigDecimal object to its simplest form. This means that the decimal part is reduced to its lowest terms.

  Money.normalize(USD('1.020'));// USD('1.02')
  Money.normalize(USD('1.02'));// USD('1.02')

parse

• parse(expression): Option<Money>

• Parses a string argument and returns a Money If the expression is not valid, it returns Option.None

  Money.parse('1.1EUR');// Option.Some(EUR('1.1'))
  Money.parse('invalid');// Option.None