Merge pull request #10 from codibre/decorator-helpers

feat: creating decorator helpers

src/decorator-helpers.ts

@@ -0,0 +1,43 @@
+import { getProperMetadataTarget } from './internal/get-proper-metadata-target';
+import { getClassMetadata } from './meta-info';
+import { ClassType, Key } from './meta-type';
+
+export const DEFAULT = Symbol('default');
+
+export function applyPropertyAndMethodsDecorators<T extends object = object>(
+  cls: ClassType<T>,
+  propertyAndMethodsDecorators: Partial<
+    Record<Key<T> | typeof DEFAULT, (MethodDecorator | PropertyDecorator)[]>
+  >,
+) {
+  const def = propertyAndMethodsDecorators[DEFAULT];
+  const meta = getClassMetadata(cls);
+  if (!meta) throw new Error('No class metadata found');
+  for (const prop of meta?.properties.values()) {
+    const decorators = propertyAndMethodsDecorators[prop.name] ?? def;
+    if (decorators) {
+      Reflect.decorate(
+        decorators,
+        getProperMetadataTarget(prop, cls),
+        prop.name,
+      );
+    }
+  }
+  for (const prop of meta?.methods.values()) {
+    const decorators = propertyAndMethodsDecorators[prop.name] ?? def;
+    if (decorators) {
+      Reflect.decorate(
+        decorators,
+        getProperMetadataTarget(prop, cls),
+        prop.name,
+      );
+    }
+  }
+}
+
+export function applyClassDecorators<T extends object = object>(
+  cls: ClassType<T>,
+  decorators: ClassDecorator[],
+) {
+  Reflect.decorate(decorators, cls);
+}

src/index.ts

@@ -1,7 +1,7 @@
+export * from './decorator-helpers';
 export * from './meta-info';
 export * from './meta-type';
 
 import './plugin/decorators';
 import { blockAccess } from './internal';
-
 blockAccess();

src/internal/get-proper-metadata-target.ts

@@ -0,0 +1,8 @@
+import { PropertyMetadata, ClassType, MethodMetadata } from '../meta-type';
+
+export function getProperMetadataTarget<T extends object = object>(
+  prop: PropertyMetadata<T> | MethodMetadata<T>,
+  cls: ClassType,
+): Object {
+  return prop.modifiers.static ? cls : cls.prototype;
+}

src/internal/index.ts

@@ -1 +1,2 @@
+export * from './get-proper-metadata-target';
 export * from './meta-storage';

src/meta-type.ts

@@ -1,6 +1,8 @@
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type ClassType = abstract new (...args: any[]) => unknown;
-export type Key = string | symbol;
+export type ClassType<T extends object = object> = abstract new (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ...args: any[]
+) => T;
+export type Key<T extends object = object> = keyof T | keyof ClassType<T>;
 
 export interface ModifiersMetadata {
   public: boolean;
@@ -20,23 +22,26 @@ export interface BaseMetadata {
   modifiers: ModifiersMetadata;
 }
 
-export interface ConstructorMetadata extends BaseMetadata {
-  cls: ClassType;
+export interface ConstructorMetadata<T extends object = object>
+  extends BaseMetadata {
+  cls: ClassType<T>;
   args: unknown[];
 }
-export interface MethodMetadata extends BaseMetadata {
-  name: Key;
+export interface MethodMetadata<T extends object = object>
+  extends BaseMetadata {
+  name: Key<T>;
   args: unknown[];
   returnType: unknown;
   propertyDescriptor: PropertyDescriptor;
 }
-export interface PropertyMetadata extends BaseMetadata {
-  name: Key;
+export interface PropertyMetadata<T extends object = object>
+  extends BaseMetadata {
+  name: Key<T>;
   type: unknown;
 }
 
-export interface ClassMetadata {
-  ctor: ConstructorMetadata;
-  properties: Map<Key, PropertyMetadata>;
-  methods: Map<Key, MethodMetadata>;
+export interface ClassMetadata<T extends object = object> {
+  ctor: ConstructorMetadata<T>;
+  properties: Map<Key<T>, PropertyMetadata<T>>;
+  methods: Map<Key<T>, MethodMetadata<T>>;
 }

src/plugin/decorators.ts

@@ -1,22 +1,25 @@
 import { getMetadataStorage } from '../internal';
 import {
+  ClassMetadata,
   ClassType,
   ConstructorMetadata,
   Key,
+  MethodMetadata,
   ModifiersMetadata,
+  PropertyMetadata,
 } from '../meta-type';
 
 const metadata = getMetadataStorage();
 
-function getMeta(prototype: object) {
-  let ref = metadata.get(prototype);
+function getMeta<T extends object = object>(prototype: T) {
+  let ref = metadata.get(prototype) as ClassMetadata<T> | undefined;
   if (!ref) {
     ref = {
-      ctor: undefined as unknown as ConstructorMetadata,
-      properties: new Map(),
-      methods: new Map(),
+      ctor: undefined as unknown as ConstructorMetadata<T>,
+      properties: new Map<Key<T>, PropertyMetadata>(),
+      methods: new Map<Key<T>, MethodMetadata>(),
     };
-    metadata.set(prototype, ref);
+    metadata.set(prototype, ref as unknown as ClassMetadata<object>);
   }
   return ref;
 }
@@ -45,13 +48,11 @@ export function registerPropertyMetadata(modifiers: ModifiersMetadata) {
   };
 }
 
-export function registerMethodMetadata(modifiers: ModifiersMetadata) {
-  return (
-    prototype: object,
-    key: Key,
-    propertyDescriptor: PropertyDescriptor,
-  ) => {
-    const ref = getMeta(prototype);
+export function registerMethodMetadata<T extends object = object>(
+  modifiers: ModifiersMetadata,
+) {
+  return (prototype: T, key: Key, propertyDescriptor: PropertyDescriptor) => {
+    const ref = getMeta<T>(prototype);
     const returnType = Reflect.getMetadata('design:returntype', prototype, key);
     ref.methods.set(key, {
       name: key,

src/plugin/emitter.ts

@@ -20,7 +20,9 @@ function addRef(
   }
 }
 
-function* emitPropertyAssignments(obj: Record<Key, boolean>) {
+function* emitPropertyAssignments<T extends object = object>(
+  obj: Record<Key<T>, boolean>,
+) {
   for (const k in obj) {
     if (k in obj) {
       yield tsBinary.factory.createPropertyAssignment(