@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/cjs/lib/ioc/ListModules.d.ts

@@ -0,0 +1,42 @@
+import { BuildResolverOptions } from './Resolvers.js';
+import { LifetimeType } from './Lifetime.js';
+/**
+ * The options when invoking listModules().
+ * @interface ListModulesOptions
+ */
+export interface ListModulesOptions {
+    cwd?: string;
+    glob?: (pattern: string, options: {
+        cwd: string;
+    }) => string[];
+}
+/**
+ * An object containing the module name and path (full path to module).
+ *
+ * @interface ModuleDescriptor
+ */
+export interface ModuleDescriptor {
+    name: string;
+    path: string;
+    opts: any;
+}
+/**
+ * A glob pattern with associated registration options.
+ */
+export type GlobWithOptions = [string] | [string, BuildResolverOptions<any> | LifetimeType];
+/**
+ * Returns a list of {name, path} pairs,
+ * where the name is the module name, and path is the actual
+ * full path to the module.
+ *
+ * @param  {String|Array<String>} globPatterns
+ * The glob pattern as a string or an array of strings.
+ *
+ * @param  {String} opts.cwd
+ * Current working directory, used for resolving filepaths.
+ * Defaults to `process.cwd()`.
+ *
+ * @return {[{name, path}]}
+ * An array of objects with the module names and paths.
+ */
+export declare function listModules(globPatterns: string | Array<string | GlobWithOptions>, opts?: ListModulesOptions): ModuleDescriptor[];

package/dist/cjs/lib/ioc/ListModules.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listModules = listModules;
+const Glob_1 = require("@lakutata/utils/Glob");
+const path = __importStar(require("path"));
+const Utils_js_1 = require("./Utils.js");
+/**
+ * Default glob: matches files only, follows symbolic links and matches the case, like the fast-glob lookup of 2.x
+ * (case sensitive on every platform)
+ * @param pattern
+ * @param options
+ */
+function defaultGlob(pattern, options) {
+    return (0, Glob_1.GlobSync)(pattern, { cwd: options.cwd, nodir: true, follow: true, nocase: false });
+}
+// Regex to extract the module name.
+const nameExpr = /(.*)\..*/i;
+/**
+ * Internal method for globbing a single pattern.
+ *
+ * @param  {String} globPattern
+ * The glob pattern.
+ *
+ * @param opts
+ * @param  {String} opts.cwd
+ * Current working directory, used for resolving filepaths.
+ * Defaults to `process.cwd()`.
+ *
+ * @return {[{name, path, opts}]}
+ * The module names and paths.
+ *
+ * @api private
+ */
+function _listModules(globPattern, opts) {
+    opts = { cwd: process.cwd(), glob: defaultGlob, ...opts };
+    let patternOpts = null;
+    if (Array.isArray(globPattern)) {
+        patternOpts = globPattern[1];
+        globPattern = globPattern[0];
+    }
+    // Replace Windows path separators with Posix path
+    globPattern = globPattern.replace(/\\/g, '/');
+    const result = opts.glob(globPattern, { cwd: opts.cwd });
+    const mapped = result.map((p) => ({
+        name: nameExpr.exec(path.basename(p))[1],
+        path: path.resolve(opts.cwd, p),
+        opts: patternOpts
+    }));
+    return mapped;
+}
+/**
+ * Returns a list of {name, path} pairs,
+ * where the name is the module name, and path is the actual
+ * full path to the module.
+ *
+ * @param  {String|Array<String>} globPatterns
+ * The glob pattern as a string or an array of strings.
+ *
+ * @param  {String} opts.cwd
+ * Current working directory, used for resolving filepaths.
+ * Defaults to `process.cwd()`.
+ *
+ * @return {[{name, path}]}
+ * An array of objects with the module names and paths.
+ */
+function listModules(globPatterns, opts) {
+    if (Array.isArray(globPatterns)) {
+        return (0, Utils_js_1.flatten)(globPatterns.map((p) => _listModules(p, opts)));
+    }
+    return _listModules(globPatterns, opts);
+}

package/dist/cjs/lib/ioc/LoadModuleNative.d.ts

@@ -0,0 +1 @@
+export function importModule(path: any): Promise<any>;

package/dist/cjs/lib/ioc/LoadModuleNative.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importModule = importModule;
+// This is kept in a separate .js file to prevent TypeScript re-writing the import() statement to a require() statement
+function importModule(path) {
+    return Promise.resolve(`${path}`).then(s => __importStar(require(s)));
+}
+// module.exports = {importModule}

package/dist/cjs/lib/ioc/LoadModules.d.ts

@@ -0,0 +1,49 @@
+import { IDependencyInjectionContainer } from './DependencyInjectionContainer.js';
+import { GlobWithOptions, ModuleDescriptor, listModules } from './ListModules.js';
+import { BuildResolverOptions } from './Resolvers.js';
+/**
+ * Metadata of the module as well as the loaded module itself.
+ * @interface LoadedModuleDescriptor
+ */
+export interface LoadedModuleDescriptor extends ModuleDescriptor {
+    value: unknown;
+}
+/**
+ * The options when invoking loadModules().
+ * @interface LoadModulesOptions
+ */
+export interface LoadModulesOptions<ESM extends boolean = false> {
+    cwd?: string;
+    formatName?: NameFormatter | BuiltInNameFormatters;
+    resolverOptions?: BuildResolverOptions<any>;
+    esModules?: ESM;
+}
+/**
+ * Name formatting options when using loadModules().
+ * @type BuiltInNameFormatters
+ */
+export type BuiltInNameFormatters = 'camelCase';
+/**
+ * Takes in the filename of the module being loaded as well as the module descriptor,
+ * and returns a string which is used to register the module in the container.
+ *
+ * `descriptor.name` is the same as `name`.
+ *
+ * @type {NameFormatter}
+ */
+export type NameFormatter = (name: string, descriptor: LoadedModuleDescriptor) => string;
+/**
+ * Dependencies for `loadModules`
+ */
+export interface LoadModulesDeps {
+    listModules: typeof listModules;
+    container: IDependencyInjectionContainer;
+    require(path: string): any | Promise<any>;
+}
+/**
+ * The list of loaded modules
+ */
+export interface LoadModulesResult {
+    loadedModules: Array<ModuleDescriptor>;
+}
+export declare function loadModules<ESM extends boolean = false>(dependencies: LoadModulesDeps, globPatterns: string | Array<string | GlobWithOptions>, opts?: LoadModulesOptions<ESM>): ESM extends true ? Promise<LoadModulesResult> : LoadModulesResult;

package/dist/cjs/lib/ioc/LoadModules.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModules = loadModules;
+const url_1 = require("url");
+const Lifetime_js_1 = require("./Lifetime.js");
+const Resolvers_js_1 = require("./Resolvers.js");
+const Utils_js_1 = require("./Utils.js");
+const CamelCase_1 = require("@lakutata/utils/CamelCase");
+const As_1 = require("@lakutata/utils/As");
+const nameFormatters = {
+    camelCase: (s) => (0, CamelCase_1.camelCase)(s)
+};
+/**
+ * Given an array of glob strings, will call `require`
+ * on them, and call their default exported function with the
+ * container as the first parameter.
+ * @param dependencies
+ * @param globPatterns
+ * @param opts
+ */
+function loadModules(dependencies, globPatterns, opts) {
+    opts ??= {};
+    const container = dependencies.container;
+    opts = optsWithDefaults(opts);
+    const modules = dependencies.listModules(globPatterns, opts);
+    if (opts.esModules) {
+        return loadEsModules(dependencies, container, modules, opts);
+    }
+    else {
+        const result = modules.map((m) => {
+            const loaded = dependencies.require(m.path);
+            return parseLoadedModule(loaded, m);
+        });
+        return registerModules(result, container, modules, opts);
+    }
+}
+/**
+ * Loads the modules using native ES6 modules and the async import()
+ * @param dependencies
+ * @param container
+ * @param modules
+ * @param opts
+ */
+async function loadEsModules(dependencies, container, modules, opts) {
+    const importPromises = [];
+    for (const m of modules) {
+        const fileUrl = (0, url_1.pathToFileURL)(m.path).toString();
+        importPromises.push((0, As_1.As)(dependencies.require(fileUrl)));
+    }
+    const imports = await Promise.all(importPromises);
+    const result = [];
+    for (let i = 0; i < modules.length; i++) {
+        result.push((0, As_1.As)(parseLoadedModule(imports[i], modules[i])));
+    }
+    return registerModules(result, container, modules, opts);
+}
+/**
+ * Parses the module which has been required
+ *
+ * @param {any} loaded
+ * @param {ModuleDescriptor} m
+ */
+function parseLoadedModule(loaded, m) {
+    const items = [];
+    if (!loaded)
+        return items;
+    if ((0, Utils_js_1.isFunction)(loaded)) {
+        // for module.exports = ...
+        items.push({
+            name: m.name,
+            path: m.path,
+            value: loaded,
+            opts: m.opts
+        });
+        return items;
+    }
+    if (loaded.default && (0, Utils_js_1.isFunction)(loaded.default)) {
+        // ES6 default export
+        items.push({
+            name: m.name,
+            path: m.path,
+            value: loaded.default,
+            opts: m.opts
+        });
+    }
+    // loop through non-default exports, but require the RESOLVER property set for
+    // it to be a valid service module export.
+    for (const key of Object.keys(loaded)) {
+        if (key === 'default')
+            continue;
+        if ((0, Utils_js_1.isFunction)(loaded[key]) && Resolvers_js_1.RESOLVER in loaded[key]) {
+            items.push({
+                name: key,
+                path: m.path,
+                value: loaded[key],
+                opts: m.opts
+            });
+        }
+    }
+    return items;
+}
+/**
+ * Registers the modules
+ * @param modulesToRegister
+ * @param container
+ * @param modules
+ * @param opts
+ */
+function registerModules(modulesToRegister, container, modules, opts) {
+    modulesToRegister
+        .reduce((acc, cur) => acc.concat(cur), [])
+        .filter((x) => x)
+        .forEach(registerDescriptor.bind(null, container, opts));
+    return {
+        loadedModules: modules
+    };
+}
+/**
+ * Returns a new options object with defaults applied.
+ * @param opts
+ */
+function optsWithDefaults(opts) {
+    return {
+        resolverOptions: {
+            lifetime: Lifetime_js_1.Lifetime.TRANSIENT,
+            ...(opts && opts.resolverOptions)
+        },
+        ...opts
+    };
+}
+/**
+ * Given a module descriptor, reads it and registers it's value with the container.
+ * @param container
+ * @param opts
+ * @param moduleDescriptor
+ */
+function registerDescriptor(container, opts, moduleDescriptor) {
+    const inlineConfig = moduleDescriptor.value[Resolvers_js_1.RESOLVER];
+    let name = inlineConfig && inlineConfig.name;
+    if (!name) {
+        name = moduleDescriptor.name;
+        let formatter = opts.formatName;
+        if (formatter) {
+            if (typeof formatter === 'string') {
+                formatter = nameFormatters[formatter];
+            }
+            if (formatter) {
+                name = formatter(name, moduleDescriptor);
+            }
+        }
+    }
+    let moduleDescriptorOpts = moduleDescriptor.opts;
+    if (typeof moduleDescriptorOpts === 'string') {
+        moduleDescriptorOpts = { lifetime: moduleDescriptorOpts };
+    }
+    const regOpts = {
+        ...opts.resolverOptions,
+        ...moduleDescriptorOpts,
+        ...inlineConfig
+    };
+    const reg = regOpts.register
+        ? regOpts.register
+        : (0, Utils_js_1.isClass)(moduleDescriptor.value)
+            ? Resolvers_js_1.asClass
+            : Resolvers_js_1.asFunction;
+    container.register(name, reg(moduleDescriptor.value, regOpts));
+}

package/dist/cjs/lib/ioc/ObjectLifetime.d.ts

@@ -0,0 +1,22 @@
+import { IConstructor } from '../../interfaces/IConstructor.js';
+import { LifetimeType } from './Lifetime.js';
+/**
+ * Get Object's lifetime
+ * @param target
+ * @constructor
+ */
+export declare function getObjectLifetime<ClassConstructor extends IConstructor>(target: ClassConstructor): LifetimeType;
+/**
+ * Get whether Object's lifetime is locked
+ * @param target
+ * @constructor
+ */
+export declare function getObjectLifetimeLocked<ClassConstructor extends IConstructor>(target: ClassConstructor): boolean;
+/**
+ * Set Object's lifetime
+ * @param target
+ * @param lifetime
+ * @param lock
+ * @constructor
+ */
+export declare function setObjectLifetime<ClassConstructor extends IConstructor>(target: ClassConstructor, lifetime: LifetimeType, lock?: boolean): ClassConstructor;

package/dist/cjs/lib/ioc/ObjectLifetime.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObjectLifetime = getObjectLifetime;
+exports.getObjectLifetimeLocked = getObjectLifetimeLocked;
+exports.setObjectLifetime = setObjectLifetime;
+const DIMetadataKey_js_1 = require("../../constants/DIMetadataKey.js");
+const LifetimeLockedException_js_1 = require("../../exceptions/di/LifetimeLockedException.js");
+/**
+ * Get Object's lifetime
+ * @param target
+ * @constructor
+ */
+function getObjectLifetime(target) {
+    return Reflect.getMetadata(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_LIFETIME, target);
+}
+/**
+ * Get whether Object's lifetime is locked
+ * @param target
+ * @constructor
+ */
+function getObjectLifetimeLocked(target) {
+    return !!Reflect.getMetadata(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_LIFETIME_LOCK, target);
+}
+/**
+ * Set Object's lifetime
+ * @param target
+ * @param lifetime
+ * @param lock
+ * @constructor
+ */
+function setObjectLifetime(target, lifetime, lock = false) {
+    //A locked lifetime can be declared again, but never changed
+    if (getObjectLifetimeLocked(target) && getObjectLifetime(target) !== lifetime)
+        throw new LifetimeLockedException_js_1.LifetimeLockedException('[{0}] Object lifecycle settings cannot be applied because the parent object lifecycle of the current operation object is locked', [target.name]);
+    if (lock)
+        Reflect.defineMetadata(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_LIFETIME_LOCK, true, target);
+    Reflect.defineMetadata(DIMetadataKey_js_1.DI_TARGET_CONSTRUCTOR_LIFETIME, lifetime, target);
+    return target;
+}

package/dist/cjs/lib/ioc/ObjectWeakRefs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Get object weak refs
+ * @param target
+ * @constructor
+ */
+export declare function getObjectWeakRefs<ObjectInstance extends object>(target: any): Set<WeakRef<ObjectInstance>>;
+/**
+ * Append object weak refs
+ * @param target
+ * @param instance
+ * @constructor
+ */
+export declare function appendObjectWeakRefs<ObjectInstance extends object>(target: any, instance: ObjectInstance): void;
+/**
+ * Clear transient object weak refs
+ * @param target
+ * @constructor
+ */
+export declare function clearObjectWeakRefs(target: any): void;

package/dist/cjs/lib/ioc/ObjectWeakRefs.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObjectWeakRefs = getObjectWeakRefs;
+exports.appendObjectWeakRefs = appendObjectWeakRefs;
+exports.clearObjectWeakRefs = clearObjectWeakRefs;
+const As_1 = require("@lakutata/utils/As");
+const OWR_SYMBOL = Symbol('OWR'); //Object Weak Ref
+const OFR_SYMBOL = Symbol('OFR'); //Object Finalization Registry
+/**
+ * Get object weak refs
+ * @param target
+ * @constructor
+ */
+function getObjectWeakRefs(target) {
+    if (!Reflect.hasOwnMetadata(OFR_SYMBOL, target))
+        Reflect.defineMetadata(OFR_SYMBOL, new FinalizationRegistry((ref) => {
+            const objectWeakRefs = Reflect.getOwnMetadata(OWR_SYMBOL, target) || new Set();
+            objectWeakRefs.delete(ref);
+            Reflect.defineMetadata(OWR_SYMBOL, objectWeakRefs, target);
+        }), target);
+    if (!Reflect.hasOwnMetadata(OWR_SYMBOL, target))
+        Reflect.defineMetadata(OWR_SYMBOL, new Set(), target);
+    return Reflect.getOwnMetadata(OWR_SYMBOL, target);
+}
+/**
+ * Append object weak refs
+ * @param target
+ * @param instance
+ * @constructor
+ */
+function appendObjectWeakRefs(target, instance) {
+    const refs = getObjectWeakRefs(target);
+    const ref = new WeakRef(instance);
+    (0, As_1.As)(Reflect.getOwnMetadata(OFR_SYMBOL, target)).register(instance, ref);
+    refs.add(ref);
+    Reflect.defineMetadata(OWR_SYMBOL, refs, target);
+}
+/**
+ * Clear transient object weak refs
+ * @param target
+ * @constructor
+ */
+function clearObjectWeakRefs(target) {
+    if (!Reflect.hasOwnMetadata(OWR_SYMBOL, target))
+        return;
+    Reflect.deleteMetadata(OWR_SYMBOL, target);
+}

package/dist/cjs/lib/ioc/Resolvers.d.ts

@@ -0,0 +1,136 @@
+import { FunctionReturning, IDependencyInjectionContainer } from './DependencyInjectionContainer.js';
+import { type LifetimeType } from './Lifetime.js';
+/**
+ * RESOLVER symbol can be used by modules loaded by
+ * `loadModules` to configure their lifetime, injection mode, etc.
+ */
+export declare const RESOLVER: unique symbol;
+/**
+ * Gets passed the container and is expected to return an object
+ * whose properties are accessible at construction time for the
+ * configured resolver.
+ *
+ * @type {Function}
+ */
+export type InjectorFunction = <T extends object>(container: IDependencyInjectionContainer<T>) => object;
+/**
+ * A resolver object returned by asClass(), asFunction() or asValue().
+ */
+export interface Resolver<T> extends ResolverOptions<T> {
+    resolve<U extends object>(container: IDependencyInjectionContainer<U>): T;
+}
+/**
+ * A resolver object created by asClass() or asFunction().
+ */
+export interface BuildResolver<T> extends Resolver<T>, BuildResolverOptions<T> {
+    injector?: InjectorFunction;
+    setLifetime(lifetime: LifetimeType): this;
+    singleton(): this;
+    scoped(): this;
+    transient(): this;
+    inject(injector: InjectorFunction): this;
+}
+/**
+ * Options for disposable resolvers.
+ */
+export interface DisposableResolverOptions<T> extends ResolverOptions<T> {
+    dispose?: Disposer<T>;
+}
+/**
+ * Disposable resolver.
+ */
+export interface DisposableResolver<T> extends Resolver<T>, DisposableResolverOptions<T> {
+    disposer(dispose: Disposer<T>): this;
+}
+/**
+ * Disposer function type.
+ */
+export type Disposer<T> = (value: T) => any | Promise<any>;
+/**
+ * The options when registering a class, function or value.
+ * @type RegistrationOptions
+ */
+export interface ResolverOptions<T> {
+    /**
+     * Only used for inline configuration with `loadModules`.
+     */
+    name?: string;
+    /**
+     * Lifetime setting.
+     */
+    lifetime?: LifetimeType;
+    /**
+     * Registration function to use. Only used for inline configuration with `loadModules`.
+     */
+    register?: (...args: any[]) => Resolver<T>;
+    /**
+     * True if this resolver should be excluded from lifetime leak checking. Used by resolvers that
+     * wish to uphold the anti-leakage contract themselves. Defaults to false.
+     */
+    isLeakSafe?: boolean;
+}
+/**
+ * Builder resolver options.
+ */
+export interface BuildResolverOptions<T> extends ResolverOptions<T>, DisposableResolverOptions<T> {
+    /**
+     * Injector function to provide additional parameters.
+     */
+    injector?: InjectorFunction;
+}
+/**
+ * A class constructor. For example:
+ *
+ *    class MyClass {}
+ *
+ *    container.registerClass('myClass', MyClass)
+ *                                       ^^^^^^^
+ */
+export type Constructor<T> = {
+    new (...args: any[]): T;
+};
+/**
+ * Creates a simple value resolver where the given value will always be resolved. The value is
+ * marked as leak-safe since in strict mode, the value will only be resolved when it is not leaking
+ * upwards from a child scope to a parent singleton.
+ *
+ * @param  {string} name The name to register the value as.
+ *
+ * @param  {*} value The value to resolve.
+ *
+ * @return {object} The resolver.
+ */
+export declare function asValue<T>(value: T): Resolver<T>;
+/**
+ * Creates a factory resolver, where the given factory function
+ * will be invoked with `new` when requested.
+ *
+ * @param  {string} name
+ * The name to register the value as.
+ *
+ * @param  {Function} fn
+ * The function to register.
+ *
+ * @param {object} opts
+ * Additional options for the resolver.
+ *
+ * @return {object}
+ * The resolver.
+ */
+export declare function asFunction<T>(fn: FunctionReturning<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+/**
+ * Like a factory resolver, but for classes that require `new`.
+ *
+ * @param  {string} name
+ * The name to register the value as.
+ *
+ * @param  {Class} Type
+ * The function to register.
+ *
+ * @param {object} opts
+ * Additional options for the resolver.
+ *
+ * @return {object}
+ * The resolver.
+ */
+export declare function asClass<T = object>(Type: Constructor<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;