Variable

The opposite of Before. This method creates a function that invokes once it's called n or more times.

Example:

class MyClass {
  @After(2)
  fn() {
    return 10;
  }
}

const myClass = new MyClass();

myClass.fn(); // => undefined
myClass.fn(); // => 10

The opposite of Before. This method creates a function that invokes once it's called n or more times. This spans across all instances of the class instead of the instance.

Example:

class MyClass {
  @AfterAll(2)
  fn() {
    return 10;
  }
}

const myClass = new MyClass();
const myClass2 = new MyClass();

myClass.fn(); // => undefined
myClass.fn(); // => 10

myClass2.fn(); // => 10
myClass2.fn(); // => 10

Creates a function that invokes func, with up to n arguments, ignoring any additional arguments.

Example:

class MyClass {
  @Ary(1)
  fn(...args) {
    return args;
  }
}

const myClass = new MyClass();

myClass.fn(1, 2, 3, 4); // => [ 1 ]

Attempts to invoke func, returning either the result or the caught error object. Any additional arguments are provided to func when it's invoked.

Example:

class MyClass {
  @Attempt()
  fn(value) {
    if (typeof value === 'number') {
      return value
    }

    throw new Error();
  }
}

const myClass = new MyClass();

myClass.fn(10); // => 10;
myClass.fn(null); // => Error

Creates a function that invokes func, with the this binding and arguments of the created function, while it's called less than n times. Subsequent calls to the created function return the result of the last func invocation.

Example:

let calls = 0;

class MyClass {
  @Before(3)
  fn() {
    calls++;
  }
}

const myClass = new MyClass();

myClass.fn();
myClass.fn();
myClass.fn();
myClass.fn();

calls === 2; // => true

Creates a function that invokes func, with the this binding and arguments of the created function, while it's called less than n times. Subsequent calls to the created function return the result of the last func invocation.

Example:

let calls = 0;

class MyClass {
  @BeforeAll(3)
  fn() {
    calls++;
  }
}

const myClass = new MyClass();
const myClass2 = new MyClass();

myClass.fn();
myClass.fn();
myClass.fn();
myClass.fn();

myClass2.fn();

calls === 3; // => true

Creates a function that invokes func with the this binding of thisArg and partials prepended to the arguments it receives.

The .bind.placeholder value, which defaults to in monolithic builds, may be used as a placeholder for partially applied arguments.

Note: Unlike native Function#bind, this method doesn't set the "length" property of bound functions.

Example:

class MyClass {
  @Bind()
  bound() {
    return this;
  }

  unbound() {
    return this;
  }
}

const myClass = new MyClass();

myClass.bound.call(null); // => myClass {}
myClass.unbound.call(null); // => null

Creates a function that accepts arguments of func and either invokes func returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient. The original function is bound to the instance. If the method is needed to call in a different context use CurryAll.

The .curry.placeholder value, which defaults to in monolithic builds, may be used as a placeholder for provided arguments.

Note: This method doesn't set the "length" property of curried functions.

Example:

class MyClass {
  multiplier = 2;

  @Curry()
  add(a, b) {
    return (a + b) * this.multiplier;
  }
}

const myClass = new MyClass();

const add5 = myClass.add(5);

add5AndMultiply(10); // => 30

Creates a function that accepts arguments of func and either invokes func returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.

The .curry.placeholder value, which defaults to in monolithic builds, may be used as a placeholder for provided arguments.

Note: This method doesn't set the "length" property of curried functions. Note: The original function invoked will not be called in the context of the instance. Use Curry to for using it bound.

Example:

class MyClass {
  @CurryAll()
  add(a, b) {
    return (a + b);
  }
}

const myClass = new MyClass();

const add5 = myClass.add(5);

add5AndMultiply(10); // => 15

This method is like .curry except that arguments are applied to func in the manner of .partialRight instead of _.partial. The arity of func may be specified if func.length is not sufficient. The original function is bound to the instance. If the method is needed to call in a different context use CurryAll.

The .curryRight.placeholder value, which defaults to in monolithic builds, may be used as a placeholder for provided arguments.

Note: This method doesn't set the "length" property of curried functions.

Example:

class MyClass {
  multiplier = 2;

  @CurryRight()
  add(a, b) {
    return (a + b) * this.multiplier;
  }
}

const myClass = new MyClass();

const add5 = myClass.add(5);

add5AndMultiply(10); // => 30

This method is like .curry except that arguments are applied to func in the manner of .partialRight instead of _.partial. The arity of func may be specified if func.length is not sufficient. The original function is bound to the instance. If the method is needed to call in a different context use CurryAll.

The .curryRight.placeholder value, which defaults to in monolithic builds, may be used as a placeholder for provided arguments.

Note: This method doesn't set the "length" property of curried functions.

Example:

class MyClass {
  @CurryRightAll()
  add(a, b) {
    return (a + b);
  }
}

const myClass = new MyClass();

const add5 = myClass.add(5);

add5AndMultiply(10); // => 15

Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since the last time the debounced function was invoked. The debounced function comes with a cancel method to cancel delayed func invocations and a flush method to immediately invoke them. Provide options to indicate whether func should be invoked on the leading and/or trailing edge of the wait timeout. The func is invoked with the last arguments provided to the debounced function. Subsequent calls to the debounced function return the result of the last func invocation.

Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only if the debounced function is invoked more than once during the wait timeout.

If wait is 0 and leading is false, func invocation is deferred until to the next tick, similar to setTimeout with a timeout of 0.

Example:

class MyClass {
  value = 100;

  @Debounce(10)
  add(a) {
    this.value += a;
  }
}

const myClass = new MyClass();

myClass.add(10);
myClass.add(50);
myClass.add(20);

myClass.value; // => 100;

setTimeout(() => {
  myClass.value; // => 120;
}, 11);

Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since the last time the debounced function was invoked. The debounced function comes with a cancel method to cancel delayed func invocations and a flush method to immediately invoke them. Provide options to indicate whether func should be invoked on the leading and/or trailing edge of the wait timeout. The func is invoked with the last arguments provided to the debounced function. Subsequent calls to the debounced function return the result of the last func invocation.

The debounce state is shared across all instances of the class.

Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only if the debounced function is invoked more than once during the wait timeout.

If wait is 0 and leading is false, func invocation is deferred until to the next tick, similar to setTimeout with a timeout of 0.

Example:

class MyClass {
  value = 100;

  @DebounceAll(10)
  add(a) {
    this.value += a;
  }
}

const myClass = new MyClass();

myClass.add(10);
myClass.add(50);
myClass.add(20);

myClass.value; // => 100;

setTimeout(() => {
  myClass.value; // => 120;
}, 11);

Defers invoking the func until the current call stack has cleared. Any additional arguments are provided to func when it's invoked.

Example:

class MyClass {
  value = 100;

  @Defer()
  add(a) {
    this.value += a;
  }
}

const myClass = new MyClass();

myClass.add(10);

myClass.value; // => 100;

setTimeout(() => {
  myClass.value; // => 110;
}, 0);

Invokes func after wait milliseconds. Any additional arguments are provided to func when it's invoked.

Example:

class MyClass {
  value = 100;

  @Delay(20)
  add(a) {
    this.value += a;
  }
}

const myClass = new MyClass();

myClass.add(10);

myClass.value; // => 100;

setTimeout(() => {
  myClass.value; // => 110;
}, 30);

Creates a function that invokes func with arguments reversed. Honestly, there is probably not much use for this decorator but maybe you will find one?

Example:

class MyClass {
  value = 100;

  @Flip()
  fn(a, b) {
    return [ a, b ];
  }
}

const myClass = new MyClass();

myClass.fn(10, 20); // => [ 20, 10 ]

Creates a function that returns the result of invoking the given functions with the this binding of the created function, where each successive invocation is supplied the return value of the previous.

Example:

class MyClass {
  name = 'Ted';

  @Flow('getName', toUpperCase)
  getUpperCaseName: () => string;

  getName() {
    return this.name;
  }
}

const myClass = new MyClass();

myClass.getUpperCaseName(); // => 'TED'

Creates a function that returns the result of invoking the given functions with the this binding of the created function, where each successive invocation is supplied the return value of the previous.

Example:

class MyClass {
  name = 'Ted';

  @FlowRight(toUpperCase, 'getName')
  getUpperCaseName: () => string;

  getName() {
    return this.name;
  }
}

const myClass = new MyClass();

myClass.getUpperCaseName(); // => 'TED'

Memoizes a function on the prototype instead of the instance. All instances of the class use the same memoize cache.

Returns the first argument from the function regardless of the decorated functions return value.