instanceof SerializableResource

[plojo]

After some consideration, I came up with the following idea to enable the usage of the instanceof keyword with SerializableResource. This approach leverages decorators and metadata.

We define SerializableResource as an abstract class. Abstract classes can be used similarly to interfaces through the implements keyword. Additionally, we apply a decorator to our class, which will be explained below:

Example:

@SerializableResource.register
export class Material extends Mutable implements SerializableResource {}

The abstract class SerializableResource now allows us to achieve two things:

1. Encapsulate a decorator (register) that registers the class, using the class's metadata to indicate that it implements SerializableResource.
2. Override [Symbol.hasInstance] (instanceof behavior) to check the metadata of a given instance to verify whether it implements SerializableResource.

SerializableResource:

export abstract class SerializableResource implements Serializable {
  public abstract name: string;
  public abstract idResource: string;
  public abstract readonly type: string;

  // decorator
  public static register(_class: abstract new (...args: General[]) => SerializableResource, _context: ClassDecoratorContext): void {
    let meta: Metadata = _context.metadata;
    meta.implements ??= [];
    meta.implements.push(SerializableResource);
  }

  // instanceof
  public static [Symbol.hasInstance](_instance: unknown): _instance is SerializableResource {
    if (Function.prototype[Symbol.hasInstance].call(SerializableResource, _instance)) // default instanceof behavior
      return true;

    let meta: Metadata = _instance.constructor[Symbol.metadata]; // check the metadata
    return meta?.implements?.includes(SerializableResource);
  }

  public abstract serialize(): Serialization;
  public abstract deserialize(_serialization: Serialization): Promise<Serializable>;
}

To make this work, we need to decorate our class with @SerializableResource.register (see Example). Once the class is registered, we can now do the following:

Let instance: Material = new Material("Material");
// check instance
instance instanceof SerializableResource // true
// check class
Material.prototype instanceof SerializableResource // true

Note: We could expand this pattern to allow the registration of custom resources compatible with the editor. The abstract class could keep track of all registered SerializableResources, enabling creators to register their own custom SerializableResources.

[JirkaDellOro]

Well... errr... sounds good to me.