@rustable/type/lib/factory.js

A TypeScript implementation of Rust-like type system with generic support and runtime type information.

'use strict';

var type = require('./type.js');

"use strict";
const factoryCache = /* @__PURE__ */ new WeakMap();
function createFactory(BaseClass, factoryFn) {
  BaseClass = type.Type(BaseClass);
  const cache = factoryCache.get(BaseClass) || /* @__PURE__ */ new WeakMap();
  factoryCache.set(BaseClass, cache);
  const key = factoryFn ?? BaseClass;
  if (cache.has(key)) {
    return cache.get(key);
  }
  function Factory(...args) {
    if (!(this instanceof Factory)) {
      return factoryFn ? factoryFn(...args) : new BaseClass(...args);
    }
    return Reflect.construct(BaseClass, args, this.constructor);
  }
  Factory.prototype = BaseClass.prototype;
  const staticProps = Object.getOwnPropertyDescriptors(BaseClass);
  Object.defineProperties(Factory, staticProps);
  Object.setPrototypeOf(Factory, BaseClass);
  cache.set(key, Factory);
  return Factory;
}
function createFactoryProxy(BaseClass, factoryFn) {
  BaseClass = type.Type(BaseClass);
  const cache = factoryCache.get(BaseClass) || /* @__PURE__ */ new WeakMap();
  factoryCache.set(BaseClass, cache);
  const key = factoryFn ?? BaseClass;
  if (cache.has(key)) {
    return cache.get(key);
  }
  const Factory = new Proxy(BaseClass, {
    construct(target, args, newTarget) {
      return Reflect.construct(target, args, newTarget);
    },
    apply(target, thisArg, args) {
      return factoryFn ? factoryFn.bind(thisArg)(...args) : Reflect.construct(target, args, target);
    }
  });
  cache.set(key, Factory);
  return Factory;
}
const createGenericType = (baseType) => {
  return createFactory(baseType, (...generics) => {
    return type.Type(baseType, generics);
  });
};

exports.createFactory = createFactory;
exports.createFactoryProxy = createFactoryProxy;
exports.createGenericType = createGenericType;