awv3/dist/session/index.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = undefined;

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _from = require('babel-runtime/core-js/array/from');

var _from2 = _interopRequireDefault(_from);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _extends3 = require('babel-runtime/helpers/extends');

var _extends4 = _interopRequireDefault(_extends3);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var observeActiveConnection = function () {
    var _ref7 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4(id, previous) {
        var activeConnection;
        return _regenerator2.default.wrap(function _callee4$(_context4) {
            while (1) {
                switch (_context4.prev = _context4.next) {
                    case 0:
                        if (previous) this.pool.removeAsync(_connections.base.references[previous].pool);

                        if (!id) {
                            _context4.next = 8;
                            break;
                        }

                        activeConnection = _connections.base.references[id];
                        _context4.next = 5;
                        return this.pool.addAsync(activeConnection.pool);

                    case 5:
                        _context4.next = 7;
                        return this.pool.viewFound();

                    case 7:
                        this.pool.view.updateBounds();

                    case 8:
                    case 'end':
                        return _context4.stop();
                }
            }
        }, _callee4, this);
    }));

    return function observeActiveConnection(_x6, _x7) {
        return _ref7.apply(this, arguments);
    };
}();

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

var _redux = require('redux');

var _reduxThunk = require('redux-thunk');

var _reduxThunk2 = _interopRequireDefault(_reduxThunk);

var _element = require('./element');

var _element2 = _interopRequireDefault(_element);

var _index = require('./store/index.js');

var _globals = require('./store/globals');

var _elements = require('./store/elements');

var _connections = require('./store/connections');

var _plugins = require('./store/plugins');

var _helpers = require('./helpers');

var _selector = require('./selection/selector');

var _selector2 = _interopRequireDefault(_selector);

var _connection = require('./connection');

var _connection2 = _interopRequireDefault(_connection);

var _defaults = require('../core/defaults');

var _defaults2 = _interopRequireDefault(_defaults);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Session = function () {
    function Session() {
        var _this = this;

        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        (0, _classCallCheck3.default)(this, Session);


        this.options = (0, _extends4.default)({

            throttle: 200,
            updateMaterials: false,
            centerGeometry: false,
            pool: _helpers.Pool,
            objectPrototype: _helpers.ObjectPrototype

        }, _defaults2.default.all, options);

        var composeEnhancers = this.options.debug && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : _redux.compose;
        this.store = options.store || (0, _redux.createStore)(_index.reducer, composeEnhancers((0, _redux.applyMiddleware)(_reduxThunk2.default /*, logger*/)));

        // Support hot reloading reducers
        if (process.env.NODE_ENV !== 'production' && !options.store && module.hot) {
            module.hot.accept(['./store/globals', './store/plugins', './store/elements', './store/connections', './store/index'], function () {
                return _this.store.replaceReducer(require('./store/index.js').reducer);
            });
        }

        this.pool = new _helpers.Pool({ session: this, name: 'session.pool' });
        this.defaultFeaturePlugin;
        this.featurePlugins = {};
        this.materials = {};
        this.layerNames = [];
        this.observe = (0, _helpers.createObserver)(this.store, this.getState.bind(this));
        this.selector = new _selector2.default(this, options);

        // Global observers
        this.observe(function (state) {
            return state.globals.activeConnection;
        }, observeActiveConnection.bind(this));

        options.resources && this.addResources(options.resources);
        options.featurePlugins && this.registerFeaturePlugins(options.featurePlugins);
        options.defaultFeaturePlugin && this.registerDefaultFeaturePlugins(options.defaultFeaturePlugin);

        // Add a global keylistener that will forward events to a plugins console
        var keydownEventHandler = keydownEvent.bind(this);
        document.addEventListener('keydown', keydownEventHandler);

        // Link view
        if (this.options.view) {
            this.view = this.options.view;
            this.view.scene.add(this.pool);
        } else {
            this.pool.viewFound().then(function (view) {
                return _this.view = view;
            });
        }

        // Add default connection for convenience
        if (this.options.defaultConnection) {
            var connection = this.addConnection('default');
            if (this.options.url && this.options.protocol) connection.on('connected', function (connection) {
                return _this.options.defaultConnection(connection);
            });else this.options.defaultConnection(connection);
        }

        this.observe(function (state) {
            return state.globals.camera;
        }, function (state) {
            return _this.view.camera.orthographic = state === 'orthographic';
        });
    }

    (0, _createClass3.default)(Session, [{
        key: 'showLayer',
        value: function showLayer() {
            var _this2 = this;

            var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

            this.layerNames = Array.isArray(args) ? args : [args];
            this.pool.traverse(function (obj) {
                if (obj.material) {
                    var isMultiMaterial = Array.isArray(obj.material);
                    if (isMultiMaterial) {
                        obj.material.forEach(function (mat) {
                            return mat.visible = mat.meta ? _this2.layerNames.length == 0 || _this2.layerNames.indexOf(mat.meta.layer) > -1 : mat.visible;
                        });
                    } else if (obj.material.meta) {
                        obj.material.visible = _this2.layerNames.length == 0 || _this2.layerNames.indexOf(obj.material.meta.layer) > -1;
                    }
                }
            });
            this.pool.view.invalidate();
        }
    }, {
        key: 'isVisibleLayer',
        value: function isVisibleLayer(layerName) {
            if (this.layerNames.length === 0 || this.layerNames.indexOf(layerName) > -1) return true;
            return false;
        }
    }, {
        key: 'getState',
        value: function getState() {
            return this.store.getState() || {};
        }
    }, {
        key: 'dispatch',
        value: function dispatch(action) {
            return this.store.dispatch(action);
        }
    }, {
        key: 'registerDefaultFeaturePlugin',
        value: function registerDefaultFeaturePlugin(prototype) {
            this.defaultFeaturePlugin = prototype;
        }
    }, {
        key: 'registerFeaturePlugins',
        value: function registerFeaturePlugins(map) {
            this.featurePlugins = (0, _extends4.default)({}, this.featurePlugins, map);
        }
    }, {
        key: 'resolveFeaturePlugin',
        value: function () {
            var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(promise) {
                for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                    args[_key - 1] = arguments[_key];
                }

                var _ref2, plugin;

                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                _context.next = 2;
                                return promise;

                            case 2:
                                _ref2 = _context.sent;
                                plugin = _ref2.default;

                                this.registerFeaturePlugins(args.reduce(function (prev, key) {
                                    return (0, _extends4.default)({}, prev, (0, _defineProperty3.default)({}, key, plugin));
                                }, {}));

                            case 5:
                            case 'end':
                                return _context.stop();
                        }
                    }
                }, _callee, this);
            }));

            function resolveFeaturePlugin(_x3) {
                return _ref.apply(this, arguments);
            }

            return resolveFeaturePlugin;
        }()
    }, {
        key: 'resolveDefaultFeaturePlugin',
        value: function () {
            var _ref3 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(promise) {
                var _ref4, Plugin;

                return _regenerator2.default.wrap(function _callee2$(_context2) {
                    while (1) {
                        switch (_context2.prev = _context2.next) {
                            case 0:
                                _context2.next = 2;
                                return promise;

                            case 2:
                                _ref4 = _context2.sent;
                                Plugin = _ref4.default;

                                this.registerDefaultFeaturePlugin(Plugin);

                            case 5:
                            case 'end':
                                return _context2.stop();
                        }
                    }
                }, _callee2, this);
            }));

            function resolveDefaultFeaturePlugin(_x4) {
                return _ref3.apply(this, arguments);
            }

            return resolveDefaultFeaturePlugin;
        }()
    }, {
        key: 'resolveGlobalPlugins',
        value: function () {
            var _ref5 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3() {
                for (var _len2 = arguments.length, promises = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                    promises[_key2] = arguments[_key2];
                }

                var plugins;
                return _regenerator2.default.wrap(function _callee3$(_context3) {
                    while (1) {
                        switch (_context3.prev = _context3.next) {
                            case 0:
                                _context3.next = 2;
                                return _promise2.default.all(promises);

                            case 2:
                                _context3.t0 = function (_ref6) {
                                    var Plugin = _ref6.default;
                                    return new Plugin(session).id;
                                };

                                plugins = _context3.sent.map(_context3.t0);

                                session.dispatch(_globals.actions.linkPlugins(plugins));

                            case 5:
                            case 'end':
                                return _context3.stop();
                        }
                    }
                }, _callee3, this);
            }));

            function resolveGlobalPlugins() {
                return _ref5.apply(this, arguments);
            }

            return resolveGlobalPlugins;
        }()
    }, {
        key: 'findFeaturePlugin',
        value: function findFeaturePlugin(id) {
            return this.featurePlugins.find(function (item) {
                return item.id === id;
            });
        }
    }, {
        key: 'addResources',
        value: function addResources(map) {
            this.dispatch(_globals.actions.addResources(map));
        }
    }, {
        key: 'addConnection',
        value: function addConnection(name) {
            var connection = new _connection2.default(this, { name: name });
            this.store.dispatch(_globals.actions.setActiveConnection(connection.id));
            return connection;
        }
    }, {
        key: 'resolveResource',
        value: function resolveResource(name, plugin) {
            var resource = void 0;
            var scope = this.plugins[plugin];
            if (scope) resource = scope.resources[name];
            if (!resource) resource = this.globals.resources[name];
            return resource;
        }
    }, {
        key: 'resolveTree',
        value: function resolveTree(args) {
            var id = this.globals.activeConnection;
            var connection = _connections.base.references[id];
            return connection.resolveTree(args);
        }
    }, {
        key: 'printSceneGraph',
        value: function printSceneGraph() {
            var count = 1;
            var traverse = function traverse(obj) {
                var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

                if (obj) {
                    obj.children.forEach(function (item) {
                        console.log(count++ + ':\t' + (0, _from2.default)(new Array(level)).fill(' ').join('') + item.type + (item.name ? '_' + item.name : ''));
                        traverse(item, level + 2);
                    });
                }
            };
            traverse(this.scene);
        }
    }, {
        key: 'scene',
        get: function get() {
            return this.pool.scene;
        }
    }, {
        key: 'state',
        get: function get() {
            return this.getState();
        }
    }, {
        key: 'globals',
        get: function get() {
            return this.state.globals;
        }
    }, {
        key: 'plugins',
        get: function get() {
            return this.state.plugins;
        }
    }, {
        key: 'elements',
        get: function get() {
            return this.state.elements;
        }
    }, {
        key: 'connections',
        get: function get() {
            return this.state.connections;
        }
    }, {
        key: 'collections',
        get: function get() {
            return this.state.collections;
        }

        // Computed props

    }, {
        key: 'activeConnection',
        get: function get() {
            return this.state.connections[this.state.globals.activeConnection];
        }
    }, {
        key: 'activePlugin',
        get: function get() {
            var _this3 = this;

            return this.plugins[this.activeConnection.plugins.find(function (item) {
                return _this3.plugins[item].feature === _this3.activeConnection.activeFeature;
            })];
        }
    }, {
        key: 'tree',
        get: function get() {
            return this.activeConnection.tree;
        }
    }, {
        key: 'activeConnectionClass',
        get: function get() {
            return _connections.base.references[this.globals.activeConnection];
        }
    }, {
        key: 'activePluginClass',
        get: function get() {
            return _plugins.base.references[this.activePlugin.id];
        }
    }]);
    return Session;
}();

exports.default = Session;


function checkElements(session, elements) {
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
        for (var _iterator = (0, _getIterator3.default)(elements), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            var key = _step.value;

            var element = session.elements[key];
            if (element.type === _element2.default.Type.Console) {
                session.store.dispatch(_elements.actions.update(element.id, { focus: true }));
                session.store.dispatch(_elements.actions.event(element.id, event));
                return true;
            } else if (element.type === _element2.default.Type.Group && checkElements(session, element.children)) {
                return true;
            }
        }
    } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
    } finally {
        try {
            if (!_iteratorNormalCompletion && _iterator.return) {
                _iterator.return();
            }
        } finally {
            if (_didIteratorError) {
                throw _iteratorError;
            }
        }
    }

    return false;
}

function keydownEvent(event) {
    var target = event.target;
    if (!(target instanceof HTMLInputElement)) {
        for (var key in this.plugins) {
            var plugin = this.plugins[key];
            if (plugin.enabled && !plugin.collapsed && checkElements(this, plugin.elements)) {
                return;
            }
        }
    }
}