@tstdl/base 0.87.13 → 0.88.0-alpha1

package/image-service/imgproxy/imgproxy-image-service.js

@@ -1,138 +1,101 @@
-"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var imgproxy_image_service_exports = {};
-__export(imgproxy_image_service_exports, {
-  IMGPROXY_IMAGE_SERVICE_CONFIG: () => IMGPROXY_IMAGE_SERVICE_CONFIG,
-  ImgproxyImageService: () => ImgproxyImageService,
-  configureImgproxyImageService: () => configureImgproxyImageService
-});
-module.exports = __toCommonJS(imgproxy_image_service_exports);
-var import_injector = require("../../injector/index.js");
-var import_injector2 = require("../../injector/injector.js");
-var import_base64 = require("../../utils/base64.js");
-var import_binary = require("../../utils/binary.js");
-var import_cryptography = require("../../utils/cryptography.js");
-var import_encoding = require("../../utils/encoding.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var import_image_service = require("../image-service.js");
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-var __param = function(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-};
-const IMGPROXY_IMAGE_SERVICE_CONFIG = (0, import_injector.injectionToken)("ImgproxyImageServiceConfig");
-let ImgproxyImageService = class ImgproxyImageService2 extends import_image_service.ImageService {
-  #keyBytes;
-  #saltBytes;
-  #signatureSize;
-  endpoint;
-  constructor(endpoint, key, salt, signatureSize) {
-    super();
-    this.endpoint = endpoint;
-    this.#signatureSize = signatureSize;
-    this.#keyBytes = (0, import_encoding.decodeHex)(key);
-    this.#saltBytes = (0, import_encoding.decodeHex)(salt);
-  }
-  async getUrl(resourceUri, options = {}) {
-    const encodedResourceUri = (0, import_base64.encodeBase64Url)((0, import_encoding.encodeUtf8)(resourceUri));
-    const processingOptions = [];
-    const { resizeMode, width, height } = options;
-    if ((0, import_type_guards.isDefined)(width) || (0, import_type_guards.isDefined)(height) || (0, import_type_guards.isDefined)(resizeMode)) {
-      processingOptions.push(`rs:${resizeMode ?? ""}:${width ?? ""}:${height ?? ""}`);
-    }
-    if ((0, import_type_guards.isDefined)(options.origin)) {
-      processingOptions.push(`gravity:${convertOrigin(options.origin)}`);
-    }
-    if ((0, import_type_guards.isDefined)(options.quality)) {
-      processingOptions.push(`q:${options.quality}`);
+import { InjectArg, Singleton, injectionToken, resolveArgumentType } from '../../injector/index.js';
+import { Injector } from '../../injector/injector.js';
+import { encodeBase64Url } from '../../utils/base64.js';
+import { concatArrayBufferViews } from '../../utils/binary.js';
+import { importHmacKey, sign } from '../../utils/cryptography.js';
+import { decodeHex, encodeUtf8 } from '../../utils/encoding.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { ImageService } from '../image-service.js';
+export const IMGPROXY_IMAGE_SERVICE_CONFIG = injectionToken('ImgproxyImageServiceConfig');
+let ImgproxyImageService = class ImgproxyImageService extends ImageService {
+    #keyBytes;
+    #saltBytes;
+    #signatureSize;
+    endpoint;
+    constructor(endpoint, key, salt, signatureSize) {
+        super();
+        this.endpoint = endpoint;
+        this.#signatureSize = signatureSize;
+        this.#keyBytes = decodeHex(key);
+        this.#saltBytes = decodeHex(salt);
     }
-    if ((0, import_type_guards.isDefined)(options.cacheBuster)) {
-      processingOptions.push(`cb:${options.cacheBuster}`);
+    async getUrl(resourceUri, options = {}) {
+        const encodedResourceUri = encodeBase64Url(encodeUtf8(resourceUri));
+        const processingOptions = [];
+        const { resizeMode, width, height } = options;
+        if (isDefined(width) || isDefined(height) || isDefined(resizeMode)) {
+            processingOptions.push(`rs:${resizeMode ?? ''}:${width ?? ''}:${height ?? ''}`);
+        }
+        if (isDefined(options.origin)) {
+            processingOptions.push(`gravity:${convertOrigin(options.origin)}`);
+        }
+        if (isDefined(options.quality)) {
+            processingOptions.push(`q:${options.quality}`);
+        }
+        if (isDefined(options.cacheBuster)) {
+            processingOptions.push(`cb:${options.cacheBuster}`);
+        }
+        if (isDefined(options.format)) {
+            processingOptions.push(`f:${options.format}`);
+        }
+        const processingOptionsString = processingOptions.join('/');
+        const path = `/${[processingOptionsString, encodedResourceUri].join('/')}`;
+        const signature = await signString(this.#keyBytes, this.#saltBytes, path, this.#signatureSize);
+        return `${this.endpoint}/${signature}${path}`;
     }
-    if ((0, import_type_guards.isDefined)(options.format)) {
-      processingOptions.push(`f:${options.format}`);
-    }
-    const processingOptionsString = processingOptions.join("/");
-    const path = `/${[processingOptionsString, encodedResourceUri].join("/")}`;
-    const signature = await signString(this.#keyBytes, this.#saltBytes, path, this.#signatureSize);
-    return `${this.endpoint}/${signature}${path}`;
-  }
 };
 ImgproxyImageService = __decorate([
-  (0, import_injector.Singleton)({
-    defaultArgumentProvider: (context) => context.resolve(IMGPROXY_IMAGE_SERVICE_CONFIG)
-  }),
-  __param(0, (0, import_injector.InjectArg)("endpoint")),
-  __param(1, (0, import_injector.InjectArg)("key")),
-  __param(2, (0, import_injector.InjectArg)("salt")),
-  __param(3, (0, import_injector.InjectArg)("signatureSize")),
-  __metadata("design:paramtypes", [String, String, String, Number])
+    Singleton({
+        defaultArgumentProvider: (context) => context.resolve(IMGPROXY_IMAGE_SERVICE_CONFIG)
+    }),
+    __param(0, InjectArg('endpoint')),
+    __param(1, InjectArg('key')),
+    __param(2, InjectArg('salt')),
+    __param(3, InjectArg('signatureSize')),
+    __metadata("design:paramtypes", [String, String, String, Number])
 ], ImgproxyImageService);
+export { ImgproxyImageService };
 async function signString(keyBytes, saltBytes, target, size = 32) {
-  const hmacKey = await (0, import_cryptography.importHmacKey)("SHA-256", keyBytes, false);
-  const targetBytes = (0, import_binary.concatArrayBufferViews)([saltBytes, (0, import_encoding.encodeUtf8)(target)]);
-  const base64Signature = await (0, import_cryptography.sign)("HMAC", hmacKey, targetBytes).toBuffer();
-  return (0, import_base64.encodeBase64Url)(base64Signature.slice(0, size));
+    const hmacKey = await importHmacKey('SHA-256', keyBytes, false);
+    const targetBytes = concatArrayBufferViews([saltBytes, encodeUtf8(target)]);
+    const base64Signature = await sign('HMAC', hmacKey, targetBytes).toBuffer();
+    return encodeBase64Url(base64Signature.slice(0, size));
 }
 function convertOrigin(origin) {
-  switch (origin) {
-    case "center":
-      return "ce";
-    case "smart":
-      return "sm";
-    case "top":
-      return "no";
-    case "left":
-      return "we";
-    case "right":
-      return "ea";
-    case "bottom":
-      return "so";
-    case "topleft":
-      return "nowe";
-    case "topright":
-      return "noea";
-    case "bottomleft":
-      return "sowe";
-    case "bottomright":
-      return "soea";
-    default:
-      throw new Error();
-  }
+    switch (origin) {
+        case 'center': return 'ce';
+        case 'smart': return 'sm';
+        case 'top': return 'no';
+        case 'left': return 'we';
+        case 'right': return 'ea';
+        case 'bottom': return 'so';
+        case 'topleft': return 'nowe';
+        case 'topright': return 'noea';
+        case 'bottomleft': return 'sowe';
+        case 'bottomright': return 'soea';
+        default: throw new Error();
+    }
 }
-function configureImgproxyImageService(defaultConfig, register = true) {
-  import_injector2.Injector.register(IMGPROXY_IMAGE_SERVICE_CONFIG, { useValue: defaultConfig });
-  if (register) {
-    import_injector2.Injector.registerSingleton(import_image_service.ImageService, { useToken: ImgproxyImageService });
-  }
+/**
+ * configure imgproxy image service module
+ * @param defaultConfig default configuration
+ * @param register whether to register for {@link ImageService}
+ */
+export function configureImgproxyImageService(defaultConfig, register = true) {
+    Injector.register(IMGPROXY_IMAGE_SERVICE_CONFIG, { useValue: defaultConfig });
+    if (register) {
+        Injector.registerSingleton(ImageService, { useToken: ImgproxyImageService });
+    }
 }

package/image-service/imgproxy/index.js

@@ -1,18 +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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var imgproxy_exports = {};
-module.exports = __toCommonJS(imgproxy_exports);
-__reExport(imgproxy_exports, require("./imgproxy-image-service.js"), module.exports);
+export * from './imgproxy-image-service.js';

package/image-service/index.js

@@ -1,18 +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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var image_service_exports = {};
-module.exports = __toCommonJS(image_service_exports);
-__reExport(image_service_exports, require("./image-service.js"), module.exports);
+export * from './image-service.js';

package/import.js

@@ -1,26 +1,3 @@
-"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 import_exports = {};
-__export(import_exports, {
-  dynamicImport: () => dynamicImport
-});
-module.exports = __toCommonJS(import_exports);
-async function dynamicImport(id) {
-  return import(id);
+export async function dynamicImport(id) {
+    return import(id);
 }

package/index.js

@@ -1,18 +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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var dist_exports = {};
-module.exports = __toCommonJS(dist_exports);
-__reExport(dist_exports, require("./core.js"), module.exports);
+export * from './core.js';

package/injector/decorators.js

@@ -1,127 +1,149 @@
-"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 decorators_exports = {};
-__export(decorators_exports, {
-  ForwardArg: () => ForwardArg,
-  ForwardRef: () => ForwardRef,
-  Inject: () => Inject,
-  InjectAll: () => InjectAll,
-  InjectArg: () => InjectArg,
-  Injectable: () => Injectable,
-  Optional: () => Optional,
-  ReplaceClass: () => ReplaceClass,
-  ResolveArg: () => ResolveArg,
-  ResolveArgProvider: () => ResolveArgProvider,
-  Scoped: () => Scoped,
-  Singleton: () => Singleton
-});
-module.exports = __toCommonJS(decorators_exports);
-var import_reflection = require("../reflection/index.js");
-var import_array = require("../utils/array/array.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_injector = require("./injector.js");
-var import_symbols = require("./symbols.js");
-function ReplaceClass(constructor) {
-  return (0, import_reflection.createClassDecorator)({ handler: () => constructor });
+/* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/naming-convention */
+import { createClassDecorator, createDecorator } from '../reflection/index.js';
+import { toArray } from '../utils/array/array.js';
+import { isDefined, isFunction } from '../utils/type-guards.js';
+import { Injector } from './injector.js';
+import { injectMetadataSymbol, injectableMetadataSymbol } from './symbols.js';
+/**
+ * Helper decorator to replace a class definition with an other
+ * can be used for example to type external classes with the {@link Resolvable} interface
+ * @param constructor class to replace with
+ */
+export function ReplaceClass(constructor) {
+    return createClassDecorator({ handler: () => constructor });
 }
-function Injectable(options = {}) {
-  return (0, import_reflection.createClassDecorator)({
-    data: { [import_symbols.injectableMetadataSymbol]: {} },
-    mergeData: true,
-    handler: (data) => {
-      const { alias: aliases, provider, ...registrationOptions } = options;
-      const token = data.constructor;
-      const targetProvider = provider ?? { useClass: token };
-      import_injector.Injector.register(token, targetProvider, registrationOptions);
-      if ((0, import_type_guards.isDefined)(aliases)) {
-        for (const alias of (0, import_array.toArray)(aliases)) {
-          import_injector.Injector.register(alias, { useToken: token }, registrationOptions);
+/**
+ * Globally registers the class for injection
+ * @param options registration options
+ */
+export function Injectable(options = {}) {
+    return createClassDecorator({
+        data: { [injectableMetadataSymbol]: {} },
+        mergeData: true,
+        handler: (data) => {
+            const { alias: aliases, provider, ...registrationOptions } = options;
+            const token = data.constructor;
+            const targetProvider = provider ?? { useClass: token };
+            Injector.register(token, targetProvider, registrationOptions);
+            if (isDefined(aliases)) {
+                for (const alias of toArray(aliases)) {
+                    Injector.register(alias, { useToken: token }, registrationOptions);
+                }
+            }
         }
-      }
-    }
-  });
+    });
 }
-function Singleton(options = {}) {
-  return Injectable({ ...options, lifecycle: "singleton" });
+/**
+ * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export function Singleton(options = {}) {
+    return Injectable({ ...options, lifecycle: 'singleton' });
 }
-function Scoped(lifecycle, options = {}) {
-  return Injectable({ ...options, lifecycle });
+/**
+ * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export function Scoped(lifecycle, options = {}) {
+    return Injectable({ ...options, lifecycle });
 }
-function Inject(token, argument, mapperOrKey) {
-  const injectMetadata = {};
-  if ((0, import_type_guards.isDefined)(token)) {
-    injectMetadata.injectToken = token;
-  }
-  if ((0, import_type_guards.isDefined)(argument)) {
-    injectMetadata.resolveArgumentProvider = () => argument;
-  }
-  if ((0, import_type_guards.isDefined)(mapperOrKey)) {
-    injectMetadata.mapper = (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (value) => value[mapperOrKey];
-  }
-  return createInjectDecorator(injectMetadata);
+/**
+ * sets the token used to resolve the parameter
+ * @param token token used for resolving
+ * @param argument resolve argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export function Inject(token, argument, mapperOrKey) {
+    const injectMetadata = {};
+    if (isDefined(token)) {
+        injectMetadata.injectToken = token;
+    }
+    if (isDefined(argument)) {
+        injectMetadata.resolveArgumentProvider = () => argument;
+    }
+    if (isDefined(mapperOrKey)) {
+        injectMetadata.mapper = isFunction(mapperOrKey) ? mapperOrKey : ((value) => value[mapperOrKey]);
+    }
+    return createInjectDecorator(injectMetadata);
 }
-function InjectAll(token, argument, mapperOrKey) {
-  const injectMetadata = { resolveAll: true };
-  if ((0, import_type_guards.isDefined)(token)) {
-    injectMetadata.injectToken = token;
-  }
-  if ((0, import_type_guards.isDefined)(argument)) {
-    injectMetadata.resolveArgumentProvider = () => argument;
-  }
-  if ((0, import_type_guards.isDefined)(mapperOrKey)) {
-    injectMetadata.mapper = (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (value) => value[mapperOrKey];
-  }
-  return createInjectDecorator(injectMetadata);
+/**
+ * sets the token used to resolve the parameter. Resolves all providers
+ * @param token token used for resolving
+ * @param argument resolve argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export function InjectAll(token, argument, mapperOrKey) {
+    const injectMetadata = { resolveAll: true };
+    if (isDefined(token)) {
+        injectMetadata.injectToken = token;
+    }
+    if (isDefined(argument)) {
+        injectMetadata.resolveArgumentProvider = () => argument;
+    }
+    if (isDefined(mapperOrKey)) {
+        injectMetadata.mapper = isFunction(mapperOrKey) ? mapperOrKey : ((value) => value[mapperOrKey]);
+    }
+    return createInjectDecorator(injectMetadata);
 }
-function ResolveArg(argument) {
-  return ResolveArgProvider(() => argument);
+/**
+ * sets the argument used for resolving the parameter
+ * @param argument
+ */
+export function ResolveArg(argument) {
+    return ResolveArgProvider(() => argument);
 }
-function ResolveArgProvider(argumentProvider) {
-  return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
+/**
+ * sets the argument provider used for resolving the parameter
+ * @param argumentProvider
+ */
+export function ResolveArgProvider(argumentProvider) {
+    return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
 }
-function InjectArg(mapperOrKey) {
-  return createInjectDecorator({
-    injectArgumentMapper: (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (0, import_type_guards.isDefined)(mapperOrKey) ? (value) => value[mapperOrKey] : (value) => value
-  });
+/**
+ * injects the argument used for resolving the class instead of resolving the parameter
+ * @param argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export function InjectArg(mapperOrKey) {
+    return createInjectDecorator({
+        injectArgumentMapper: isFunction(mapperOrKey)
+            ? mapperOrKey
+            : isDefined(mapperOrKey)
+                ? ((value) => value[mapperOrKey])
+                : ((value) => value)
+    });
 }
-function ForwardArg(mapper = (value) => value) {
-  return createInjectDecorator({ forwardArgumentMapper: mapper });
+export function ForwardArg(mapper = (value) => value) {
+    return createInjectDecorator({ forwardArgumentMapper: mapper });
 }
-function Optional() {
-  return createInjectDecorator({ optional: true });
+/**
+ * marks the argument as optional
+ * @param argument
+ */
+export function Optional() {
+    return createInjectDecorator({ optional: true });
 }
-function ForwardRef(token, argument, options) {
-  const injectMetadata = {
-    forwardRef: token ?? true,
-    forwardRefTypeHint: options?.forwardRefTypeHint
-  };
-  if ((0, import_type_guards.isDefined)(argument)) {
-    injectMetadata.resolveArgumentProvider = () => argument;
-  }
-  return createInjectDecorator(injectMetadata);
+/**
+ * resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
+ * @param token token to resolve
+ * @param argument resolve argument
+ */
+export function ForwardRef(token, argument, options) {
+    const injectMetadata = {
+        forwardRef: token ?? true,
+        forwardRefTypeHint: options?.forwardRefTypeHint
+    };
+    if (isDefined(argument)) {
+        injectMetadata.resolveArgumentProvider = () => argument;
+    }
+    return createInjectDecorator(injectMetadata);
 }
 function createInjectDecorator(metadata) {
-  return (0, import_reflection.createDecorator)({
-    property: true,
-    accessor: true,
-    constructorParameter: true,
-    data: { [import_symbols.injectMetadataSymbol]: metadata },
-    mergeData: true
-  });
+    return createDecorator({
+        property: true,
+        accessor: true,
+        constructorParameter: true,
+        data: { [injectMetadataSymbol]: metadata },
+        mergeData: true
+    });
 }

package/injector/index.js

@@ -1,28 +1,11 @@
-"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var injector_exports = {};
-module.exports = __toCommonJS(injector_exports);
-__reExport(injector_exports, require("./decorators.js"), module.exports);
-__reExport(injector_exports, require("./inject.js"), module.exports);
-__reExport(injector_exports, require("./injector.js"), module.exports);
-__reExport(injector_exports, require("./interfaces.js"), module.exports);
-__reExport(injector_exports, require("./provider.js"), module.exports);
-__reExport(injector_exports, require("./resolve-chain.js"), module.exports);
-__reExport(injector_exports, require("./resolve.error.js"), module.exports);
-__reExport(injector_exports, require("./symbols.js"), module.exports);
-__reExport(injector_exports, require("./token.js"), module.exports);
-__reExport(injector_exports, require("./type-info.js"), module.exports);
-__reExport(injector_exports, require("./types.js"), module.exports);
+export * from './decorators.js';
+export * from './inject.js';
+export * from './injector.js';
+export * from './interfaces.js';
+export * from './provider.js';
+export * from './resolve-chain.js';
+export * from './resolve.error.js';
+export * from './symbols.js';
+export * from './token.js';
+export * from './type-info.js';
+export * from './types.js';