text: import {
    createTypedArray,
  } from '../helpers/arrays';
  
  const ExpressionPropertyInterface = (function () {
    var defaultUnidimensionalValue = { pv: 0, v: 0, mult: 1 };
    var defaultMultidimensionalValue = { pv: [0, 0, 0], v: [0, 0, 0], mult: 1 };
  
    function completeProperty(expressionValue, property, type) {
      Object.defineProperty(expressionValue, 'velocity', {
        get: function () {
          return property.getVelocityAtTime(property.comp.currentFrame);
        },
      });
      expressionValue.numKeys = property.keyframes ? property.keyframes.length : 0;
      expressionValue.key = function (pos) {
        if (!expressionValue.numKeys) {
          return 0;
        }
        var value = '';
        if ('s' in property.keyframes[pos - 1]) {
          value = property.keyframes[pos - 1].s;
        } else if ('e' in property.keyframes[pos - 2]) {
          value = property.keyframes[pos - 2].e;
        } else {
          value = property.keyframes[pos - 2].s;
        }
        var valueProp = type === 'unidimensional' ? new Number(value) : Object.assign({}, value); // eslint-disable-line no-new-wrappers
        valueProp.time = property.keyframes[pos - 1].t / property.elem.comp.globalData.frameRate;
        valueProp.value = type === 'unidimensional' ? value[0] : value;
        return valueProp;
      };
      expressionValue.valueAtTime = property.getValueAtTime;
      expressionValue.speedAtTime = property.getSpeedAtTime;
      expressionValue.velocityAtTime = property.getVelocityAtTime;
      expressionValue.propertyGroup = property.propertyGroup;
    }
  
    function UnidimensionalPropertyInterface(property) {
      if (!property || !('pv' in property)) {
        property = defaultUnidimensionalValue;
      }
      var mult = 1 / property.mult;
      var val = property.pv * mult;
      var expressionValue = new Number(val); // eslint-disable-line no-new-wrappers
      expressionValue.value = val;
      completeProperty(expressionValue, property, 'unidimensional');
  
      return function () {
        if (property.k) {
          property.getValue();
        }
        val = property.v * mult;
        if (expressionValue.value !== val) {
          expressionValue = new Number(val); // eslint-disable-line no-new-wrappers
          expressionValue.value = val;
          completeProperty(expressionValue, property, 'unidimensional');
        }
        return expressionValue;
      };
    }
  
    function MultidimensionalPropertyInterface(property) {
      if (!property || !('pv' in property)) {
        property = defaultMultidimensionalValue;
      }
      var mult = 1 / property.mult;
      var len = (property.data && property.data.l) || property.pv.length;
      var expressionValue = createTypedArray('float32', len);
      var arrValue = createTypedArray('float32', len);
      expressionValue.value = arrValue;
      completeProperty(expressionValue, property, 'multidimensional');
  
      return function () {
        if (property.k) {
          property.getValue();
        }
        for (var i = 0; i < len; i += 1) {
          arrValue[i] = property.v[i] * mult;
          expressionValue[i] = arrValue[i];
        }
        return expressionValue;
      };
    }
  
    // TODO: try to avoid using this getter
    function defaultGetter() {
      return defaultUnidimensionalValue;
    }
  
    return function (property) {
      if (!property) {
        return defaultGetter;
      } if (property.propType === 'unidimensional') {
        return UnidimensionalPropertyInterface(property);
      }
      return MultidimensionalPropertyInterface(property);
    };
  }());
  
  export default ExpressionPropertyInterface;
  