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

class Foo {
  // alias() can be used to create multiple aliases from one original member
  @alias("qux", "nurp")
  bar(): string {
    return "baz";
  }

  // declare the aliased members to avoid compilation errors
  declare qux: Foo["bar"];
  declare nurp: Foo["bar"];

  // or, use @alias.for on the alias itself and pass it the original member name.
  @alias.for("bar")
  baz(): string {
    return this.bar();
  }
}

const foo = new Foo();

console.assert(foo.bar === "baz"); // OK
console.assert(foo.bar === foo.baz); // OK
console.assert(foo.qux === foo.bar); // OK
console.assert(foo.nurp === foo.bar); // OK

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

class Foo {
  @bind
  bar(): Foo {
    return this;
  }

  @bind
  static self(): typeof Foo {
    return this;
  }
}
const { self } = Foo, { bar } = new Foo();

console.log(self === Foo); // true
console.log(bar() instanceof Foo); // true

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

class BasicExample {
  @lru({ maxSize: 64, ttl: 1000 })
  memoized(arg1: string, arg2: number): string {
    return `${arg1}-${arg2}`;
  }
}

const example = new BasicExample();
console.log(example.memoizedMethod("foo", 42)); // "foo-42"
console.log(example.memoizedMethod("foo", 42)); // "foo-42" (cached)

import {
  type AnyDecoratorArguments,
  type AnyDecoratorReturn,
  isDecoratorArguments,
  isLegacyDecoratorArguments,
} from "@decorators/types";

function toStringTag<Args extends AnyDecoratorArguments>(
  value: string,
): (...args: Args) => AnyDecoratorReturn<Args>;
// deno-lint-ignore no-explicit-any
function toStringTag(value: string): (...args: any[]) => any {
  return (...args) => {
    if (isDecoratorArguments(args)) {
      const [target, context] = args;
      if (context.kind !== "class") {
        throw new TypeError(
          `@toStringTag cannot decorate ${context.kind}s - it can only be used on the class itself.`,
        );
      }
      context.addInitializer(function () {
        Object.defineProperty(this.prototype, Symbol.toStringTag, {
          value,
          configurable: true,
        });
      });
    } else if (isLegacyDecoratorArguments(args)) {
      const [target] = args;
      Object.defineProperty(target.prototype, Symbol.toStringTag, {
        value,
        configurable: true,
      });
    } else {
      throw new TypeError("@toStringTag received invalid arguments");
    }
  };
}

// this decorator factory works in TS 4.x and 5.x without issue:
@toStringTag("Foo")
class Foo {
  // ...
}