all files / src/ analog-array.js

100% Statements 32/32
100% Branches 18/18
100% Functions 6/6
100% Lines 32/32
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 55× 55× 43×   37× 37× 37× 13×   24×   16×   12×       10×               27×     21× 21×                      
const getter = function (target, prop, receiver) {
  const propFloat = parseFloat(prop)
  if (!isNaN(propFloat)) {
    if (propFloat < 0) {
      return target[0]
    }
    const leftIndex = ~~propFloat
    const lastIndex = target.length - 1
    if (leftIndex >= lastIndex) {
      return target[lastIndex]
    }
    if (propFloat === leftIndex) {
      return target[propFloat]
    }
    return this.slide(target[leftIndex], target[leftIndex + 1], propFloat - leftIndex)
  } else {
    return Reflect.get(target, prop, receiver)
  }
}
 
const setter = function (target, prop, value, receiver) {
  if (prop === "slide") {
    this.slide = value
    return value
  }
  return Reflect.set(target, prop, value, receiver)
}
 
function AnalogArray (array, slide) {
  this.array = array || []
  this.slide = slide || AnalogArray.slideNumber
  return new Proxy(this.array, { get: getter.bind(this), set: setter.bind(this) })
}
 
Object.assign(AnalogArray, {
  slideNumber: (from, to, amount) => {
    return ((to - from) * amount) + from
  },
  slideByte: (from, to, amount) => {
    const slid = AnalogArray.slideNumber(from & 0xff, to & 0xff, amount)
    return Math.round(Math.min(Math.max(slid, 0), 0xff))
  },
  slideColor: (from, to, amount) => {
    const sb = AnalogArray.slideByte
    const fromLen = from.length
    const color1 = parseInt(from.replace("#", ""), 16)
    const color2 = parseInt(to.replace("#", ""), 16)
    const res = sb(color1, color2, amount) |
    ( sb(color1 >>> 8, color2 >>> 8, amount) << 8 ) |
    ( sb(color1 >>> 16, color2 >>> 16, amount) << 16 ) |
    ( fromLen > 7 ? sb(color1 >>> 24, color2 >>> 24, amount) << 24 : 0 )
    const resStr = (res >>> 0).toString(16).padStart((fromLen | 1) ^ 1, "0")
    return (fromLen & 1) ? "#" + resStr : resStr
  }
})
 
export { AnalogArray }
export default AnalogArray