awv3/session/helpers.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.normalizeName = exports.buildFeaturePath = exports.createObserver = exports.arrayDiff = exports.pack = exports.ObjectPrototype = exports.Pool = undefined;

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

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

var _extends3 = _interopRequireDefault(_extends2);

var _map = require('babel-runtime/core-js/map');

var _map2 = _interopRequireDefault(_map);

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

var _promise2 = _interopRequireDefault(_promise);

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

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _set = require('babel-runtime/core-js/set');

var _set2 = _interopRequireDefault(_set);

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

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

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 _get2 = require('babel-runtime/helpers/get');

var _get3 = _interopRequireDefault(_get2);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

var _pako = require('pako');

var _pako2 = _interopRequireDefault(_pako);

var _base64Arraybuffer = require('base64-arraybuffer');

var _base64Arraybuffer2 = _interopRequireDefault(_base64Arraybuffer);

var _object = require('../three/object3');

var _object2 = _interopRequireDefault(_object);

var _easing = require('../animation/easing');

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 Pool = exports.Pool = function (_Object) {
    (0, _inherits3.default)(Pool, _Object);

    function Pool(_ref) {
        var session = _ref.session;
        (0, _classCallCheck3.default)(this, Pool);

        var _this = (0, _possibleConstructorReturn3.default)(this, (Pool.__proto__ || (0, _getPrototypeOf2.default)(Pool)).call(this));

        _this.session = session;
        _this.temporary = new _object2.default();
        _this.temporary.updateParentMaterials = false;
        _this.temporary.measurable = false;
        (0, _get3.default)(Pool.prototype.__proto__ || (0, _getPrototypeOf2.default)(Pool.prototype), 'add', _this).call(_this, _this.temporary);
        return _this;
    }

    (0, _createClass3.default)(Pool, [{
        key: 'update',
        value: function update() {
            // ...
        }
    }]);
    return Pool;
}(_object2.default);

var ObjectPrototype = exports.ObjectPrototype = function (_Object2) {
    (0, _inherits3.default)(ObjectPrototype, _Object2);

    function ObjectPrototype(_ref2) {
        var session = _ref2.session;
        (0, _classCallCheck3.default)(this, ObjectPrototype);

        var _this2 = (0, _possibleConstructorReturn3.default)(this, (ObjectPrototype.__proto__ || (0, _getPrototypeOf2.default)(ObjectPrototype)).call(this));

        _this2.on((0, _defineProperty3.default)({}, _object2.default.Events.Lifecycle.ChildAdded, function (_ref3) {
            var child = _ref3.child;
            return child.updateMaterials().animate({ materials: {
                    meshes: [{ opacity: 1 }],
                    lines: [{ opacity: typeof session.options.materials.edgeOpacity !== "undefined" ? session.options.materials.edgeOpacity : 1 }]
                } }).from({ materials: {
                    meshes: [{ opacity: 0 }],
                    lines: [{ opacity: 0 }]
                } }).start(200).easing(_easing.exponential.in);
        }));
        return _this2;
    }

    return ObjectPrototype;
}(_object2.default);

// Packs ArrayBuffer into deflated base64 for ClassCAD stream consumption


var pack = exports.pack = function pack(buffer) {
    return _base64Arraybuffer2.default.encode(_pako2.default.deflate(buffer, { raw: true }));
};

// Helps detecting changes in two array-states
var arrayDiff = exports.arrayDiff = function arrayDiff() {
    var next = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    var current = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
    var callbackNew = arguments[2];
    var callbackDeleted = arguments[3];

    var nextSet = new _set2.default(next);
    var currentSet = new _set2.default(current);
    var promises = [];

    if (callbackNew) {
        var newItems = next.filter(function (item) {
            return !currentSet.has(item);
        });
        if (newItems.length) {
            var results = callbackNew(newItems);
            if (results) {
                promises = results;
            }
        }
    }

    if (callbackDeleted) {
        var deletedItems = current.filter(function (item) {
            return !nextSet.has(item);
        });
        if (deletedItems.length) {
            var _results = callbackDeleted(deletedItems);
            if (_results) {
                promises = [].concat((0, _toConsumableArray3.default)(promises), (0, _toConsumableArray3.default)(_results));
            }
        }
    }

    return _promise2.default.all(promises);
};

// State observe with pre-select and user-select
var createObserver = exports.createObserver = function createObserver(store) {
    var preSelect = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : store.getState;
    return function (userSelect, onChange) {
        var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
        var _options$fireOnStart = options.fireOnStart,
            fireOnStart = _options$fireOnStart === undefined ? false : _options$fireOnStart,
            _options$unsubscribeO = options.unsubscribeOnUndefined,
            unsubscribeOnUndefined = _options$unsubscribeO === undefined ? false : _options$unsubscribeO,
            _options$onRemove = options.onRemove,
            onRemove = _options$onRemove === undefined ? undefined : _options$onRemove,
            _options$manager = options.manager,
            manager = _options$manager === undefined ? undefined : _options$manager,
            _options$deep = options.deep,
            deep = _options$deep === undefined ? false : _options$deep;


        var finish = void 0,
            unsubscribed = false;
        var preselect = void 0,
            state = void 0;
        if ((preselect = preSelect()) === undefined || (state = userSelect(preselect)) === undefined && unsubscribeOnUndefined) return function () {};

        var childSubscriptions = new _map2.default();
        var addChild = function addChild(id, unsub) {
            return childSubscriptions.set(id, unsub);
        };
        var removeChild = function removeChild(state) {
            childSubscriptions.delete(state.id);onRemove && onRemove(state);
        };

        var handleChange = function handleChange() {
            if (unsubscribed) return;
            // Get pre-selected state
            var previousState = state;
            // Unsubscribe if preselect or state is undefined
            if ((preselect = preSelect()) === undefined || (state = userSelect(preselect)) === undefined && unsubscribeOnUndefined) {
                // revert state so that finish calls onRemove on a good state
                state = previousState;
                return finish();
            }
            if (state === previousState) return;
            // add children subscriptions
            if (deep) arrayDiff((state || {}).children, (previousState || {}).children, function (newChildren) {
                return newChildren.forEach(function (child) {
                    return addChild(child, createObserver(store, preSelect)(function (state) {
                        return state.tree[child];
                    }, onChange, (0, _extends3.default)({}, options, { unsubscribeOnUndefined: true, onRemove: removeChild, manager: undefined })));
                });
            });
            onChange(state, previousState);
        };

        // Subscribe to store, fire on start, return hooked unsubscribe
        if (fireOnStart || deep) {
            state = undefined; // so that onChange is called with prev === undefined
            handleChange();
        }
        var unsubscribe = store.subscribe(handleChange);

        finish = function finish() {
            if (unsubscribed) return;
            unsubscribed = true;
            unsubscribe();
            onRemove && onRemove(state);
            // copy to avoid mutation during iteration
            var unsubs = [].concat((0, _toConsumableArray3.default)(childSubscriptions.values()));
            // remove children subscriptions
            unsubs.forEach(function (unsub) {
                return unsub();
            });
        };

        // Call manager, if available. This allows classes to track subscribes and clean up
        // in bulk once they are destroyed.
        if (manager) manager(finish);

        return finish;
    };
};

// Build ClassAD feature path (_O. ...)
var buildFeaturePath = exports.buildFeaturePath = function buildFeaturePath(tree, feature) {
    if ((typeof feature === 'undefined' ? 'undefined' : (0, _typeof3.default)(feature)) !== 'object') feature = tree[feature];
    var path = [normalizeName(feature.name)],
        parent = feature;
    while (parent && parent.parent > 1) {
        parent = tree[parent.parent];
        path.push(normalizeName(parent.name));
    }
    return '_O.' + path.reverse().join('.');
};

var normalizeName = exports.normalizeName = function normalizeName(name) {
    return name.replace(/(\s|-|\r?\n)/g, '');
};