@midwayjs/core 3.0.0-alpha.9 → 3.0.0-beta.4

package/dist/util/pathToRegexp.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * this file fork from path-to-regexp package v1.8.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathToRegexp = void 0;
+/**
+ * The main path matching regexp utility.
+ *
+ * @type {RegExp}
+ */
+const PATH_REGEXP = new RegExp([
+    // Match escaped characters that would otherwise appear in future matches.
+    // This allows the user to escape special characters that won't transform.
+    '(\\\\.)',
+    // Match Express-style parameters and un-named parameters with a prefix
+    // and optional suffixes. Matches appear as:
+    //
+    // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]
+    // "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined, undefined]
+    // "/*"            => ["/", undefined, undefined, undefined, undefined, "*"]
+    '([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))',
+].join('|'), 'g');
+/**
+ * Parse a string for the raw tokens.
+ *
+ * @param  {string}  str
+ * @param  {Object=} options
+ * @return {!Array}
+ */
+function parse(str, options) {
+    const tokens = [];
+    let key = 0;
+    let index = 0;
+    let path = '';
+    const defaultDelimiter = (options && options.delimiter) || '/';
+    let res;
+    while ((res = PATH_REGEXP.exec(str)) != null) {
+        const m = res[0];
+        const escaped = res[1];
+        const offset = res.index;
+        path += str.slice(index, offset);
+        index = offset + m.length;
+        // Ignore already escaped sequences.
+        if (escaped) {
+            path += escaped[1];
+            continue;
+        }
+        const next = str[index];
+        const prefix = res[2];
+        const name = res[3];
+        const capture = res[4];
+        const group = res[5];
+        const modifier = res[6];
+        const asterisk = res[7];
+        // Push the current path onto the tokens.
+        if (path) {
+            tokens.push(path);
+            path = '';
+        }
+        const partial = prefix != null && next != null && next !== prefix;
+        const repeat = modifier === '+' || modifier === '*';
+        const optional = modifier === '?' || modifier === '*';
+        const delimiter = res[2] || defaultDelimiter;
+        const pattern = capture || group;
+        tokens.push({
+            name: name || key++,
+            prefix: prefix || '',
+            delimiter: delimiter,
+            optional: optional,
+            repeat: repeat,
+            partial: partial,
+            asterisk: !!asterisk,
+            pattern: pattern
+                ? escapeGroup(pattern)
+                : asterisk
+                    ? '.*'
+                    : '[^' + escapeString(delimiter) + ']+?',
+        });
+    }
+    // Match any characters still remaining.
+    if (index < str.length) {
+        path += str.substr(index);
+    }
+    // If the path exists, push it onto the end.
+    if (path) {
+        tokens.push(path);
+    }
+    return tokens;
+}
+/**
+ * Escape a regular expression string.
+ *
+ * @param  {string} str
+ * @return {string}
+ */
+function escapeString(str) {
+    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+}
+/**
+ * Escape the capturing group by escaping special characters and meaning.
+ *
+ * @param  {string} group
+ * @return {string}
+ */
+function escapeGroup(group) {
+    return group.replace(/([=!:$/()])/g, '\\$1');
+}
+/**
+ * Attach the keys as a property of the regexp.
+ *
+ * @param  {!RegExp} re
+ * @param  {Array}   keys
+ * @return {!RegExp}
+ */
+function attachKeys(re, keys) {
+    re.keys = keys;
+    return re;
+}
+/**
+ * Get the flags for a regexp from the options.
+ *
+ * @param  {Object} options
+ * @return {string}
+ */
+function flags(options) {
+    return options && options.sensitive ? '' : 'i';
+}
+/**
+ * Pull out keys from a regexp.
+ *
+ * @param  {!RegExp} path
+ * @param  {!Array}  keys
+ * @return {!RegExp}
+ */
+function regexpToRegexp(path, keys) {
+    // Use a negative lookahead to match only capturing groups.
+    const groups = path.source.match(/\((?!\?)/g);
+    if (groups) {
+        for (let i = 0; i < groups.length; i++) {
+            keys.push({
+                name: i,
+                prefix: null,
+                delimiter: null,
+                optional: false,
+                repeat: false,
+                partial: false,
+                asterisk: false,
+                pattern: null,
+            });
+        }
+    }
+    return attachKeys(path, keys);
+}
+/**
+ * Transform an array into a regexp.
+ *
+ * @param  {!Array}  path
+ * @param  {Array}   keys
+ * @param  {!Object} options
+ * @return {!RegExp}
+ */
+function arrayToRegexp(path, keys, options) {
+    const parts = [];
+    for (let i = 0; i < path.length; i++) {
+        parts.push(pathToRegexp(path[i], keys, options).source);
+    }
+    const regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));
+    return attachKeys(regexp, keys);
+}
+/**
+ * Create a path regexp from string input.
+ *
+ * @param  {string}  path
+ * @param  {!Array}  keys
+ * @param  {!Object} options
+ * @return {!RegExp}
+ */
+function stringToRegexp(path, keys, options) {
+    return tokensToRegExp(parse(path, options), keys, options);
+}
+/**
+ * Expose a function for taking tokens and returning a RegExp.
+ *
+ * @param  {!Array}          tokens
+ * @param  {(Array|Object)=} keys
+ * @param  {Object=}         options
+ * @return {!RegExp}
+ */
+function tokensToRegExp(tokens, keys, options) {
+    if (!Array.isArray(keys)) {
+        options = /** @type {!Object} */ keys || options;
+        keys = [];
+    }
+    options = options || {};
+    const strict = options.strict;
+    const end = options.end !== false;
+    let route = '';
+    // Iterate over the tokens and create our regexp string.
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (typeof token === 'string') {
+            route += escapeString(token);
+        }
+        else {
+            const prefix = escapeString(token.prefix);
+            let capture = '(?:' + token.pattern + ')';
+            keys.push(token);
+            if (token.repeat) {
+                capture += '(?:' + prefix + capture + ')*';
+            }
+            if (token.optional) {
+                if (!token.partial) {
+                    capture = '(?:' + prefix + '(' + capture + '))?';
+                }
+                else {
+                    capture = prefix + '(' + capture + ')?';
+                }
+            }
+            else {
+                capture = prefix + '(' + capture + ')';
+            }
+            route += capture;
+        }
+    }
+    const delimiter = escapeString(options.delimiter || '/');
+    const endsWithDelimiter = route.slice(-delimiter.length) === delimiter;
+    // In non-strict mode we allow a slash at the end of match. If the path to
+    // match already ends with a slash, we remove it for consistency. The slash
+    // is valid at the end of a path match, not in the middle. This is important
+    // in non-ending mode, where "/test/" shouldn't match "/test//route".
+    if (!strict) {
+        route =
+            (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) +
+                '(?:' +
+                delimiter +
+                '(?=$))?';
+    }
+    if (end) {
+        route += '$';
+    }
+    else {
+        // In non-ending mode, we need the capturing groups to match as much as
+        // possible by using a positive lookahead to the end or next path segment.
+        route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';
+    }
+    return attachKeys(new RegExp('^' + route, flags(options)), keys);
+}
+/**
+ * Normalize the given path string, returning a regular expression.
+ *
+ * An empty array can be passed in for the keys, which will hold the
+ * placeholder key descriptions. For example, using `/user/:id`, `keys` will
+ * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+ *
+ * @param  {(string|RegExp|Array)} path
+ * @param  {(Array|Object)=}       keys
+ * @param  {Object=}               options
+ * @return {!RegExp}
+ */
+function pathToRegexp(path, keys, options) {
+    if (!Array.isArray(keys)) {
+        options = /** @type {!Object} */ keys || options;
+        keys = [];
+    }
+    options = options || {};
+    if (path instanceof RegExp) {
+        return regexpToRegexp(path, /** @type {!Array} */ keys);
+    }
+    if (Array.isArray(path)) {
+        return arrayToRegexp(
+        /** @type {!Array} */ path, 
+        /** @type {!Array} */ keys, options);
+    }
+    return stringToRegexp(
+    /** @type {string} */ path, 
+    /** @type {!Array} */ keys, options);
+}
+exports.pathToRegexp = pathToRegexp;
+//# sourceMappingURL=pathToRegexp.js.map

package/dist/util/webRouterParam.d.ts

@@ -1,3 +1,3 @@
-export declare const extractKoaLikeValue: (key: any, data: any) => (ctx: any, next: any) => Promise<any>;
-export declare const extractExpressLikeValue: (key: any, data: any) => (req: any, res: any, next: any) => Promise<any>;
+export declare const extractKoaLikeValue: (key: any, data: any, paramType?: any) => (ctx: any, next: any) => any;
+export declare const extractExpressLikeValue: (key: any, data: any, paramType?: any) => (req: any, res: any, next: any) => any;
 //# sourceMappingURL=webRouterParam.d.ts.map

package/dist/util/webRouterParam.js

@@ -2,26 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractExpressLikeValue = exports.extractKoaLikeValue = void 0;
 const decorator_1 = require("@midwayjs/decorator");
-const extractKoaLikeValue = (key, data) => {
+const index_1 = require("./index");
+const extractKoaLikeValue = (key, data, paramType) => {
     if (decorator_1.ALL === data) {
         data = undefined;
     }
-    return async function (ctx, next) {
+    return function (ctx, next) {
         switch (key) {
             case decorator_1.RouteParamTypes.NEXT:
                 return next;
             case decorator_1.RouteParamTypes.BODY:
-                return data && ctx.request.body
-                    ? ctx.request.body[data]
-                    : ctx.request.body;
+                return (0, index_1.transformRequestObjectByType)(data && ctx.request.body ? ctx.request.body[data] : ctx.request.body, paramType);
             case decorator_1.RouteParamTypes.PARAM:
-                return data ? ctx.params[data] : ctx.params;
+                return (0, index_1.transformRequestObjectByType)(data ? ctx.params[data] : ctx.params, paramType);
             case decorator_1.RouteParamTypes.QUERY:
-                return data ? ctx.query[data] : ctx.query;
+                return (0, index_1.transformRequestObjectByType)(data ? ctx.query[data] : ctx.query, paramType);
             case decorator_1.RouteParamTypes.HEADERS:
-                return data ? ctx.get(data) : ctx.headers;
+                return (0, index_1.transformRequestObjectByType)(data ? ctx.get(data) : ctx.headers, paramType);
             case decorator_1.RouteParamTypes.SESSION:
-                return data ? ctx.session[data] : ctx.session;
+                return (0, index_1.transformRequestObjectByType)(data ? ctx.session[data] : ctx.session, paramType);
             case decorator_1.RouteParamTypes.FILESTREAM:
                 return ctx.getFileStream && ctx.getFileStream(data);
             case decorator_1.RouteParamTypes.FILESSTREAM:
@@ -32,10 +31,10 @@ const extractKoaLikeValue = (key, data) => {
                 return ctx['ip'];
             case decorator_1.RouteParamTypes.QUERIES:
                 if (ctx.queries) {
-                    return data ? ctx.queries[data] : ctx.queries;
+                    return (0, index_1.transformRequestObjectByType)(data ? ctx.queries[data] : ctx.queries, paramType);
                 }
                 else {
-                    return data ? ctx.query[data] : ctx.query;
+                    return (0, index_1.transformRequestObjectByType)(data ? ctx.query[data] : ctx.query, paramType);
                 }
             default:
                 return null;
@@ -43,24 +42,24 @@ const extractKoaLikeValue = (key, data) => {
     };
 };
 exports.extractKoaLikeValue = extractKoaLikeValue;
-const extractExpressLikeValue = (key, data) => {
+const extractExpressLikeValue = (key, data, paramType) => {
     if (decorator_1.ALL === data) {
         data = undefined;
     }
-    return async function (req, res, next) {
+    return function (req, res, next) {
         switch (key) {
             case decorator_1.RouteParamTypes.NEXT:
                 return next;
             case decorator_1.RouteParamTypes.BODY:
-                return data && req.body ? req.body[data] : req.body;
+                return (0, index_1.transformRequestObjectByType)(data && req.body ? req.body[data] : req.body, paramType);
             case decorator_1.RouteParamTypes.PARAM:
-                return data ? req.params[data] : req.params;
+                return (0, index_1.transformRequestObjectByType)(data ? req.params[data] : req.params, paramType);
             case decorator_1.RouteParamTypes.QUERY:
-                return data ? req.query[data] : req.query;
+                return (0, index_1.transformRequestObjectByType)(data ? req.query[data] : req.query, paramType);
             case decorator_1.RouteParamTypes.HEADERS:
-                return data ? req.get(data) : req.headers;
+                return (0, index_1.transformRequestObjectByType)(data ? req.get(data) : req.headers, paramType);
             case decorator_1.RouteParamTypes.SESSION:
-                return data ? req.session[data] : req.session;
+                return (0, index_1.transformRequestObjectByType)(data ? req.session[data] : req.session, paramType);
             case decorator_1.RouteParamTypes.FILESTREAM:
                 return req.getFileStream && req.getFileStream(data);
             case decorator_1.RouteParamTypes.FILESSTREAM:
@@ -71,10 +70,10 @@ const extractExpressLikeValue = (key, data) => {
                 return req['ip'];
             case decorator_1.RouteParamTypes.QUERIES:
                 if (req.queries) {
-                    return data ? req.queries[data] : req.queries;
+                    return (0, index_1.transformRequestObjectByType)(data ? req.queries[data] : req.queries, paramType);
                 }
                 else {
-                    return data ? req.query[data] : req.query;
+                    return (0, index_1.transformRequestObjectByType)(data ? req.query[data] : req.query, paramType);
                 }
             default:
                 return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.0.0-alpha.9+d5acc750",
+  "version": "3.0.0-beta.4",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -21,24 +21,19 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/decorator": "^3.0.0-alpha.2",
-    "chai": "^4.2.0",
+    "@midwayjs/decorator": "^3.0.0-beta.4",
+    "midway-test-component": "*",
     "mm": "3",
     "sinon": "^7.2.2"
   },
   "peerDependencies": {
-    "@midwayjs/decorator": "^2.10.12"
+    "@midwayjs/decorator": "*"
   },
   "dependencies": {
     "@midwayjs/glob": "^1.0.2",
-    "@midwayjs/logger": "^2.11.3",
-    "class-transformer": "^0.3.1",
+    "@midwayjs/logger": "^3.0.0-beta.4",
+    "class-transformer": "^0.4.0",
     "extend2": "^1.0.0",
-    "lodash.clonedeep": "^4.5.0",
-    "lodash.defaultsdeep": "^4.6.0",
-    "lodash.get": "^4.4.2",
-    "lodash.set": "^4.3.2",
-    "lodash.template": "^4.4.0",
     "picomatch": "^2.2.2",
     "reflect-metadata": "^0.1.13"
   },
@@ -48,7 +43,7 @@
     "url": "http://github.com/midwayjs/midway.git"
   },
   "engines": {
-    "node": ">= 10.0.0"
+    "node": ">=12"
   },
-  "gitHead": "d5acc7505275ea9d566edd38e5e0377141e0abc1"
+  "gitHead": "02e2144e302f807770b512b0d89da3145b1cbf2e"
 }

package/dist/common/lodashWrap.d.ts

@@ -1,9 +0,0 @@
-import * as get from 'lodash.get';
-import * as set from 'lodash.set';
-import * as template from 'lodash.template';
-import * as cloneDeep from 'lodash.clonedeep';
-import * as defaultsDeep from 'lodash.defaultsdeep';
-import * as assign from 'extend2';
-declare const isArray: (arg: any) => arg is any[];
-export { assign, set, get, isArray, template, cloneDeep, defaultsDeep };
-//# sourceMappingURL=lodashWrap.d.ts.map

package/dist/common/lodashWrap.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultsDeep = exports.cloneDeep = exports.template = exports.isArray = exports.get = exports.set = exports.assign = void 0;
-const get = require("lodash.get");
-exports.get = get;
-const set = require("lodash.set");
-exports.set = set;
-const template = require("lodash.template");
-exports.template = template;
-const cloneDeep = require("lodash.clonedeep");
-exports.cloneDeep = cloneDeep;
-const defaultsDeep = require("lodash.defaultsdeep");
-exports.defaultsDeep = defaultsDeep;
-const assign = require("extend2");
-exports.assign = assign;
-const isArray = Array.isArray;
-exports.isArray = isArray;
-//# sourceMappingURL=lodashWrap.js.map

package/dist/common/notFoundError.d.ts

@@ -1,8 +0,0 @@
-import { ObjectIdentifier } from '@midwayjs/decorator';
-export declare class NotFoundError extends Error {
-    static readonly type: unique symbol;
-    static isClosePrototypeOf(ins: NotFoundError): boolean;
-    constructor(identifier: ObjectIdentifier);
-    updateErrorMsg(className: string): void;
-}
-//# sourceMappingURL=notFoundError.d.ts.map

package/dist/common/notFoundError.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotFoundError = void 0;
-class NotFoundError extends Error {
-    constructor(identifier) {
-        super(`${identifier} is not valid in current context`);
-        this[NotFoundError.type] = NotFoundError.type;
-    }
-    static isClosePrototypeOf(ins) {
-        return ins ? ins[NotFoundError.type] === NotFoundError.type : false;
-    }
-    updateErrorMsg(className) {
-        const identifier = this.message.split(' is not valid in current context')[0];
-        const msg = `${identifier} in class ${className} is not valid in current context`;
-        this.message = msg;
-    }
-}
-exports.NotFoundError = NotFoundError;
-NotFoundError.type = Symbol.for('#NotFoundError');
-//# sourceMappingURL=notFoundError.js.map

package/dist/common/reflectTool.d.ts

@@ -1,15 +0,0 @@
-import 'reflect-metadata';
-import { ReflectResult } from '@midwayjs/decorator';
-/**
- * 以数组形式返回对象所有 property, 数组第一个元素是距离 o 最近的原型
- * @param target 对象，class 或者 function
- */
-export declare function recursiveGetPrototypeOf(target: any): any[];
-export declare function getOwnMetadata(metadataKey: any, target: any, propertyKey?: string | symbol): ReflectResult;
-/**
- * get metadata value of a metadata key on the prototype chain of an object and property
- * @param metadataKey metadata's key
- * @param target the target of metadataKey
- */
-export declare function recursiveGetMetadata(metadataKey: any, target: any, propertyKey?: string | symbol): ReflectResult[];
-//# sourceMappingURL=reflectTool.d.ts.map

package/dist/common/reflectTool.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.recursiveGetMetadata = exports.getOwnMetadata = exports.recursiveGetPrototypeOf = void 0;
-require("reflect-metadata");
-const functionPrototype = Object.getPrototypeOf(Function);
-// get property of an object
-// https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof
-function ordinaryGetPrototypeOf(O) {
-    const proto = Object.getPrototypeOf(O);
-    if (typeof O !== 'function' || O === functionPrototype) {
-        return proto;
-    }
-    // TypeScript doesn't set __proto__ in ES5, as it's non-standard.
-    // Try to determine the superclass constructor. Compatible implementations
-    // must either set __proto__ on a subclass constructor to the superclass constructor,
-    // or ensure each class has a valid `constructor` property on its prototype that
-    // points back to the constructor.
-    // If this is not the same as Function.[[Prototype]], then this is definately inherited.
-    // This is the case when in ES6 or when using __proto__ in a compatible browser.
-    if (proto !== functionPrototype) {
-        return proto;
-    }
-    // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.
-    const prototype = O.prototype;
-    const prototypeProto = prototype && Object.getPrototypeOf(prototype);
-    if (prototypeProto == null || prototypeProto === Object.prototype) {
-        return proto;
-    }
-    // If the constructor was not a function, then we cannot determine the heritage.
-    const constructor = prototypeProto.constructor;
-    if (typeof constructor !== 'function') {
-        return proto;
-    }
-    // If we have some kind of self-reference, then we cannot determine the heritage.
-    if (constructor === O) {
-        return proto;
-    }
-    // we have a pretty good guess at the heritage.
-    return constructor;
-}
-/**
- * 以数组形式返回对象所有 property, 数组第一个元素是距离 o 最近的原型
- * @param target 对象，class 或者 function
- */
-function recursiveGetPrototypeOf(target) {
-    const properties = [];
-    let parent = ordinaryGetPrototypeOf(target);
-    while (parent !== null) {
-        properties.push(parent);
-        parent = ordinaryGetPrototypeOf(parent);
-    }
-    return properties;
-}
-exports.recursiveGetPrototypeOf = recursiveGetPrototypeOf;
-function getOwnMetadata(metadataKey, target, propertyKey) {
-    return Reflect.getOwnMetadata(metadataKey, target, propertyKey);
-}
-exports.getOwnMetadata = getOwnMetadata;
-/**
- * get metadata value of a metadata key on the prototype chain of an object and property
- * @param metadataKey metadata's key
- * @param target the target of metadataKey
- */
-function recursiveGetMetadata(metadataKey, target, propertyKey) {
-    const metadatas = [];
-    // get metadata value of a metadata key on the prototype
-    let metadata = Reflect.getOwnMetadata(metadataKey, target, propertyKey);
-    if (metadata) {
-        metadatas.push(metadata);
-    }
-    // get metadata value of a metadata key on the prototype chain
-    let parent = ordinaryGetPrototypeOf(target);
-    while (parent !== null) {
-        metadata = Reflect.getOwnMetadata(metadataKey, parent, propertyKey);
-        if (metadata) {
-            metadatas.push(metadata);
-        }
-        parent = ordinaryGetPrototypeOf(parent);
-    }
-    return metadatas;
-}
-exports.recursiveGetMetadata = recursiveGetMetadata;
-//# sourceMappingURL=reflectTool.js.map

package/dist/context/applicationContext.d.ts

@@ -1,81 +0,0 @@
-/**
- * 基础的ObjectFactory和ApplicationContext实现
- */
-import { ObjectIdentifier } from '@midwayjs/decorator';
-import { IApplicationContext, IObjectDefinition, IObjectDefinitionRegistry, IObjectFactory, ObjectDependencyTree } from '../interface';
-import { ObjectProperties } from '../definitions/properties';
-import { ManagedResolverFactory } from './managedResolverFactory';
-export declare class ObjectDefinitionRegistry extends Map implements IObjectDefinitionRegistry {
-    private singletonIds;
-    get identifiers(): any[];
-    get count(): number;
-    getSingletonDefinitionIds(): ObjectIdentifier[];
-    getDefinitionByName(name: string): IObjectDefinition[];
-    registerDefinition(identifier: ObjectIdentifier, definition: IObjectDefinition): void;
-    getDefinition(identifier: ObjectIdentifier): IObjectDefinition;
-    getDefinitionByPath(path: string): IObjectDefinition;
-    removeDefinition(identifier: ObjectIdentifier): void;
-    hasDefinition(identifier: ObjectIdentifier): boolean;
-    clearAll(): void;
-    hasObject(identifier: ObjectIdentifier): boolean;
-    registerObject(identifier: ObjectIdentifier, target: any): void;
-    getObject(identifier: ObjectIdentifier): any;
-}
-export declare class BaseApplicationContext implements IApplicationContext, IObjectFactory {
-    protected readied: boolean;
-    protected midwayIdentifiers: string[];
-    private _resolverFactory;
-    private _registry;
-    private _props;
-    private _dependencyMap;
-    baseDir: string;
-    parent: IApplicationContext;
-    disableConflictCheck: boolean;
-    constructor(baseDir?: string, parent?: IApplicationContext);
-    get dependencyMap(): Map<string, ObjectDependencyTree>;
-    get props(): ObjectProperties;
-    get registry(): IObjectDefinitionRegistry;
-    set registry(registry: IObjectDefinitionRegistry);
-    protected getManagedResolverFactory(): ManagedResolverFactory;
-    /**
-     * 继承实现时需要调用super
-     */
-    protected init(): void;
-    stop(): Promise<void>;
-    ready(): void;
-    protected loadDefinitions(): void;
-    isAsync(identifier: ObjectIdentifier): boolean;
-    get<T>(identifier: {
-        new (...args: any[]): T;
-    }, args?: any): T;
-    get<T>(identifier: ObjectIdentifier, args?: any): T;
-    getAsync<T>(identifier: {
-        new (...args: any[]): T;
-    }, args?: any): Promise<T>;
-    getAsync<T>(identifier: ObjectIdentifier, args?: any): Promise<T>;
-    get isReady(): boolean;
-    /**
-     * proxy registry.registerDefinition
-     * @param {ObjectIdentifier} identifier
-     * @param {IObjectDefinition} definition
-     */
-    registerDefinition(identifier: ObjectIdentifier, definition: IObjectDefinition): void;
-    /**
-     * proxy registry.registerObject
-     * @param {ObjectIdentifier} identifier
-     * @param target
-     */
-    registerObject(identifier: ObjectIdentifier, target: any): void;
-    /**
-     * register handler after instance create
-     * @param fn
-     */
-    afterEachCreated(fn: (ins: any, context: IApplicationContext, definition?: IObjectDefinition) => void): void;
-    /**
-     * register handler before instance create
-     * @param fn
-     */
-    beforeEachCreated(fn: (Clzz: any, constructorArgs: any[], context: IApplicationContext) => void): void;
-    protected createObjectDependencyTree(identifier: any, definition: any): void;
-}
-//# sourceMappingURL=applicationContext.d.ts.map