alias

The @decorators/alias package provides a simple decorator factory named @alias, which allows you to alias one class member to another with zero configuration. It supports aliasing class fields, accessors, methods, getters, and setters. Compatible with both the instance side and the static side of any TypeScript/JavaScript class.

Getting Started

All @decorators/* packages are published exclusively to JSR.io, a new registry for TypeScript and JavaScript developers, with a keen focus on performance, security, and compatibility.

1. Install

deno add @decorators/alias

jsr add @decorators/alias

bunx jsr add @decorators/alias

npx jsr add @decorators/alias

pnpx jsr add @decorators/alias

yarn dlx jsr add @decorators/alias

2. Enjoy!

import { alias } from "@decorators/alias";

class Example {
  declare private hello: this["greet"];
  declare private welcome: this["greet"];

  private greeting = "Hello World";

  @alias.for("greeting")
  private message!: string;

  @alias("hello", "welcome")
  greet() {
    return this.message;
  }
}

Warning: Please ensure the experimentalDecorators option is disabled in your tsconfig.json or deno.json file's compilerOptions section.

This package will not work if legacy TypeScript decorators are enabled.

API

There are two different approaches to creating aliases with this package, both of which are available from the same named import, alias.

alias

The first is to use @alias directly on a class member you wish to alias, and provide it with the name(s) of the alias(es) it should create to that member. This allows you to create any number of aliases for a given class member, with each alias name passed as an argument to the decorator factory.

Usage

class A {
  // these are important!
  declare b: this["a"];
  declare c: this["a"];

  @alias("b", "c")
  a() {
    // ...
  }
}

Signature

export function alias<
  Aliases extends readonly PropertyKey[],
  This extends object = object,
  Value = unknown,
>(...aliases: Aliases): {
  (target: unknown, context: DecoratorContext): void;
};

This signature is in a simplified form for the sake of brevity. See the source code in mod.ts for the actual function signature as it is used in the implementation.

Parameters

Returns

This decorator factory returns a decorator function that can be applied to any class member type, including fields, accessors, methods, getters, and setters. It cannot be used on the class itself. The decorator it returns does not return a replacement member, but instead leverages initialization side-effects via the addInitializer API, creating the alias(es) at initialization time.

Example

Take note of the logical flow in this approach, demonstrated below, where the aliases are defined on the original member that is being decorated. You can think of it in natural language as "The 'greeting' field is also aliased as 'message'.", or "The 'greet' method is also aliased as 'hello' and 'welcome'.".

import { alias } from "@decorators/alias";

class Example {
  declare private message: string;
  declare private hello: this["greet"];
  declare private welcome: this["greet"];

  @alias("message")
  private greeting = "Hello World";

  @alias("hello", "welcome")
  greet() {
    return this.message;
  }
}

const example = new Example();

// The original method:
console.log(example.greet()); // "Hello World"

// The aliases to that method:
console.log(example.hello()); // "Hello World"
console.log(example.welcome()); // "Hello World"
console.log(example.hello === example.greet); // true

Note: notice the property declarations in the following example. These ensure the TypeScript compiler recognizes each alias as a valid member of the class. If they were elided, tsc would raise compile errors complaining about non-existent properties.

alias.for

The second approach to aliasing class members with this package is to use the @alias.for method. Similar to the @alias function, this is also a decorator factory, but differs in that applied to the alias itself, providing it with the name of the member it should point to. This accepts only one argument, which must be the name of another existing member of the class.

Usage

class Hi {
  message = "Hello World";

  greet() {
    return this.message;
  }

  @alias.for("greet") // source: greet, target: hello
  hello!: this["greet"]; // this is defined at initialization

  @alias.for("greet") // source: greet, target: welcome
  welcome(): string { // this is overridden at initialization
    return this.greet();
  }
}

Signature

alias.for = function<Source extends PropertyKey>(source: Source): {
  (target: unknown, context: DecoratorContext): void;
};

Parameters

Returns

This decorator factory returns a decorator that can be applied to any class member type, including fields, accessors, methods, getters, and setters. It cannot be used on the class itself. The decorator it returns does not return a replacement member (except when used on a field/accessor), but instead leverages initialization side-effects via the addInitializer API, creating the alias(es) at initialization time.

Example

import { alias } from "@decorators/alias";

class Example {
  private greeting = "Hello World";

  @alias.for("greeting")
  private message!: string;

  greet() {
    return this.message;
  }

  @alias.for("greet")
  hello!: this["greet"];

  @alias.for("greet")
  welcome(): string {
    return this.greet();
  }
}

const example = new Example();

// The original method:
console.log(example.greet()); // "Hello World"

// The aliases to that method:
console.log(example.hello()); // "Hello World"
console.log(example.welcome()); // "Hello World"
console.log(example.hello === example.greet); // true