mani-game-engine 1.0.0-pre.34 → 1.0.0-pre.36

package/lib/injector.js

@@ -1,290 +1,290 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injector = exports.InjectType = exports.InjectId = exports.Inject = exports.createDependencyAnnotation = exports.putIfAbsent = void 0;
-require("reflect-metadata");
-const isInjectDependency = (dep) => dep.kind === 'inject';
-const isTypeDependency = (dep) => dep.kind === 'type';
-const putIfAbsent = (map, key, value) => {
-    let v = map.get(key);
-    if (!v) {
-        v = value();
-        map.set(key, v);
-    }
-    return v;
-};
-exports.putIfAbsent = putIfAbsent;
-const createDependencyAnnotation = (cb) => (dependantType, _propertyKey, index) => {
-    const metadata = Reflect.getMetadata('design:paramtypes', dependantType);
-    const type = metadata[index];
-    if (type === dependantType) {
-        throw new Error('Could not inject class in itself.');
-    }
-    const depList = (0, exports.putIfAbsent)(Injector.dependencyMap, dependantType, () => []);
-    depList.push(cb(type, index, dependantType));
-};
-exports.createDependencyAnnotation = createDependencyAnnotation;
-exports.Inject = (0, exports.createDependencyAnnotation)((type, index) => ({ kind: 'inject', index, type, id: '' }));
-const InjectId = (id) => (0, exports.createDependencyAnnotation)((type, index) => ({ kind: 'inject', index, type, id }));
-exports.InjectId = InjectId;
-const InjectType = (id) => (0, exports.createDependencyAnnotation)((_type, index) => ({ kind: 'type', index, id }));
-exports.InjectType = InjectType;
-class Injector {
-    constructor(parent) {
-        this.parent = parent;
-        this.typeMappings = new Map();
-        this.classMappings = new Map();
-        this.parameterResolverArrays = new Map();
-        this.classResolvers = new Map();
-        this.typeResolvers = new Map();
-        this.singletons = new Map();
-        this.typeSingletons = new Map();
-        this.dependencyResolverExtensions = parent ? parent.dependencyResolverExtensions : new Map();
-        this.map(Injector).toValue(this);
-    }
-    createChild() {
-        return new this.constructor(this);
-    }
-    addExtensionResolver(kind, resolver) {
-        this.dependencyResolverExtensions.set(kind, resolver);
-    }
-    map(type, id = '') {
-        const mapper = new InternalClassMapper(this);
-        const idMappings = (0, exports.putIfAbsent)(this.classMappings, type, () => ({ map: new Map() }));
-        if (id === '') {
-            idMappings.def = mapper.mapping;
-        }
-        else {
-            idMappings.map.set(id, mapper.mapping);
-        }
-        return mapper;
-    }
-    mapType(id) {
-        const typeMapper = new InternalTypeMapper(this);
-        this.typeMappings.set(id, typeMapper.mapping);
-        return typeMapper;
-    }
-    getType(id) {
-        const typeResolver = this.getTypeResolver(id);
-        if (!typeResolver) {
-            throw new Error(`No Mapping for Type with id: '${String(id)}'`);
-        }
-        return typeResolver();
-    }
-    get(type, id = '') {
-        const resolver = this.getClassIdResolver(type, id);
-        if (!resolver) {
-            throw new Error(`No Mapping for Type ${type.name}` + String(id === '' ? '' : ` with id: '${String(id)}'`));
-        }
-        return resolver();
-    }
-    createInstance(type) {
-        return this.getCreateInstanceResolver(type)();
-    }
-    createResolverArray(resolverContext) {
-        const { type } = resolverContext;
-        const result = [];
-        const dependencies = Injector.dependencyMap.get(resolverContext.type);
-        if (!dependencies) {
-            return [];
-        }
-        for (const dependency of dependencies) {
-            let resolver;
-            if (isInjectDependency(dependency)) {
-                if (!dependency.type)
-                    throw new Error(`Undefined dependency type for ${type.name}. Check for circular dependency.`);
-                const classIdResolver = this.getClassIdResolver(dependency.type, dependency.id);
-                if (!classIdResolver) {
-                    throw new Error(`Could not inject ${dependency.type.name} into ${resolverContext.type.name}`);
-                }
-                resolver = classIdResolver;
-            }
-            else if (isTypeDependency(dependency)) {
-                const typeResolver = this.getTypeResolver(dependency.id);
-                if (!typeResolver) {
-                    throw new Error(`Could not inject type with id '${String(dependency.id)}' into ${resolverContext.type.name}`);
-                }
-                resolver = typeResolver;
-            }
-            else {
-                const extensionResolver = this.dependencyResolverExtensions.get(dependency.kind);
-                if (!extensionResolver) {
-                    throw new Error(`no dependency resolver for '${dependency.kind}'`);
-                }
-                resolver = extensionResolver(resolverContext, dependency);
-            }
-            result[dependency.index] = resolver;
-        }
-        return result;
-    }
-    getClassMapping(type, id) {
-        const idMapping = this.classMappings.get(type);
-        if (!idMapping) {
-            if (!this.parent)
-                return undefined;
-            return this.parent.getClassMapping(type, id);
-        }
-        const mapping = id === '' ? idMapping.def : idMapping.map.get(id);
-        if (!mapping) {
-            if (!this.parent)
-                return undefined;
-            return this.parent.getClassMapping(type, id);
-        }
-        return mapping;
-    }
-    getClassIdResolver(dependencyType, id) {
-        const getResolver = () => {
-            const mapping = this.getClassMapping(dependencyType, id);
-            if (!mapping)
-                return undefined;
-            switch (mapping.kind) {
-                case 0:
-                    return this.getCreateInstanceResolver(dependencyType);
-                case 1:
-                    const instance = mapping.value;
-                    return () => instance;
-                case 2:
-                    let singleton;
-                    const singletonContainer = (0, exports.putIfAbsent)(mapping.injector.singletons, dependencyType, () => ({ map: new Map() }));
-                    if (id === '') {
-                        if (singletonContainer.def) {
-                            singleton = singletonContainer.def;
-                        }
-                        else {
-                            singletonContainer.def = mapping.injector.createInstance(dependencyType);
-                            singleton = singletonContainer.def;
-                        }
-                    }
-                    else {
-                        singleton = (0, exports.putIfAbsent)(singletonContainer.map, id, () => mapping.injector.createInstance(dependencyType));
-                    }
-                    return () => singleton;
-                case 3:
-                    return mapping.provider;
-            }
-        };
-        const container = (0, exports.putIfAbsent)(this.classResolvers, dependencyType, () => ({
-            def: undefined,
-            map: new Map(),
-        }));
-        if (id === '') {
-            if (container.def) {
-                return container.def;
-            }
-            const resolver = getResolver();
-            container.def = resolver;
-            return resolver;
-        }
-        else {
-            return (0, exports.putIfAbsent)(container.map, id, () => getResolver());
-        }
-    }
-    getTypeResolver(id) {
-        return (0, exports.putIfAbsent)(this.typeResolvers, id, () => {
-            const mapping = this.getTypeMapping(id);
-            if (!mapping)
-                return undefined;
-            if (mapping.kind === undefined) {
-                throw new Error(`No TypeMapping for id ${String(id)}.`);
-            }
-            if (mapping.kind === 2) {
-                const instance = mapping.value;
-                return () => instance;
-            }
-            else if (mapping.kind === 0) {
-                return this.getCreateInstanceResolver(mapping.type);
-            }
-            else if (mapping.kind === 1) {
-                const instance = (0, exports.putIfAbsent)(mapping.injector.typeSingletons, id, () => mapping.injector.createInstance(mapping.type));
-                return () => instance;
-            }
-            else {
-                return mapping.provider;
-            }
-        });
-    }
-    getCreateInstanceResolver(type) {
-        const resolvers = (0, exports.putIfAbsent)(this.parameterResolverArrays, type, () => this.createResolverArray({
-            kind: 'class',
-            type: type,
-        }));
-        if (resolvers.length === 0) {
-            return () => new type();
-        }
-        const args = new Array(resolvers.length);
-        return () => {
-            for (let i = 0; i < args.length; i++) {
-                args[i] = resolvers[i]();
-            }
-            return new type(...args);
-        };
-    }
-    getTypeMapping(id) {
-        const mapping = this.typeMappings.get(id);
-        if (!mapping) {
-            if (!this.parent)
-                return undefined;
-            return this.parent.getTypeMapping(id);
-        }
-        return mapping;
-    }
-}
-exports.Injector = Injector;
-Injector.dependencyMap = new Map();
-class InternalTypeMapper {
-    constructor(injector) {
-        this.injector = injector;
-        this.mapping = { kind: undefined };
-    }
-    toClass(classValue) {
-        Object.assign(this.mapping, {
-            kind: 0,
-            type: classValue,
-        });
-    }
-    toSingleton(classValue) {
-        Object.assign(this.mapping, {
-            kind: 1,
-            type: classValue,
-            injector: this.injector,
-        });
-    }
-    toValue(value) {
-        Object.assign(this.mapping, {
-            kind: 2,
-            value: value,
-        });
-    }
-    toProvider(provider) {
-        Object.assign(this.mapping, {
-            kind: 3,
-            provider: provider,
-        });
-    }
-}
-class InternalClassMapper {
-    constructor(injector) {
-        this.injector = injector;
-        this.mapping = { kind: 0 };
-    }
-    toValue(value) {
-        Object.assign(this.mapping, {
-            kind: 1,
-            value: value,
-        });
-        return value;
-    }
-    toSingleton() {
-        Object.assign(this.mapping, {
-            kind: 2,
-            injector: this.injector,
-        });
-        this.mapping.kind = 2;
-    }
-    toProvider(provider) {
-        Object.assign(this.mapping, {
-            kind: 3,
-            provider: provider,
-        });
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injector = exports.InjectType = exports.InjectId = exports.Inject = exports.createDependencyAnnotation = exports.putIfAbsent = void 0;
+require("reflect-metadata");
+const isInjectDependency = (dep) => dep.kind === 'inject';
+const isTypeDependency = (dep) => dep.kind === 'type';
+const putIfAbsent = (map, key, value) => {
+    let v = map.get(key);
+    if (!v) {
+        v = value();
+        map.set(key, v);
+    }
+    return v;
+};
+exports.putIfAbsent = putIfAbsent;
+const createDependencyAnnotation = (cb) => (dependantType, _propertyKey, index) => {
+    const metadata = Reflect.getMetadata('design:paramtypes', dependantType);
+    const type = metadata[index];
+    if (type === dependantType) {
+        throw new Error('Could not inject class in itself.');
+    }
+    const depList = (0, exports.putIfAbsent)(Injector.dependencyMap, dependantType, () => []);
+    depList.push(cb(type, index, dependantType));
+};
+exports.createDependencyAnnotation = createDependencyAnnotation;
+exports.Inject = (0, exports.createDependencyAnnotation)((type, index) => ({ kind: 'inject', index, type, id: '' }));
+const InjectId = (id) => (0, exports.createDependencyAnnotation)((type, index) => ({ kind: 'inject', index, type, id }));
+exports.InjectId = InjectId;
+const InjectType = (id) => (0, exports.createDependencyAnnotation)((_type, index) => ({ kind: 'type', index, id }));
+exports.InjectType = InjectType;
+class Injector {
+    constructor(parent) {
+        this.parent = parent;
+        this.typeMappings = new Map();
+        this.classMappings = new Map();
+        this.parameterResolverArrays = new Map();
+        this.classResolvers = new Map();
+        this.typeResolvers = new Map();
+        this.singletons = new Map();
+        this.typeSingletons = new Map();
+        this.dependencyResolverExtensions = parent ? parent.dependencyResolverExtensions : new Map();
+        this.map(Injector).toValue(this);
+    }
+    createChild() {
+        return new this.constructor(this);
+    }
+    addExtensionResolver(kind, resolver) {
+        this.dependencyResolverExtensions.set(kind, resolver);
+    }
+    map(type, id = '') {
+        const mapper = new InternalClassMapper(this);
+        const idMappings = (0, exports.putIfAbsent)(this.classMappings, type, () => ({ map: new Map() }));
+        if (id === '') {
+            idMappings.def = mapper.mapping;
+        }
+        else {
+            idMappings.map.set(id, mapper.mapping);
+        }
+        return mapper;
+    }
+    mapType(id) {
+        const typeMapper = new InternalTypeMapper(this);
+        this.typeMappings.set(id, typeMapper.mapping);
+        return typeMapper;
+    }
+    getType(id) {
+        const typeResolver = this.getTypeResolver(id);
+        if (!typeResolver) {
+            throw new Error(`No Mapping for Type with id: '${String(id)}'`);
+        }
+        return typeResolver();
+    }
+    get(type, id = '') {
+        const resolver = this.getClassIdResolver(type, id);
+        if (!resolver) {
+            throw new Error(`No Mapping for Type ${type.name}` + String(id === '' ? '' : ` with id: '${String(id)}'`));
+        }
+        return resolver();
+    }
+    createInstance(type) {
+        return this.getCreateInstanceResolver(type)();
+    }
+    createResolverArray(resolverContext) {
+        const { type } = resolverContext;
+        const result = [];
+        const dependencies = Injector.dependencyMap.get(resolverContext.type);
+        if (!dependencies) {
+            return [];
+        }
+        for (const dependency of dependencies) {
+            let resolver;
+            if (isInjectDependency(dependency)) {
+                if (!dependency.type)
+                    throw new Error(`Undefined dependency type for ${type.name}. Check for circular dependency.`);
+                const classIdResolver = this.getClassIdResolver(dependency.type, dependency.id);
+                if (!classIdResolver) {
+                    throw new Error(`Could not inject ${dependency.type.name} into ${resolverContext.type.name}`);
+                }
+                resolver = classIdResolver;
+            }
+            else if (isTypeDependency(dependency)) {
+                const typeResolver = this.getTypeResolver(dependency.id);
+                if (!typeResolver) {
+                    throw new Error(`Could not inject type with id '${String(dependency.id)}' into ${resolverContext.type.name}`);
+                }
+                resolver = typeResolver;
+            }
+            else {
+                const extensionResolver = this.dependencyResolverExtensions.get(dependency.kind);
+                if (!extensionResolver) {
+                    throw new Error(`no dependency resolver for '${dependency.kind}'`);
+                }
+                resolver = extensionResolver(resolverContext, dependency);
+            }
+            result[dependency.index] = resolver;
+        }
+        return result;
+    }
+    getClassMapping(type, id) {
+        const idMapping = this.classMappings.get(type);
+        if (!idMapping) {
+            if (!this.parent)
+                return undefined;
+            return this.parent.getClassMapping(type, id);
+        }
+        const mapping = id === '' ? idMapping.def : idMapping.map.get(id);
+        if (!mapping) {
+            if (!this.parent)
+                return undefined;
+            return this.parent.getClassMapping(type, id);
+        }
+        return mapping;
+    }
+    getClassIdResolver(dependencyType, id) {
+        const getResolver = () => {
+            const mapping = this.getClassMapping(dependencyType, id);
+            if (!mapping)
+                return undefined;
+            switch (mapping.kind) {
+                case 0:
+                    return this.getCreateInstanceResolver(dependencyType);
+                case 1:
+                    const instance = mapping.value;
+                    return () => instance;
+                case 2:
+                    let singleton;
+                    const singletonContainer = (0, exports.putIfAbsent)(mapping.injector.singletons, dependencyType, () => ({ map: new Map() }));
+                    if (id === '') {
+                        if (singletonContainer.def) {
+                            singleton = singletonContainer.def;
+                        }
+                        else {
+                            singletonContainer.def = mapping.injector.createInstance(dependencyType);
+                            singleton = singletonContainer.def;
+                        }
+                    }
+                    else {
+                        singleton = (0, exports.putIfAbsent)(singletonContainer.map, id, () => mapping.injector.createInstance(dependencyType));
+                    }
+                    return () => singleton;
+                case 3:
+                    return mapping.provider;
+            }
+        };
+        const container = (0, exports.putIfAbsent)(this.classResolvers, dependencyType, () => ({
+            def: undefined,
+            map: new Map(),
+        }));
+        if (id === '') {
+            if (container.def) {
+                return container.def;
+            }
+            const resolver = getResolver();
+            container.def = resolver;
+            return resolver;
+        }
+        else {
+            return (0, exports.putIfAbsent)(container.map, id, () => getResolver());
+        }
+    }
+    getTypeResolver(id) {
+        return (0, exports.putIfAbsent)(this.typeResolvers, id, () => {
+            const mapping = this.getTypeMapping(id);
+            if (!mapping)
+                return undefined;
+            if (mapping.kind === undefined) {
+                throw new Error(`No TypeMapping for id ${String(id)}.`);
+            }
+            if (mapping.kind === 2) {
+                const instance = mapping.value;
+                return () => instance;
+            }
+            else if (mapping.kind === 0) {
+                return this.getCreateInstanceResolver(mapping.type);
+            }
+            else if (mapping.kind === 1) {
+                const instance = (0, exports.putIfAbsent)(mapping.injector.typeSingletons, id, () => mapping.injector.createInstance(mapping.type));
+                return () => instance;
+            }
+            else {
+                return mapping.provider;
+            }
+        });
+    }
+    getCreateInstanceResolver(type) {
+        const resolvers = (0, exports.putIfAbsent)(this.parameterResolverArrays, type, () => this.createResolverArray({
+            kind: 'class',
+            type: type,
+        }));
+        if (resolvers.length === 0) {
+            return () => new type();
+        }
+        const args = new Array(resolvers.length);
+        return () => {
+            for (let i = 0; i < args.length; i++) {
+                args[i] = resolvers[i]();
+            }
+            return new type(...args);
+        };
+    }
+    getTypeMapping(id) {
+        const mapping = this.typeMappings.get(id);
+        if (!mapping) {
+            if (!this.parent)
+                return undefined;
+            return this.parent.getTypeMapping(id);
+        }
+        return mapping;
+    }
+}
+exports.Injector = Injector;
+Injector.dependencyMap = new Map();
+class InternalTypeMapper {
+    constructor(injector) {
+        this.injector = injector;
+        this.mapping = { kind: undefined };
+    }
+    toClass(classValue) {
+        Object.assign(this.mapping, {
+            kind: 0,
+            type: classValue,
+        });
+    }
+    toSingleton(classValue) {
+        Object.assign(this.mapping, {
+            kind: 1,
+            type: classValue,
+            injector: this.injector,
+        });
+    }
+    toValue(value) {
+        Object.assign(this.mapping, {
+            kind: 2,
+            value: value,
+        });
+    }
+    toProvider(provider) {
+        Object.assign(this.mapping, {
+            kind: 3,
+            provider: provider,
+        });
+    }
+}
+class InternalClassMapper {
+    constructor(injector) {
+        this.injector = injector;
+        this.mapping = { kind: 0 };
+    }
+    toValue(value) {
+        Object.assign(this.mapping, {
+            kind: 1,
+            value: value,
+        });
+        return value;
+    }
+    toSingleton() {
+        Object.assign(this.mapping, {
+            kind: 2,
+            injector: this.injector,
+        });
+        this.mapping.kind = 2;
+    }
+    toProvider(provider) {
+        Object.assign(this.mapping, {
+            kind: 3,
+            provider: provider,
+        });
+    }
+}
 //# sourceMappingURL=injector.js.map