Décorateurs tapeurs de classe en tant que Mixins

Question

Je cherche à améliorer un peu de code que je pense être une bonne représentation de l'utilisation de décorateurs de classe comme mixins avec la question de Typescript this est exactement ce que je cherche mais avec une solution de 'Non Possible J'ai commencé à pirater.

le résultat est le code de travail

declare type Constructor<T = {}> = new(...args: any[]) => T 

//Permissions function runs when @Permissions is placed as a class decorator 
export function Permissions<TBase extends Constructor>(Base:TBase) { 
    return class extends Base { 
     read: boolean = false; 
     edit: boolean = false; 
     admin: boolean = false; 
     constructor(...args: any[]) { 
      super(...args); 
      this.read = false; 
      this.edit = false; 
      this.admin = false; 
     } 
     isRead(): boolean { 
      return this.read; 
     } 
     isEdit(): boolean { 
      return this.edit; 
     } 
     isAdmin(): boolean { 
      return this.admin; 
     } 
     setRead(value: boolean): void { 
      this.read = value; 
     } 
     setEdit(value: boolean): void { 
      this.edit = value; 
     } 
     setAdmin(value: boolean): void { 
      this.read = value 
      this.edit = value 
      this.admin = value 
     } 
    } 
} 
// Interface to provide TypeScript types to the object Object 
export interface IPermissions { 
     read: boolean; 
     edit: boolean; 
     admin: boolean; 
     constructor(...args: any[]); 
     isRead(): boolean; 
     isEdit(): boolean; 
     isAdmin(): boolean 
     setRead(value: boolean): void 
     setEdit(value: boolean): void 
     setAdmin(value: boolean): void 
} 
//Extends the User Object with properties and methods for Permissions 
interface User extends IPermissions {} 

//Class Decorator 
@Permissions 
class User { 
    name: string; 
    constructor(name: string, ...args: any[]) { 
     this.name = name; 
    } 
} 

// Example instantiation. 
let user = new User("Nic") 
user.setAdmin(true); 
console.log(user.name + ": has these Permissions; Read: " + user.isRead() + " Edit: " + user.isEdit() + " Admin: " + user.isAdmin()) 

La question que je doit faire avec l'interface. Je voudrais créer la définition d'interface dynamiquement à partir de la fonction Permissions. Alors que tout ce que j'ai vraiment besoin de faire est de modifier la fonction d'autorisation afin d'obtenir les types appropriés dans l'objet utilisateur

Y at-il un moyen de faire cela en TypeScript?

Answer 1

tl; dr au moment d'écrire tristement je ne pense pas.

Dans mon utilitaire, j'ai le même problème avec un mixin Poolable qui implémente aussi IPoolable.

export function Poolable<T extends Constructor>(Base: T): T & ICtor<IPoolable> { 
    return class extends Base implements IPoolable { 
     public __pool__: Pool<this>; 
     public release() { 
      this.__pool__.release(this); 
     } 
     public initPool(pool: Pool<this>): void { 
      this.__pool__ = pool; 
     } 
     constructor(...args: any[]) { 
      super(...args); 
     } 
    }; 
} 

Et faire la danse mixin ça marche, en passant les interfaces.

class Base {} 
class Obj extends Poolable(Base) {} 
let pool = new Pool(Obj); 

Mais le code suivant ne le fait pas.

@Poolable 
class Base {} 
const pool = new Pool(Base); 

Pour moi c'est un bug et j'espère qu'ils le répareront bientôt.