@tstdl/base 0.87.13 → 0.88.0-alpha1

package/reflection/registry.js

@@ -1,137 +1,117 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var registry_exports = {};
-__export(registry_exports, {
-  ReflectionRegistry: () => ReflectionRegistry,
-  reflectionRegistry: () => reflectionRegistry
-});
-module.exports = __toCommonJS(registry_exports);
-var import_factory_map = require("../utils/factory-map.js");
-var import_lazy_property = require("../utils/object/lazy-property.js");
-var import_reflection = require("../utils/reflection.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_decorator_data = require("./decorator-data.js");
-var import_reflection_data_map = require("./reflection-data-map.js");
-class ReflectionRegistry {
-  metadataMap;
-  finalizedTypesSet;
-  constructor() {
-    this.metadataMap = /* @__PURE__ */ new WeakMap();
-    this.finalizedTypesSet = /* @__PURE__ */ new WeakSet();
-  }
-  hasType(type) {
-    return this.metadataMap.has(type);
-  }
-  getMetadata(type) {
-    const metadata = this.metadataMap.get(type);
-    if ((0, import_type_guards.isDefined)(metadata) && !this.finalizedTypesSet.has(type)) {
-      metadata.properties = new Map(metadata.properties);
-      metadata.staticProperties = new Map(metadata.staticProperties);
-      metadata.methods = new Map(metadata.methods);
-      metadata.staticMethods = new Map(metadata.staticMethods);
-      this.finalizedTypesSet.add(type);
+import { FactoryMap } from '../utils/factory-map.js';
+import { lazyObject, lazyObjectValue } from '../utils/object/lazy-property.js';
+import { getDesignType, getParameterTypes, getReturnType } from '../utils/reflection.js';
+import { isDefined, isUndefined } from '../utils/type-guards.js';
+import { getDecoratorData } from './decorator-data.js';
+import { ReflectionDataMap } from './reflection-data-map.js';
+export class ReflectionRegistry {
+    metadataMap;
+    finalizedTypesSet;
+    constructor() {
+        this.metadataMap = new WeakMap();
+        this.finalizedTypesSet = new WeakSet();
     }
-    return metadata;
-  }
-  register(target, propertyKey, descriptorOrParameterIndex) {
-    const data = (0, import_decorator_data.getDecoratorData)(target, propertyKey, descriptorOrParameterIndex);
-    this.registerDecoratorData(data);
-    return data;
-  }
-  registerDecoratorData(data) {
-    const metadata = this.getOrInitializeMetadata(data.constructor);
-    if (data.type == "class") {
-      return metadata;
-    } else if (data.type == "property" || data.type == "accessor") {
-      const propertyMetadata = (data.static ? metadata.staticProperties : metadata.properties).get(data.propertyKey);
-      propertyMetadata.isAccessor = data.type == "accessor";
-      return propertyMetadata;
-    } else if (data.type == "method") {
-      return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
-    } else if (data.type == "method-parameter") {
-      return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
-    } else if (data.type == "constructor-parameter") {
-      if ((0, import_type_guards.isUndefined)(metadata.parameters)) {
-        throw new Error("Constructor parameters are not available. (missing decoration?)");
-      }
-      return metadata.parameters[data.index];
+    hasType(type) {
+        return this.metadataMap.has(type);
     }
-    throw new Error(`Unknown DecoratorData type ${data.type}`);
-  }
-  /**
-   * Unregister a type. Can be useful if you replace a class with an decorator.
-   * However, this should not be necessary since WeakRefs are used.
-   * @param type Type to unregister
-   */
-  unregister(type) {
-    this.metadataMap.delete(type);
-  }
-  getOrInitializeMetadata(type) {
-    if (this.finalizedTypesSet.has(type)) {
-      throw new Error("Reflection data was accessed before registration was done.");
+    getMetadata(type) {
+        const metadata = this.metadataMap.get(type);
+        if (isDefined(metadata) && !this.finalizedTypesSet.has(type)) {
+            metadata.properties = new Map(metadata.properties);
+            metadata.staticProperties = new Map(metadata.staticProperties);
+            metadata.methods = new Map(metadata.methods);
+            metadata.staticMethods = new Map(metadata.staticMethods);
+            this.finalizedTypesSet.add(type);
+        }
+        return metadata;
     }
-    if (!this.metadataMap.has(type)) {
-      const metadata = initializeType(type);
-      this.metadataMap.set(type, metadata);
-      return metadata;
+    register(target, propertyKey, descriptorOrParameterIndex) {
+        const data = getDecoratorData(target, propertyKey, descriptorOrParameterIndex);
+        this.registerDecoratorData(data);
+        return data;
     }
-    return this.metadataMap.get(type);
-  }
-}
-function initializeType(type) {
-  return (0, import_lazy_property.lazyObject)({
-    metadataType: "type",
-    constructor: (0, import_lazy_property.lazyObjectValue)(type),
-    parent: (0, import_lazy_property.lazyObjectValue)(Reflect.getPrototypeOf(type)),
-    parameters: {
-      initializer() {
-        const parametersTypes = (0, import_reflection.getParameterTypes)(type);
-        return parametersTypes?.map((parameterType, index) => ({ metadataType: "constructor-parameter", index, type: parameterType, data: new import_reflection_data_map.ReflectionDataMap() }));
-      }
-    },
-    properties: {
-      initializer: () => new import_factory_map.FactoryMap((key) => ({ metadataType: "property", key, type: (0, import_reflection.getDesignType)(type.prototype, key), isAccessor: false, data: new import_reflection_data_map.ReflectionDataMap() }))
-    },
-    staticProperties: {
-      initializer: () => new import_factory_map.FactoryMap((key) => ({ metadataType: "property", key, type: (0, import_reflection.getDesignType)(type, key), isAccessor: false, data: new import_reflection_data_map.ReflectionDataMap() }))
-    },
-    methods: {
-      initializer: () => new import_factory_map.FactoryMap((key) => {
-        const parameters = (0, import_reflection.getParameterTypes)(type.prototype, key);
-        const returnType = (0, import_reflection.getReturnType)(type.prototype, key);
-        if ((0, import_type_guards.isUndefined)(parameters)) {
-          throw new Error(`Could not get parameters for method ${key.toString()} of type ${type.name}`);
+    registerDecoratorData(data) {
+        const metadata = this.getOrInitializeMetadata(data.constructor);
+        if (data.type == 'class') {
+            return metadata;
+        }
+        else if ((data.type == 'property') || (data.type == 'accessor')) {
+            const propertyMetadata = (data.static ? metadata.staticProperties : metadata.properties).get(data.propertyKey);
+            propertyMetadata.isAccessor = data.type == 'accessor';
+            return propertyMetadata;
         }
-        return { metadataType: "method", parameters: parameters.map((parameter, index) => ({ metadataType: "method-parameter", index, type: parameter, data: new import_reflection_data_map.ReflectionDataMap() })), returnType, data: new import_reflection_data_map.ReflectionDataMap() };
-      })
-    },
-    staticMethods: {
-      initializer: () => new import_factory_map.FactoryMap((key) => {
-        const parameters = (0, import_reflection.getParameterTypes)(type, key);
-        const returnType = (0, import_reflection.getReturnType)(type, key);
-        if ((0, import_type_guards.isUndefined)(parameters)) {
-          throw new Error(`Could not get parameters for static method ${key.toString()} of type ${type.name}`);
+        else if (data.type == 'method') {
+            return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
         }
-        return { metadataType: "method", parameters: parameters.map((parameter, index) => ({ metadataType: "method-parameter", index, type: parameter, data: new import_reflection_data_map.ReflectionDataMap() })), returnType, data: new import_reflection_data_map.ReflectionDataMap() };
-      })
-    },
-    data: { initializer: () => new import_reflection_data_map.ReflectionDataMap() }
-  });
+        else if (data.type == 'method-parameter') {
+            return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
+        }
+        else if (data.type == 'constructor-parameter') { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+            if (isUndefined(metadata.parameters)) {
+                throw new Error('Constructor parameters are not available. (missing decoration?)');
+            }
+            return metadata.parameters[data.index];
+        }
+        throw new Error(`Unknown DecoratorData type ${data.type}`);
+    }
+    /**
+     * Unregister a type. Can be useful if you replace a class with an decorator.
+     * However, this should not be necessary since WeakRefs are used.
+     * @param type Type to unregister
+     */
+    unregister(type) {
+        this.metadataMap.delete(type);
+    }
+    getOrInitializeMetadata(type) {
+        if (this.finalizedTypesSet.has(type)) {
+            throw new Error('Reflection data was accessed before registration was done.');
+        }
+        if (!this.metadataMap.has(type)) {
+            const metadata = initializeType(type);
+            this.metadataMap.set(type, metadata);
+            return metadata;
+        }
+        return this.metadataMap.get(type);
+    }
+}
+function initializeType(type) {
+    return lazyObject({
+        metadataType: 'type',
+        constructor: lazyObjectValue(type),
+        parent: lazyObjectValue(Reflect.getPrototypeOf(type)),
+        parameters: {
+            initializer() {
+                const parametersTypes = getParameterTypes(type);
+                return parametersTypes?.map((parameterType, index) => ({ metadataType: 'constructor-parameter', index, type: parameterType, data: new ReflectionDataMap() }));
+            }
+        },
+        properties: {
+            initializer: () => new FactoryMap((key) => ({ metadataType: 'property', key, type: getDesignType(type.prototype, key), isAccessor: false, data: new ReflectionDataMap() }))
+        },
+        staticProperties: {
+            initializer: () => new FactoryMap((key) => ({ metadataType: 'property', key, type: getDesignType(type, key), isAccessor: false, data: new ReflectionDataMap() }))
+        },
+        methods: {
+            initializer: () => new FactoryMap((key) => {
+                const parameters = getParameterTypes(type.prototype, key);
+                const returnType = getReturnType(type.prototype, key);
+                if (isUndefined(parameters)) {
+                    throw new Error(`Could not get parameters for method ${key.toString()} of type ${type.name}`);
+                }
+                return { metadataType: 'method', parameters: parameters.map((parameter, index) => ({ metadataType: 'method-parameter', index, type: parameter, data: new ReflectionDataMap() })), returnType, data: new ReflectionDataMap() };
+            })
+        },
+        staticMethods: {
+            initializer: () => new FactoryMap((key) => {
+                const parameters = getParameterTypes(type, key);
+                const returnType = getReturnType(type, key);
+                if (isUndefined(parameters)) {
+                    throw new Error(`Could not get parameters for static method ${key.toString()} of type ${type.name}`);
+                }
+                return { metadataType: 'method', parameters: parameters.map((parameter, index) => ({ metadataType: 'method-parameter', index, type: parameter, data: new ReflectionDataMap() })), returnType, data: new ReflectionDataMap() };
+            })
+        },
+        data: { initializer: () => new ReflectionDataMap() }
+    });
 }
-const reflectionRegistry = new ReflectionRegistry();
+export const reflectionRegistry = new ReflectionRegistry();

package/reflection/types.js

@@ -1,16 +1 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+export {};

package/reflection/utils.js

@@ -1,139 +1,111 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  createAccessorDecorator: () => createAccessorDecorator,
-  createClassDecorator: () => createClassDecorator,
-  createConstructorParameterDecorator: () => createConstructorParameterDecorator,
-  createDecorator: () => createDecorator,
-  createMethodDecorator: () => createMethodDecorator,
-  createMethodParameterDecorator: () => createMethodParameterDecorator,
-  createParameterDecorator: () => createParameterDecorator,
-  createPropertyDecorator: () => createPropertyDecorator,
-  createPropertyOrAccessorDecorator: () => createPropertyOrAccessorDecorator,
-  getConstructor: () => getConstructor,
-  getTypeInfoString: () => getTypeInfoString,
-  printType: () => printType,
-  wrapDecorator: () => wrapDecorator,
-  wrapDecoratorFactory: () => wrapDecoratorFactory
-});
-module.exports = __toCommonJS(utils_exports);
-var import_array = require("../utils/array/array.js");
-var import_noop = require("../utils/noop.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_decorator_data = require("./decorator-data.js");
-var import_registry = require("./registry.js");
-function createDecorator(options, handler = import_noop.noop) {
-  function decoratorWrapper(...args) {
-    const data = (0, import_decorator_data.getDecoratorData)(...args);
-    const optionsType = data.type == "constructor-parameter" ? "constructorParameter" : data.type == "method-parameter" ? "methodParameter" : data.type;
-    const valid = options[optionsType] == true || optionsType == "methodParameter" && (options.methodParameter == true || options.parameter == true) || optionsType == "constructorParameter" && (options.constructorParameter == true || options.parameter == true);
-    (0, import_type_guards.assert)(valid, () => `Decorator cannot be used for ${data.type}.`);
-    const metadata = import_registry.reflectionRegistry.registerDecoratorData(data);
-    if ((0, import_type_guards.isDefined)(options.data)) {
-      metadata.data.setMany(options.data, options.mergeData);
+import { toArray } from '../utils/array/array.js';
+import { noop } from '../utils/noop.js';
+import { assert, isDefined, isFunction, isSymbol } from '../utils/type-guards.js';
+import { getDecoratorData } from './decorator-data.js';
+import { reflectionRegistry } from './registry.js';
+// eslint-disable-next-line max-lines-per-function
+export function createDecorator(options, handler = noop) {
+    // eslint-disable-next-line max-statements, max-lines-per-function
+    function decoratorWrapper(...args) {
+        const data = getDecoratorData(...args);
+        const optionsType = (data.type == 'constructor-parameter') ? 'constructorParameter'
+            : (data.type == 'method-parameter') ? 'methodParameter'
+                : data.type;
+        const valid = (options[optionsType] == true)
+            || (optionsType == 'methodParameter' && ((options.methodParameter == true) || (options.parameter == true)))
+            || (optionsType == 'constructorParameter' && ((options.constructorParameter == true) || (options.parameter == true)));
+        assert(valid, () => `Decorator cannot be used for ${data.type}.`);
+        const metadata = reflectionRegistry.registerDecoratorData(data);
+        if (isDefined(options.data)) {
+            metadata.data.setMany(options.data, options.mergeData);
+        }
+        const result = handler(data, metadata, args);
+        if (isDefined(options.include)) {
+            for (const include of toArray(options.include)) {
+                include(...args); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+            }
+        }
+        return result;
     }
-    const result = handler(data, metadata, args);
-    if ((0, import_type_guards.isDefined)(options.include)) {
-      for (const include of (0, import_array.toArray)(options.include)) {
-        include(...args);
-      }
-    }
-    return result;
-  }
-  return decoratorWrapper;
+    return decoratorWrapper;
 }
-function createClassDecorator(options = {}) {
-  return createDecorator({ ...options, class: true }, options.handler);
+export function createClassDecorator(options = {}) {
+    return createDecorator({ ...options, class: true }, options.handler);
 }
-function createPropertyDecorator(options = {}) {
-  return createDecorator({ ...options, property: true }, options.handler);
+export function createPropertyDecorator(options = {}) {
+    return createDecorator({ ...options, property: true }, options.handler);
 }
-function createAccessorDecorator(options = {}) {
-  return createDecorator({ ...options, accessor: true }, options.handler);
+export function createAccessorDecorator(options = {}) {
+    return createDecorator({ ...options, accessor: true }, options.handler);
 }
-function createPropertyOrAccessorDecorator(options = {}) {
-  return createDecorator({ ...options, property: true, accessor: true }, options.handler);
+export function createPropertyOrAccessorDecorator(options = {}) {
+    return createDecorator({ ...options, property: true, accessor: true }, options.handler);
 }
-function createMethodDecorator(options = {}) {
-  return createDecorator({ ...options, method: true }, options.handler);
+export function createMethodDecorator(options = {}) {
+    return createDecorator({ ...options, method: true }, options.handler);
 }
-function createMethodParameterDecorator(options = {}) {
-  return createDecorator({ ...options, methodParameter: true }, options.handler);
+export function createMethodParameterDecorator(options = {}) {
+    return createDecorator({ ...options, methodParameter: true }, options.handler);
 }
-function createConstructorParameterDecorator(options = {}) {
-  return createDecorator({ ...options, constructorParameter: true }, options.handler);
+export function createConstructorParameterDecorator(options = {}) {
+    return createDecorator({ ...options, constructorParameter: true }, options.handler);
 }
-function createParameterDecorator(options = {}) {
-  return createDecorator({ ...options, parameter: true }, options.handler);
+export function createParameterDecorator(options = {}) {
+    return createDecorator({ ...options, parameter: true }, options.handler);
 }
-function wrapDecoratorFactory(decoratorFactory, options) {
-  function wrappedDecoratorFactory(...args) {
-    const decorator = decoratorFactory(...args);
-    return wrapDecorator(decorator, options);
-  }
-  return wrappedDecoratorFactory;
+export function wrapDecoratorFactory(decoratorFactory, options) {
+    function wrappedDecoratorFactory(...args) {
+        const decorator = decoratorFactory(...args);
+        return wrapDecorator(decorator, options);
+    }
+    return wrappedDecoratorFactory;
 }
-function wrapDecorator(decorator, options) {
-  const wrappedDecorator = createDecorator({
-    class: true,
-    property: true,
-    method: true,
-    parameter: true,
-    methodParameter: true,
-    constructorParameter: true,
-    ...options
-  }, (data, metadata, args) => {
-    options?.handler?.(data, metadata, args);
-    return decorator(...args);
-  });
-  return wrappedDecorator;
+export function wrapDecorator(decorator, options) {
+    const wrappedDecorator = createDecorator({
+        class: true,
+        property: true,
+        method: true,
+        parameter: true,
+        methodParameter: true,
+        constructorParameter: true,
+        ...options
+    }, (data, metadata, args) => {
+        options?.handler?.(data, metadata, args);
+        return decorator(...args); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    });
+    return wrappedDecorator;
 }
-function getConstructor(constructorOrTarget) {
-  return (0, import_type_guards.isFunction)(constructorOrTarget) ? constructorOrTarget : constructorOrTarget.constructor;
+export function getConstructor(constructorOrTarget) {
+    return isFunction(constructorOrTarget)
+        ? constructorOrTarget
+        : constructorOrTarget.constructor;
 }
-function getTypeInfoString(type) {
-  const lines = [];
-  const metadata = import_registry.reflectionRegistry.getMetadata(type);
-  const constructorParameters = metadata?.parameters?.map((parameter) => parameter.type?.name ?? "<unknown>").join(", ") ?? "?";
-  lines.push(`${type.name}(${constructorParameters})`);
-  for (const [key, propertyMetadata] of metadata?.staticProperties ?? []) {
-    const propertyKey = (0, import_type_guards.isSymbol)(key) ? `[${key.toString()}]` : key;
-    lines.push(`  static ${propertyKey}: ${propertyMetadata.type.name}`);
-  }
-  for (const [key, methodMetadata] of metadata?.staticMethods ?? []) {
-    const propertyKey = (0, import_type_guards.isSymbol)(key) ? `[${key.toString()}]` : key;
-    const parameters = methodMetadata.parameters.map((parameter) => parameter.type.name).join(", ");
-    lines.push(`  static ${propertyKey}(${parameters}): ${methodMetadata.returnType?.name ?? "void"}`);
-  }
-  for (const [key, propertyMetadata] of metadata?.properties ?? []) {
-    const propertyKey = (0, import_type_guards.isSymbol)(key) ? `[${key.toString()}]` : key;
-    lines.push(`  ${propertyKey}: ${propertyMetadata.type.name}`);
-  }
-  for (const [key, methodMetadata] of metadata?.methods ?? []) {
-    const propertyKey = (0, import_type_guards.isSymbol)(key) ? `[${key.toString()}]` : key;
-    const parameters = methodMetadata.parameters.map((parameter) => parameter.type.name).join(", ");
-    lines.push(`  ${propertyKey}(${parameters}): ${methodMetadata.returnType?.name ?? "void"}`);
-  }
-  return lines.join("\n");
+export function getTypeInfoString(type) {
+    const lines = [];
+    const metadata = reflectionRegistry.getMetadata(type);
+    const constructorParameters = metadata?.parameters?.map((parameter) => parameter.type?.name ?? '<unknown>').join(', ') ?? '?';
+    lines.push(`${type.name}(${constructorParameters})`);
+    for (const [key, propertyMetadata] of (metadata?.staticProperties ?? [])) {
+        const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
+        lines.push(`  static ${propertyKey}: ${propertyMetadata.type.name}`);
+    }
+    for (const [key, methodMetadata] of (metadata?.staticMethods ?? [])) {
+        const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
+        const parameters = methodMetadata.parameters.map((parameter) => parameter.type.name).join(', ');
+        lines.push(`  static ${propertyKey}(${parameters}): ${methodMetadata.returnType?.name ?? 'void'}`);
+    }
+    for (const [key, propertyMetadata] of (metadata?.properties ?? [])) {
+        const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
+        lines.push(`  ${propertyKey}: ${propertyMetadata.type.name}`);
+    }
+    for (const [key, methodMetadata] of (metadata?.methods ?? [])) {
+        const propertyKey = isSymbol(key) ? `[${key.toString()}]` : key;
+        const parameters = methodMetadata.parameters.map((parameter) => parameter.type.name).join(', ');
+        lines.push(`  ${propertyKey}(${parameters}): ${methodMetadata.returnType?.name ?? 'void'}`);
+    }
+    return lines.join('\n');
 }
-function printType(type) {
-  const text = getTypeInfoString(type);
-  console.log(text);
+export function printType(type) {
+    const text = getTypeInfoString(type);
+    console.log(text); // eslint-disable-line no-console
 }

package/require.js

@@ -1,29 +1,6 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var require_exports = {};
-__export(require_exports, {
-  dynamicRequire: () => dynamicRequire
-});
-module.exports = __toCommonJS(require_exports);
 function getRequire() {
-  return require;
+    return require;
 }
-function dynamicRequire(id) {
-  return getRequire()(id);
+export function dynamicRequire(id) {
+    return getRequire()(id);
 }

package/rpc/endpoints/message-port.rpc-endpoint.js

@@ -1,51 +1,32 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var message_port_rpc_endpoint_exports = {};
-__export(message_port_rpc_endpoint_exports, {
-  MessagePortRpcEndpoint: () => MessagePortRpcEndpoint
-});
-module.exports = __toCommonJS(message_port_rpc_endpoint_exports);
-var import_environment = require("../../environment.js");
-var import_rxjs = require("rxjs");
-var import_rpc_endpoint = require("../rpc-endpoint.js");
-class MessagePortRpcEndpoint extends import_rpc_endpoint.RpcEndpoint {
-  source;
-  _postMessage;
-  supportsTransfers = true;
-  message$;
-  constructor(source) {
-    super();
-    this.source = import_environment.isBrowser && (typeof SharedWorker == "function" && source instanceof SharedWorker) ? source.port : source;
-    this.message$ = (0, import_rxjs.fromEvent)(this.source, "message").pipe((0, import_rxjs.map)((message) => message instanceof MessageEvent ? { ...message.data, metadata: { source: message } } : message));
-    this._postMessage = import_environment.isBrowser ? (data, transfer) => this.source.postMessage(data, { transfer }) : (data, transfer) => this.source.postMessage(data, transfer);
-  }
-  start() {
-    if (this.source instanceof MessagePort) {
-      this.source.start();
+import { isBrowser } from '../../environment.js';
+import { fromEvent, map } from 'rxjs';
+import { RpcEndpoint } from '../rpc-endpoint.js';
+export class MessagePortRpcEndpoint extends RpcEndpoint {
+    source;
+    _postMessage;
+    supportsTransfers = true;
+    message$;
+    constructor(source) {
+        super();
+        this.source = (isBrowser && ((typeof SharedWorker == 'function') && (source instanceof SharedWorker)))
+            ? source.port
+            : source;
+        this.message$ = fromEvent(this.source, 'message').pipe(map((message) => ((message instanceof MessageEvent) ? { ...message.data, metadata: { source: message } } : message)));
+        this._postMessage = isBrowser
+            ? (data, transfer) => this.source.postMessage(data, { transfer })
+            : (data, transfer) => this.source.postMessage(data, transfer);
     }
-  }
-  close() {
-    if (this.source instanceof MessagePort) {
-      this.source.close();
+    start() {
+        if (this.source instanceof MessagePort) {
+            this.source.start();
+        }
+    }
+    close() {
+        if (this.source instanceof MessagePort) {
+            this.source.close();
+        }
+    }
+    postMessage(data, transfer) {
+        this._postMessage(data, transfer);
     }
-  }
-  postMessage(data, transfer) {
-    this._postMessage(data, transfer);
-  }
 }