awv3/session/connection.js

⚡ AWV3 embedded CAD

'use strict';

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

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

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

var _extends3 = _interopRequireDefault(_extends2);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _values = require('babel-runtime/core-js/object/values');

var _values2 = _interopRequireDefault(_values);

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

var _promise2 = _interopRequireDefault(_promise);

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

var _regenerator2 = _interopRequireDefault(_regenerator);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

var _memoize = require('lodash/memoize');

var _memoize2 = _interopRequireDefault(_memoize);

var _cloneDeep = require('lodash/cloneDeep');

var _cloneDeep2 = _interopRequireDefault(_cloneDeep);

var _lifecycle = require('./lifecycle.js');

var _lifecycle2 = _interopRequireDefault(_lifecycle);

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

var _store = require('./store/');

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

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

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

var _base = require('../communication/base');

var _base2 = _interopRequireDefault(_base);

var _error = require('../core/error');

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 }; }

function observe(id, parent) {

    var tree = this.getState().tree;
    var object = tree[id];

    switch (object.class) {
        case "CC_Assembly":
            console.log("observing", object.name);
            return observeAssembly.bind(this)(id, parent);

        case "CC_Part":
            observeFeatures.bind(this)(id, parent);
            return observePart.bind(this)(id, parent);
    }
}

function observeAssembly(root) {
    var _this = this;

    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.pool;


    var instances = {};
    var container = new this.session.options.objectPrototype({ session: this.session });
    parent.addAsync(container);

    this.observe(
    // selector
    function (state) {
        return (state.tree[root] || {}).instances || [];
    },
    // onChange
    function () {
        var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee() {
            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
                args[_key] = arguments[_key];
            }

            var tree;
            return _regenerator2.default.wrap(function _callee$(_context) {
                while (1) {
                    switch (_context.prev = _context.next) {
                        case 0:
                            tree = _this.tree;
                            _context.next = 3;
                            return _helpers.arrayDiff.apply(undefined, args.concat([function (newItems) {
                                return newItems.forEach(function (item) {
                                    var instance = tree[item];
                                    var csys = instance.coordinateSystem;
                                    console.log("  observing instance", instance.name, (0, _stringify2.default)(csys[0]));
                                    var object = instances[item] = observe.bind(_this)(instance.link, container);
                                    object.name = instance.name;
                                    object.matrixAutoUpdate = false;
                                    object.matrix = new THREE.Matrix4().makeBasis(new (Function.prototype.bind.apply(THREE.Vector3, [null].concat((0, _toConsumableArray3.default)(csys[1]))))(), new (Function.prototype.bind.apply(THREE.Vector3, [null].concat((0, _toConsumableArray3.default)(csys[2]))))(), new (Function.prototype.bind.apply(THREE.Vector3, [null].concat((0, _toConsumableArray3.default)(csys[3]))))()).setPosition(new (Function.prototype.bind.apply(THREE.Vector3, [null].concat((0, _toConsumableArray3.default)(csys[0]))))());
                                    return;
                                });
                            }, function (deletedItems) {
                                return deletedItems.forEach(function (item) {
                                    var instance = instances[item];
                                    delete instances[item];
                                    return instance.destroyAsync();
                                });
                            }]));

                        case 3:

                            tree.root === root && _this.pool.update();

                        case 4:
                        case 'end':
                            return _context.stop();
                    }
                }
            }, _callee, _this);
        }));

        return function () {
            return _ref.apply(this, arguments);
        };
    }(),
    // options
    {
        onRemove: function () {
            var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2() {
                return _regenerator2.default.wrap(function _callee2$(_context2) {
                    while (1) {
                        switch (_context2.prev = _context2.next) {
                            case 0:
                                _context2.next = 2;
                                return _promise2.default.all((0, _values2.default)(instances).map(function (item) {
                                    return item.destroyAsync();
                                }));

                            case 2:
                                instances = {};
                                _context2.next = 5;
                                return container.destroyAsync();

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

            return function onRemove() {
                return _ref2.apply(this, arguments);
            };
        }(), fireOnStart: true, unsubscribeOnUndefined: true
    });

    return container;
}

function observePart(root) {
    var _this2 = this;

    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.pool;


    var solids = {};
    var container = new this.session.options.objectPrototype({ session: this.session });
    parent.addAsync(container);

    this.observe(
    // selector
    function (state) {
        return (state.tree[root] || {}).solids || [];
    },
    // onChange
    function () {
        var _ref3 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3() {
            for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                args[_key2] = arguments[_key2];
            }

            var tree;
            return _regenerator2.default.wrap(function _callee3$(_context3) {
                while (1) {
                    switch (_context3.prev = _context3.next) {
                        case 0:
                            _context3.next = 2;
                            return _helpers.arrayDiff.apply(undefined, args.concat([function (newItems) {
                                return newItems.map(function (item) {
                                    var solid = solids[item] = _this2.primitives[item].clone();
                                    return container.addAsync(solid);
                                });
                            }, function (deletedItems) {
                                return deletedItems.map(function (item) {
                                    var solid = solids[item];
                                    delete solids[item];
                                    return solid.destroyAsync();
                                });
                            }]));

                        case 2:
                            tree = _this2.tree;

                            tree.root === root && _this2.pool.update();

                        case 4:
                        case 'end':
                            return _context3.stop();
                    }
                }
            }, _callee3, _this2);
        }));

        return function () {
            return _ref3.apply(this, arguments);
        };
    }(),
    // options
    {
        onRemove: function () {
            var _ref4 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4() {
                return _regenerator2.default.wrap(function _callee4$(_context4) {
                    while (1) {
                        switch (_context4.prev = _context4.next) {
                            case 0:
                                _context4.next = 2;
                                return _promise2.default.all((0, _values2.default)(solids).map(function (item) {
                                    return item.destroyAsync();
                                }));

                            case 2:
                                solids = {};
                                _context4.next = 5;
                                return container.destroyAsync();

                            case 5:
                            case 'end':
                                return _context4.stop();
                        }
                    }
                }, _callee4, _this2);
            }));

            return function onRemove() {
                return _ref4.apply(this, arguments);
            };
        }(),
        fireOnStart: true, unsubscribeOnUndefined: true
    });

    return container;
}

function observeFeatures(root) {
    var _this3 = this;

    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.pool;

    return this.observe(
    // selector
    function (state) {
        return (state.tree[root] || {}).features || [];
    },
    // onChange
    function () {
        for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
            args[_key3] = arguments[_key3];
        }

        _helpers.arrayDiff.apply(undefined, args.concat([function (newItems) {
            var items = newItems.map(function (id) {
                var feature = _this3.tree[id];
                var type = feature.class;
                var pluginPrototype = _this3.session.prototypes[type];
                if (!pluginPrototype && _this3.session.defaultPrototype) pluginPrototype = _this3.session.defaultPrototype;
                if (pluginPrototype) {

                    // If activeSelection is on we must reset it
                    _this3.session.globals.activeSelection && _this3.store.dispatch(_globals.actions.setActiveSelection());

                    // Each plugin gets a distinct pool to draw into
                    var pool = new THREE.Object3D();
                    pool.updateParentMaterials = false;
                    pool.measurable = false;
                    pool.name = feature.name;
                    _this3.pool.temporary.add(pool);

                    // Intanciate and link new plugin
                    var plugin = new pluginPrototype(_this3.session, { name: feature.name, feature: feature, pool: pool, connection: _this3 });
                    _this3.featurePlugins[id] = plugin;
                    return plugin.id;
                }
            });

            // Flush store and link plugins
            _this3.store.dispatch(_connections.actions.linkPlugins(_this3.id, items));
        }, function (deletedItems) {
            return deletedItems.forEach(function (id) {
                // Find real plugin class
                var plugin = _this3.featurePlugins[id];
                if (plugin) {
                    _this3.pool.temporary.remove(plugin.pool);
                    _this3.store.dispatch(_plugins.actions.unregister(plugin.id));
                    delete _this3.featurePlugins[id];
                }
            });
        }]));
    },
    // options
    { fireOnStart: true, unsubscribeOnUndefined: true });
}

/**
 * @class Connection manages a local or remote connection to a running ClassCAD instances.
   ClassCAD will then drive the tree-state and cause visual actions, models, meshes, movement, etc.
   In theory a ClassCAD instance is not needed, results could be fed statically using parse or stream.
 */

var Connection = function (_Lifecycle) {
    (0, _inherits3.default)(Connection, _Lifecycle);

    function Connection() {
        var session = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (0, _error.halt)("connection must be initialized with a session");
        var props = arguments[1];
        (0, _classCallCheck3.default)(this, Connection);

        var _this4 = (0, _possibleConstructorReturn3.default)(this, (Connection.__proto__ || (0, _getPrototypeOf2.default)(Connection)).call(this, session, _connections.actions, function (state) {
            return state.connections[_this4.id];
        }, (0, _extends3.default)({
            name: "Part"
        }, props, {
            connected: false,
            activeFeature: undefined,
            messages: [],
            plugins: [],
            tree: {
                root: 1
            }
        })));

        _this4._get = (0, _memoize2.default)(function (key) {
            var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _this4.getState().tree;

            if (_this4.store) {
                var obj = state[key];
                if (obj) {
                    obj = (0, _cloneDeep2.default)(state[key]);
                    if (obj.children) obj.children = obj.children.map(function (item) {
                        return _this4._get(item, state);
                    });
                    if (obj.members) {
                        for (var _key4 in obj.members) {
                            var member = obj.members[_key4];
                            if (member.type === 'id') {
                                obj.members[_key4] = _this4._get(member.value, state);
                            } else if (member.type === 'array') {
                                _this4._resolveArray(member.members, state);
                            }
                        }
                    }
                }
                return obj;
            }
        });


        _this4.pool = new session.options.pool((0, _extends3.default)({ session: session }, session.options.poolOptions));
        _this4.primitives = {};
        _this4.featurePlugins = {};

        // Observe tree changes to clear cache
        _this4.observe(function (state) {
            return state.tree;
        }, function () {
            return _this4._get.cache.clear();
        });

        // Observe root
        _this4.observe(function (state) {
            return state.tree.root;
        }, function (root) {
            return observe.bind(_this4)(root);
        });

        // Observe active feature
        _this4.observe(function (state) {
            return state.activeFeature;
        }, function (feature, oldFeature) {
            if (oldFeature) {
                var plugin = (0, _values2.default)(_this4.session.plugins).find(function (plugin) {
                    return plugin.feature === oldFeature;
                });
                _this4.store.dispatch(_plugins.actions.update(plugin.id, { enabled: false, collapsed: true }));
            }

            if (feature) {
                var _plugin = (0, _values2.default)(_this4.session.plugins).find(function (plugin) {
                    return plugin.feature === feature;
                });
                _this4.store.dispatch(_plugins.actions.update(_plugin.id, { enabled: true, collapsed: false }));
                _this4.activeFeaturePlugin = _plugin;
            }
        });

        // Connect to server
        if (_this4.session.options.url && _this4.session.options.protocol) {
            _this4.connect(_this4.session.options.url);
        }
        return _this4;
    }

    (0, _createClass3.default)(Connection, [{
        key: 'request',
        value: function request(command, factory) {
            return this.store.dispatch(this.actions.request(this.id, command, factory));
        }
    }, {
        key: 'stream',
        value: function stream(url, factory) {
            return this.store.dispatch(this.actions.stream(this.id, url, factory));
        }
    }, {
        key: 'parse',
        value: function parse(blob, factory) {
            return this.store.dispatch(this.actions.parse(this.id, blob, factory));
        }
    }, {
        key: 'connect',
        value: function connect(url) {
            return this.store.dispatch(this.actions.connect(this.id, url, this.session.options.protocol));
        }
    }, {
        key: 'init',
        value: function init(payload) {
            this.store.dispatch({ type: "connections/init", payload: { id: this.id, data: payload } });
        }
    }, {
        key: 'patch',
        value: function patch(payload) {
            return this.store.dispatch(this.actions.patch(this.id, payload));
        }
    }, {
        key: 'resolveTree',
        value: function resolveTree(args) {
            var _this5 = this;

            if (!args) return;
            args = Array.isArray(args) ? args : [args];
            var result = args.map(function (key) {
                return _this5._get(key, _this5.getState().tree);
            });
            return result;
        }
    }, {
        key: '__onDestroyed',
        value: function __onDestroyed() {
            var _this6 = this;

            (0, _values2.default)(this.primitives).forEach(function (item) {
                return item.destroy();
            });
            this.primitives = {};

            (0, _values2.default)(this.session.plugins).forEach(function (plugin) {
                return plugin.connection === _this6.id && _this6.store.dispatch(_plugins.actions.unregister(plugin.id));
            });

            if (this.session.globals.activeConnection === this.id) {
                this.session.dispatch(_globals.actions.setActiveConnection());
            }
            this.socket && this.socket.disconnect();
        }
    }, {
        key: '_resolveArray',
        value: function _resolveArray(array, state) {
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

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

                    if (member.type === 'id') {
                        array[array.indexOf(member)] = this._get(member.value, state);
                    } else if (member.type === 'array') {
                        this._resolveArray(member, state);
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }
    }]);
    return Connection;
}((0, _lifecycle2.default)(_base2.default, false));

exports.default = Connection;