@tstdl/base 0.86.0-beta2 → 0.86.0-beta4

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

@@ -1,99 +1,138 @@
-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;
+"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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+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 __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+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;
 };
-import { container, injectArg, injectionToken, singleton } from '../../container/index.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');
-export let ImgproxyImageService = class ImgproxyImageService extends ImageService {
-    endpoint;
-    keyBytes;
-    saltBytes;
-    signatureSize;
-    constructor(endpoint, key, salt, signatureSize) {
-        super();
-        this.endpoint = endpoint;
-        this.signatureSize = signatureSize;
-        this.keyBytes = decodeHex(key);
-        this.saltBytes = decodeHex(salt);
+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}`);
     }
-    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.cacheBuster)) {
+      processingOptions.push(`cb:${options.cacheBuster}`);
     }
+    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([
-    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])
+  (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])
 ], ImgproxyImageService);
 async function signString(keyBytes, saltBytes, target, size = 32) {
-    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));
+  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));
 }
 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();
+  }
 }
-/**
- * configure imgproxy image service module
- * @param defaultConfig default configuration
- * @param register whether to register for {@link ImageService}
- */
-export function configureImgproxyImageService(defaultConfig, register = true) {
-    container.register(IMGPROXY_IMAGE_SERVICE_CONFIG, { useValue: defaultConfig });
-    if (register) {
-        container.registerSingleton(ImageService, { useToken: ImgproxyImageService });
-    }
+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 });
+  }
 }

package/image-service/imgproxy/index.js

@@ -1 +1,18 @@
-export * from './imgproxy-image-service.js';
+"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);

package/image-service/index.js

@@ -1 +1,18 @@
-export * from './image-service.js';
+"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);

package/import.js

@@ -1,3 +1,26 @@
-export async function dynamicImport(id) {
-    return import(id);
+"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);
 }

package/index.js

@@ -1 +1,18 @@
-export * from './core.js';
+"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);

package/injector/decorators.d.ts

@@ -0,0 +1,81 @@
+import type { Decorator } from '../reflection/index.js';
+import type { Constructor, OneOrMany, Record, Simplify, TypedOmit } from '../types.js';
+import type { Provider } from './provider.js';
+import type { InjectionToken } from './token.js';
+import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
+export type InjectDecorator = Decorator<'accessor' | 'constructorParameter'>;
+export type InjectableOptions<T, A, C extends Record = Record> = RegistrationOptions<T, A, C> & {
+    /** aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
+    alias?: OneOrMany<InjectionToken>;
+    /** custom provider. Useful for example if initialization is required */
+    provider?: Provider<T, A, C>;
+};
+export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
+/**
+ * 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 declare function ReplaceClass<T>(constructor: Constructor<T>): ClassDecorator;
+/**
+ * Globally registers the class for injection
+ * @param options registration options
+ */
+export declare function Injectable<T = any, A = any, C extends Record = Record>(options?: InjectableOptions<T, A, C>): ClassDecorator;
+/**
+ * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function Singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+/**
+ * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function Scoped<T = any, A = any>(lifecycle: 'resolution' | 'injector', options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+/**
+ * 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 declare function Inject<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * 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 declare function InjectAll<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * sets the argument used for resolving the parameter
+ * @param argument
+ */
+export declare function ResolveArg<T>(argument: T): InjectDecorator;
+/**
+ * sets the argument provider used for resolving the parameter
+ * @param argumentProvider
+ */
+export declare function ResolveArgProvider<T>(argumentProvider: ArgumentProvider<T>): InjectDecorator;
+/**
+ * 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 declare function InjectArg<T>(mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * sets the argument used for resolving the decorated parameter to the the argument provided for parent resolve
+ * @param mapper map the argument (for example to select a property instead of forwarding the whole object)
+ */
+export declare function ForwardArg(): InjectDecorator;
+export declare function ForwardArg<T, U>(mapper: Mapper<T, U>): InjectDecorator;
+/**
+ * marks the argument as optional
+ * @param argument
+ */
+export declare function Optional(): InjectDecorator;
+/**
+ * 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 declare function ForwardRef<T extends object, A>(token: ForwardRefInjectionToken<T>, argument?: A): InjectDecorator;

package/injector/decorators.js

@@ -0,0 +1,126 @@
+"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 });
+}
+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);
+        }
+      }
+    }
+  });
+}
+function Singleton(options = {}) {
+  return Injectable({ ...options, lifecycle: "singleton" });
+}
+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);
+}
+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);
+}
+function ResolveArg(argument) {
+  return ResolveArgProvider(() => argument);
+}
+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
+  });
+}
+function ForwardArg(mapper = (value) => value) {
+  return createInjectDecorator({ forwardArgumentMapper: mapper });
+}
+function Optional() {
+  return createInjectDecorator({ optional: true });
+}
+function ForwardRef(token, argument) {
+  const injectMetadata = {
+    forwardRefToken: token
+  };
+  if ((0, import_type_guards.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
+  });
+}

package/{container/index.js → injector/index.d.ts}

@@ -1,10 +1,11 @@
-export * from './container.js';
 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';
-export * from './utils.js';

package/injector/index.js

@@ -0,0 +1,28 @@
+"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);

package/injector/inject.d.ts

@@ -0,0 +1,85 @@
+import { Injector } from './injector.js';
+import type { Resolvable, ResolveArgument } from './interfaces.js';
+import type { InjectionToken } from './token.js';
+import type { ResolveOptions } from './types.js';
+export type InjectOptions = ResolveOptions & {
+    /** if defined, resolve the ForwardRefToken using ForwardRef strategy instead resolving the token */
+    forwardRef?: boolean;
+};
+export type InjectArgumentOptions = {
+    optional?: boolean;
+};
+export type InjectionContext = {
+    injector: Injector;
+    argument: unknown;
+    inject<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T;
+    injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T[];
+    injectAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T>;
+    injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T[]>;
+};
+/**
+ * Resolves a token using the {@link Injector} of the current injection context
+ *
+ * @param token token to resolve
+ * @param argument argument to resolve token with
+ * @param options resolve options
+ */
+export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions & {
+    optional: true;
+}): T | undefined;
+export declare function inject<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T;
+/**
+ * Resolves a token using the {@link Injector} of the current injection context
+ *
+ * @param token token to resolve
+ * @param argument argument to resolve token with
+ * @param options resolve options
+ */
+export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: InjectOptions & {
+    optional: true;
+}): Promise<T | undefined>;
+export declare function injectAsync<T = unknown, A = unknown>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T>;
+/**
+ * Resolves a token using the {@link Injector} of the current injection context
+ *
+ * @param token token to resolve
+ * @param argument argument to resolve token with
+ * @param options resolve options
+ */
+export declare function injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T[];
+/**
+ * Resolves a token using the {@link Injector} of the current injection context
+ *
+ * @param token token to resolve
+ * @param argument argument to resolve token with
+ * @param options resolve options
+ */
+export declare function injectAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): Promise<T[]>;
+/**
+ * Injects the resolve argument from the current resolution
+ * @param _this can be used for type infer by simply passing `this`. Requires class to implement {@link Resolvable}.
+ * @returns
+ */
+export declare function injectArgument<T, R>(_this?: Resolvable<T>, options?: InjectArgumentOptions & {
+    optional: R;
+}): T | (R extends true ? undefined : never);
+export declare function getCurrentInjectionContext(required: true): InjectionContext;
+export declare function getCurrentInjectionContext(required?: boolean): InjectionContext | null;
+export declare function getCurrentInjector(required: true): Injector;
+export declare function getCurrentInjector(required?: boolean): Injector | null;
+export declare function setCurrentInjectionContext(context: InjectionContext | null): InjectionContext | null;
+/**
+ * Runs the given function in the context of the given {@link InjectionContext}.
+ *
+ * @param context the injection context which will satisfy calls to {@link inject} while `fn` is executing
+ * @param fn the closure to be run in the context of `injector`
+ * @returns the return value of the function, if any
+ */
+export declare function runInInjectionContext<ReturnT>(injectorOrContext: Injector | InjectionContext, fn: () => ReturnT): ReturnT;
+export declare function isInInjectionContext(): boolean;
+/**
+ * Asserts that the current stack frame is within an injection context and has access to {@link inject}.
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ */
+export declare function assertInInjectionContext(debugFn: Function): void;