awv3/session/helpers.js

⚡ AWV3 embedded CAD

import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
import * as THREE from 'three';
import Object3 from '../three/object3';
import { exponential } from '../animation/easing';
export var Pool =
/*#__PURE__*/
function (_THREE$Group) {
  _inheritsLoose(Pool, _THREE$Group);

  function Pool(_ref) {
    var _this;

    var session = _ref.session,
        _ref$name = _ref.name,
        name = _ref$name === void 0 ? 'pool' : _ref$name;
    _this = _THREE$Group.call(this) || this;
    _this.name = name;
    _this.session = session;
    _this.temporary = new THREE.Group();
    _this.temporary.name = name + ".temporary";
    _this.temporary.updateParentMaterials = false;

    _THREE$Group.prototype.add.call(_this, _this.temporary);

    _this.preset = {
      duration: 300,
      renderOrder: Object3.RenderOrder.Default
    };
    _this.defaults = _this.preset;
    return _this;
  }

  var _proto = Pool.prototype;

  _proto.update = function update() {};

  return Pool;
}(THREE.Group);
export var ObjectPrototype =
/*#__PURE__*/
function (_THREE$Group2) {
  _inheritsLoose(ObjectPrototype, _THREE$Group2);

  function ObjectPrototype(_ref2) {
    var _this2;

    var session = _ref2.session;
    _this2 = _THREE$Group2.call(this) || this;
    _this2.session = session;

    if (_this2.session) {
      _this2.pool = session.pool;
    }

    return _this2;
  }

  return ObjectPrototype;
}(THREE.Group); // Empty prototypes, useful for reduxes connect, where newly created objects (state.array || [])
// ... would cause re-redering.

export var emptyObject = {};
export var emptyArray = []; // Helps detecting changes in two array-states

export var arrayDiff = function arrayDiff(next, current, callbackNew, callbackDeleted) {
  if (next === void 0) {
    next = [];
  }

  if (current === void 0) {
    current = [];
  }

  var nextSet = new Set(next);
  var currentSet = new Set(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 = promises.concat(_results);
      }
    }
  }

  return Promise.all(promises);
}; // State observe with pre-select and user-select

export var createObserver = function createObserver(store, preSelect) {
  if (preSelect === void 0) {
    preSelect = store.getState;
  }

  return function (userSelect, onChange, options) {
    if (options === void 0) {
      options = {};
    }

    var _options = options,
        _options$fireOnStart = _options.fireOnStart,
        fireOnStart = _options$fireOnStart === void 0 ? false : _options$fireOnStart,
        _options$unsubscribeO = _options.unsubscribeOnUndefined,
        unsubscribeOnUndefined = _options$unsubscribeO === void 0 ? false : _options$unsubscribeO,
        _options$onRemove = _options.onRemove,
        onRemove = _options$onRemove === void 0 ? undefined : _options$onRemove,
        _options$manager = _options.manager,
        manager = _options$manager === void 0 ? undefined : _options$manager;

    var _finish,
        unsubscribed = false;

    var preselect, state;
    if ((preselect = preSelect()) === undefined || (state = userSelect(preselect)) === undefined && unsubscribeOnUndefined) return function () {};

    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;
      onChange(state, previousState);
    }; // Subscribe to store, fire on start, return hooked unsubscribe


    if (fireOnStart) {
      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, _finish);
    }; // 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. ...)

export var buildFeaturePath = function buildFeaturePath(tree, feature) {
  if (typeof 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('.');
};
export var normalizeName = function normalizeName(name) {
  return name.replace(/(\s|-|\r?\n)/g, '');
};
export var collectNestedIds = function collectNestedIds(target) {
  var array = [];
  var parent = target;

  while (parent) {
    if (parent.userData.id) array.push(parent.userData.id);
    parent = parent.parent;
  }

  array = array.reverse();
  return array;
};