rakkiisto-utils v1.2.0

rakkiisto-utils

rakkiisto utils by rakkiisto

extend (function)

how to use:

// original definition
Foo.bar = function (a: T, b: T): T {
  return a + b
}
Foo.bar(2, 3) // 5

extend(Foo, {
  bar: (a, b) => a * b
}, 'override')
Foo.bar(2, 3) // 6

// caution: order won't preserved
extend(Foo, {
  bar: {
    prerun: () => console.log('start'),
    args: (a, b) => [a + 1, b + 1],
    relay: (c, a, b) => c / (a * b),
    postrun: () => console.log('end'),
  }
})
Foo.bar(2, 3) // 2

extend function has 8 modes: attach, relay, override, overload, args, gate, prerun, postrun

default mode is attach

// copy the original function...
var _bar = Foo.bar

// prerun: runs before original function, with same arguments
Foo.bar = function (a, b) {
  prerun(a, b)
  return _bar(a, b)
}

// args: process the arguments, passes it to original function
Foo.bar = function (a, b) {
  return _bar(args(a, b))
}

// relay: receives original return value as first arg, and original arguments array as second arg.
Foo.bar = function (...args) {
  return relay(_bar(...args), args)
}

function relay(originalReturn: T, originalArguments: T[]) {
  //...
}

// attach: runs after original function, return new value instead of original return
Foo.bar = function (a, b) {
  _bar(a, b)
  return attach(a, b)
}

// postrun: runs after original function, return original value instead of callback return
Foo.bar = function (a, b) {
  const originalReturn = _bar(a, b)
  postrun(a, b)
  return originalReturn
}

// overload: passes the original function as first arg without calling, arguments array as second arg.
Foo.bar = function (...args) {
  return overload(_bar, args)
}

function overload(originalFunc: (a: T, b: T) => T, originalArgs: T[]) {
  const start = performance.now()

  for (let i = 0; i < 10000; i++) {
    const [a, b] = originalArgs
    const ret = originalFunc(a + i, b * i)
  }

  const end = performance.now() - start
  console.log(`elapsed ${end} ms`)
  return end
}

// override: replaces the original function to new one.
Foo.bar = function (a, b) {
  return override(a, b)
}

// gate: skips running original function if callback returns falsy value
Foo.bar = function (a, b) {
  if (gate(a, b)) return _bar(a, b)
}