@antv/g-webgpu-core/es/inversify.config.js

/**
 * Root Container
 * @see /dev-docs/IoC 容器、依赖注入与服务说明.md
 */
import 'reflect-metadata';
import { Container } from 'inversify';
import getDecorators from 'inversify-inject-decorators';
import { ComponentManager } from './ComponentManager';
import { CameraComponent } from './components/camera/CameraComponent';
import { CameraSystem } from './components/camera/System';
import { ComputeComponent } from './components/compute/ComputeComponent';
import { LayoutComputeStrategy } from './components/compute/LayoutComputeStrategy';
import { ParticleComputeStrategy } from './components/compute/ParticleComputeStrategy';
import { ComputeSystem } from './components/compute/System';
import { PassNodeComponent } from './components/framegraph/PassNodeComponent';
import { ResourceHandleComponent } from './components/framegraph/ResourceHandleComponent';
import { FrameGraphSystem } from './components/framegraph/System';
import { GeometryComponent } from './components/geometry/GeometryComponent';
import { GeometrySystem } from './components/geometry/System';
import { InteractionSystem } from './components/interaction/System';
import { MaterialComponent } from './components/material/MaterialComponent';
import { MaterialSystem } from './components/material/System';
import { CullableComponent } from './components/mesh/CullableComponent';
import { MeshComponent } from './components/mesh/MeshComponent';
import { MeshSystem } from './components/mesh/System';
import { ForwardRenderPath } from './components/renderpath/Forward';
import { SceneComponent } from './components/scene/SceneComponent';
import { SceneSystem } from './components/scene/System';
import { HierarchyComponent } from './components/scenegraph/HierarchyComponent';
import { NameComponent } from './components/scenegraph/NameComponent';
import { SceneGraphSystem } from './components/scenegraph/System';
import { TransformComponent } from './components/scenegraph/TransformComponent';
import { IDENTIFIER } from './identifier';
// @see https://github.com/inversify/InversifyJS/blob/master/wiki/container_api.md#defaultscope
export var container = new Container(); // 支持使用 new 而非容器实例化的场景，同时禁止 lazyInject cache
// @see https://github.com/inversify/inversify-inject-decorators#caching-vs-non-caching-behaviour

var DECORATORS = getDecorators(container, false);
// Add babel legacy decorators support
// @see https://github.com/inversify/InversifyJS/issues/1050
// @see https://github.com/inversify/InversifyJS/issues/1026#issuecomment-504936034
export var lazyInject = function lazyInject(serviceIdentifier) {
  var original = DECORATORS.lazyInject(serviceIdentifier); // the 'descriptor' parameter is actually always defined for class fields for Babel, but is considered undefined for TSC
  // so we just hack it with ?/! combination to avoid "TS1240: Unable to resolve signature of property decorator when called as an expression"

  return function (proto, key, descriptor) {
    // make it work as usual
    original.call(this, proto, key); // return link to proto, so own value wont be 'undefined' after component's creation

    if (descriptor) {
      descriptor.initializer = function () {
        return proto[key];
      };
    }
  };
};
export var lazyMultiInject = function lazyMultiInject(serviceIdentifier) {
  var original = DECORATORS.lazyMultiInject(serviceIdentifier); // the 'descriptor' parameter is actually always defined for class fields for Babel, but is considered undefined for TSC
  // so we just hack it with ?/! combination to avoid "TS1240: Unable to resolve signature of property decorator when called as an expression"

  return function (proto, key, descriptor) {
    // make it work as usual
    original.call(this, proto, key);

    if (descriptor) {
      // return link to proto, so own value wont be 'undefined' after component's creation
      descriptor.initializer = function () {
        return proto[key];
      };
    }
  };
};
/**
 * bind global component managers in root container
 */

container.bind(IDENTIFIER.NameComponentManager).toConstantValue(new ComponentManager(NameComponent));
container.bind(IDENTIFIER.HierarchyComponentManager).toConstantValue(new ComponentManager(HierarchyComponent));
container.bind(IDENTIFIER.TransformComponentManager).toConstantValue(new ComponentManager(TransformComponent));
container.bind(IDENTIFIER.CameraComponentManager).toConstantValue(new ComponentManager(CameraComponent));
container.bind(IDENTIFIER.ResourceHandleComponentManager).toConstantValue(new ComponentManager(ResourceHandleComponent));
container.bind(IDENTIFIER.PassNodeComponentManager).toConstantValue(new ComponentManager(PassNodeComponent));
container.bind(IDENTIFIER.MeshComponentManager).toConstantValue(new ComponentManager(MeshComponent));
container.bind(IDENTIFIER.CullableComponentManager).toConstantValue(new ComponentManager(CullableComponent));
container.bind(IDENTIFIER.GeometryComponentManager).toConstantValue(new ComponentManager(GeometryComponent));
container.bind(IDENTIFIER.MaterialComponentManager).toConstantValue(new ComponentManager(MaterialComponent));
container.bind(IDENTIFIER.SceneComponentManager).toConstantValue(new ComponentManager(SceneComponent));
container.bind(IDENTIFIER.ComputeComponentManager).toConstantValue(new ComponentManager(ComputeComponent));
/**
 * bind systems
 */

container.bind(IDENTIFIER.Systems).to(SceneGraphSystem).whenTargetNamed(IDENTIFIER.SceneGraphSystem);
container.bind(IDENTIFIER.Systems).to(SceneSystem).whenTargetNamed(IDENTIFIER.SceneSystem);
container.bind(IDENTIFIER.Systems).to(CameraSystem).whenTargetNamed(IDENTIFIER.CameraSystem);
container.bind(IDENTIFIER.Systems).to(FrameGraphSystem).whenTargetNamed(IDENTIFIER.FrameGraphSystem);
container.bind(IDENTIFIER.Systems).to(MeshSystem).whenTargetNamed(IDENTIFIER.MeshSystem);
container.bind(IDENTIFIER.Systems).to(GeometrySystem).whenTargetNamed(IDENTIFIER.GeometrySystem);
container.bind(IDENTIFIER.Systems).to(MaterialSystem).whenTargetNamed(IDENTIFIER.MaterialSystem);
container.bind(IDENTIFIER.Systems).to(InteractionSystem).whenTargetNamed(IDENTIFIER.InteractionSystem);
container.bind(IDENTIFIER.Systems).to(ComputeSystem).whenTargetNamed(IDENTIFIER.ComputeSystem);
container.bind(IDENTIFIER.ForwardRenderPath).to(ForwardRenderPath).inSingletonScope();
/**
 * bind compute strategy
 */

container.bind(IDENTIFIER.ComputeStrategy).to(ParticleComputeStrategy).whenTargetNamed('particle');
container.bind(IDENTIFIER.ComputeStrategy).to(LayoutComputeStrategy).whenTargetNamed('layout');
//# sourceMappingURL=inversify.config.js.map