TimeDuration

A collection of functions to manipulate time duration (i.e amount of milliseconds)

Index

Codec

• codecDecode
• codecEncode
• codecSchema

Comparator

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

Constructor

• asInstance
• days
• hours
• milliseconds
• minutes
• of
• seconds
• weeks

Numeric

• *
• +
• -
• abs
• sign

Type

• inspect
• hasInstance

Other

• typeName
• __call__
• from
• unwrap
• wrap

Codec

codecDecode

• codecDecode(this: void, input: unknown, context: Context<TimeDuration>): Result<TimeDuration, CodecError>

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

  @example

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

codecEncode

• codecEncode(this: void, input: TimeDuration): unknown

• Returns the encoded input

  @example

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

codecSchema

• codecSchema(this: void): JSONValue

• Returns the JSONSchema corresponding to the decoded type

  @example

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

Comparator

!=

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

• "Not equal to" operator

  @example

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

＜

• ＜(this: void, left: TimeDuration, right: TimeDuration): boolean

• "Less than" operator

  @example

  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: void, left: TimeDuration, right: TimeDuration): boolean

• "Less than or equal to" operator

  @example

  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: void, left: TimeDuration, right: TimeDuration): boolean

• "Equal to" operator

  @example

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

＞

• ＞(this: void, left: TimeDuration, right: TimeDuration): boolean

• "Greater than" operator

  @example

  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: void, left: TimeDuration, right: TimeDuration): boolean

• "Greater than or equal to" operator

  @example

  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: void, value: TimeDuration, minValue: TimeDuration, maxValue: TimeDuration): TimeDuration

• Clamp value between minValue and maxValue

  @example

  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: void, left: TimeDuration, right: TimeDuration): number

• Return a number that represents comparison

  @example

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

equals

• equals(this: void, left: TimeDuration, right: TimeDuration): boolean

• Alias to '=='

  @example

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

max

• max(this: void, left: TimeDuration, right: TimeDuration): TimeDuration

• "maximum" operator

  @example

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

min

• min(this: void, left: TimeDuration, right: TimeDuration): TimeDuration

• "minimum" operator

  @example

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

Constructor

asInstance

• asInstance(anyValue: unknown): Option<TimeDuration>

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

  @example

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

days

• days(amount: number): TimeDuration

• Return a duration of amount days

  @example

  const duration = TimeDuration.days(1);// 1000 * 60 * 60 * 24

hours

• hours(amount: number): TimeDuration

• Return a duration of amount hours

  @example

  const duration = TimeDuration.hours(1);// 1000 * 60 * 60

milliseconds

• milliseconds(amount: number): TimeDuration

• Return a duration of amount milliseconds

  @example

  const duration = TimeDuration.milliseconds(1);// 1

minutes

• minutes(amount: number): TimeDuration

• Return a duration of amount minutes

  @example

  const duration = TimeDuration.minutes(1);// 1000 * 60

of

• of(milliseconds: number): TimeDuration

• Return a duration from a number

  @example

  const duration = TimeDuration.of(0);// typeof duration === 'number'

seconds

• seconds(amount: number): TimeDuration

• Return a duration of amount seconds

  @example

  const duration = TimeDuration.seconds(1);// 1000

weeks

• weeks(amount: number): TimeDuration

• Return a duration of amount days

  @example

  const duration = TimeDuration.weeks(1);// 1000 * 60 * 60 * 24 * 7

Numeric

*

• *(left: TimeDuration, right: TimeDuration): TimeDuration

• Multiplication operator

  @example

  type T = ...;
  const TNumeric: Numeric.Multiply<T> = ...;
  const result = Numeric['*'](left, right);// represents (left * right)

+

• +(left: TimeDuration, right: TimeDuration): TimeDuration

• Addition operator

  @example

  type T = ...;
  const TNumeric: Numeric.Add<T> = ...;
  const result = TNumeric['+'](left, right);// represents (left + right)

-

• -(left: TimeDuration, right: TimeDuration): TimeDuration

• Subtraction operator

  @example

  type T = ...;
  const TNumeric: Numeric.Subtract<T> = ...;
  const result = Numeric['-'](left, right);// represents (left - right)

abs

• abs(value: TimeDuration): TimeDuration

• Absolute value. It should satisfy Numeric['*'](Numeric.abs(x), Numeric.sign(x)) == x

  @example

  type T = ...;
  const TSigned: Numeric.Signed<T> = ...;
  const result = TSigned.abs(value);// absolute value of (value)

sign

• sign(value: TimeDuration): TimeDuration

• Sign of a number. It should satisfy TSigned['*'](TSigned.abs(x), TSigned.sign(x)) == x

Type

inspect

inspect: Option<(anyValue: TimeDuration, depth: number, options: InspectOptions, inspect: InspectFunction) => string>

When defined, returns a custom string representation

@example

@param

hasInstance

• hasInstance(anyValue: unknown): anyValue is TimeDuration

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

  @example

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

Other

typeName

Re-exports typeName

__call__

• __call__(source: number | TimeDurationObject): TimeDuration

• Converts a number or a TimeDurationObject to a TimeDuration

  @example

  const duration = TimeDuration.from(1000);// 1000
  const duration = TimeDuration.from({ milliseconds: 3, seconds: 2, hours: 1 });// 3 + 1000 * 2 + 1000 * 60 * 60 * 1

from

• from(source: number | TimeDurationObject): TimeDuration

• Converts a number or a TimeDurationObject to a TimeDuration

  @example

  const duration = TimeDuration.from(1000);// 1000
  const duration = TimeDuration.from({ milliseconds: 3, seconds: 2, hours: 1 });// 3 + 1000 * 2 + 1000 * 60 * 60 * 1

unwrap

• unwrap(value: TimeDuration): number

• Convert a tagged value to the underlying type

wrap

• wrap(value: number): TimeDuration

• Convert an underlying type to a tagged type