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

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.lazyMultiInject = exports.lazyInject = exports.container = void 0;

require("reflect-metadata");

var _inversify = require("inversify");

var _inversifyInjectDecorators = _interopRequireDefault(require("inversify-inject-decorators"));

var _ComponentManager = require("./ComponentManager");

var _CameraComponent = require("./components/camera/CameraComponent");

var _System = require("./components/camera/System");

var _ComputeComponent = require("./components/compute/ComputeComponent");

var _LayoutComputeStrategy = require("./components/compute/LayoutComputeStrategy");

var _ParticleComputeStrategy = require("./components/compute/ParticleComputeStrategy");

var _System2 = require("./components/compute/System");

var _PassNodeComponent = require("./components/framegraph/PassNodeComponent");

var _ResourceHandleComponent = require("./components/framegraph/ResourceHandleComponent");

var _System3 = require("./components/framegraph/System");

var _GeometryComponent = require("./components/geometry/GeometryComponent");

var _System4 = require("./components/geometry/System");

var _System5 = require("./components/interaction/System");

var _MaterialComponent = require("./components/material/MaterialComponent");

var _System6 = require("./components/material/System");

var _CullableComponent = require("./components/mesh/CullableComponent");

var _MeshComponent = require("./components/mesh/MeshComponent");

var _System7 = require("./components/mesh/System");

var _Forward = require("./components/renderpath/Forward");

var _SceneComponent = require("./components/scene/SceneComponent");

var _System8 = require("./components/scene/System");

var _HierarchyComponent = require("./components/scenegraph/HierarchyComponent");

var _NameComponent = require("./components/scenegraph/NameComponent");

var _System9 = require("./components/scenegraph/System");

var _TransformComponent = require("./components/scenegraph/TransformComponent");

var _identifier = require("./identifier");

/**
 * Root Container
 * @see /dev-docs/IoC 容器、依赖注入与服务说明.md
 */
// @see https://github.com/inversify/InversifyJS/blob/master/wiki/container_api.md#defaultscope
var container = new _inversify.Container(); // 支持使用 new 而非容器实例化的场景，同时禁止 lazyInject cache
// @see https://github.com/inversify/inversify-inject-decorators#caching-vs-non-caching-behaviour

exports.container = container;
var DECORATORS = (0, _inversifyInjectDecorators.default)(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
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];
      };
    }
  };
};

exports.lazyInject = lazyInject;

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
 */


exports.lazyMultiInject = lazyMultiInject;
container.bind(_identifier.IDENTIFIER.NameComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_NameComponent.NameComponent));
container.bind(_identifier.IDENTIFIER.HierarchyComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_HierarchyComponent.HierarchyComponent));
container.bind(_identifier.IDENTIFIER.TransformComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_TransformComponent.TransformComponent));
container.bind(_identifier.IDENTIFIER.CameraComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_CameraComponent.CameraComponent));
container.bind(_identifier.IDENTIFIER.ResourceHandleComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_ResourceHandleComponent.ResourceHandleComponent));
container.bind(_identifier.IDENTIFIER.PassNodeComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_PassNodeComponent.PassNodeComponent));
container.bind(_identifier.IDENTIFIER.MeshComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_MeshComponent.MeshComponent));
container.bind(_identifier.IDENTIFIER.CullableComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_CullableComponent.CullableComponent));
container.bind(_identifier.IDENTIFIER.GeometryComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_GeometryComponent.GeometryComponent));
container.bind(_identifier.IDENTIFIER.MaterialComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_MaterialComponent.MaterialComponent));
container.bind(_identifier.IDENTIFIER.SceneComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_SceneComponent.SceneComponent));
container.bind(_identifier.IDENTIFIER.ComputeComponentManager).toConstantValue(new _ComponentManager.ComponentManager(_ComputeComponent.ComputeComponent));
/**
 * bind systems
 */

container.bind(_identifier.IDENTIFIER.Systems).to(_System9.SceneGraphSystem).whenTargetNamed(_identifier.IDENTIFIER.SceneGraphSystem);
container.bind(_identifier.IDENTIFIER.Systems).to(_System8.SceneSystem).whenTargetNamed(_identifier.IDENTIFIER.SceneSystem);
container.bind(_identifier.IDENTIFIER.Systems).to(_System.CameraSystem).whenTargetNamed(_identifier.IDENTIFIER.CameraSystem);
container.bind(_identifier.IDENTIFIER.Systems).to(_System3.FrameGraphSystem).whenTargetNamed(_identifier.IDENTIFIER.FrameGraphSystem);
container.bind(_identifier.IDENTIFIER.Systems).to(_System7.MeshSystem).whenTargetNamed(_identifier.IDENTIFIER.MeshSystem);
container.bind(_identifier.IDENTIFIER.Systems).to(_System4.GeometrySystem).whenTargetNamed(_identifier.IDENTIFIER.GeometrySystem);
container.bind(_identifier.IDENTIFIER.Systems).to(_System6.MaterialSystem).whenTargetNamed(_identifier.IDENTIFIER.MaterialSystem);
container.bind(_identifier.IDENTIFIER.Systems).to(_System5.InteractionSystem).whenTargetNamed(_identifier.IDENTIFIER.InteractionSystem);
container.bind(_identifier.IDENTIFIER.Systems).to(_System2.ComputeSystem).whenTargetNamed(_identifier.IDENTIFIER.ComputeSystem);
container.bind(_identifier.IDENTIFIER.ForwardRenderPath).to(_Forward.ForwardRenderPath).inSingletonScope();
/**
 * bind compute strategy
 */

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