using ES6 Proxy to let Promises/Observables pretend like they're regular values

proxy-async.js

// using ES6 Proxy to let Promises/Observables pretend like they're regular values.

// get the mapping function used for async objects
let getMapper = (target) => target instanceof Promise ? 'then' :
    target instanceof Observable ? 'switchMap' : null;
// ^ fails if the Observable is in a local namespace e.g. Rx.Observable

// bind a value to its object if it's a function
let bindFn = (val, obj) => typeof val == 'function' ? val.bind(obj) : val;

// the proxy's trap handler
let handler = {};
// function invocation
handler.apply = (targetFn, that, args) => {
  // must wrap Proxy target in functions for this `apply` trap :(
  let target = targetFn();
  let mapper = getMapper(target);
  if(mapper) { // async
    // transparently map; keep Proxy.
    let val = target[mapper]((fn) => fn(args));
    return new Proxy(() => val, handler);
  } else { // sync
    // no-op, ditch proxy
    return target.apply(that, args);
  }
};
// property access
handler.get = (targetFn, prop) => {
  let target = targetFn();
  let value;
  let mapper = getMapper(target);
  let bound = bindFn(target[prop], target);
  if(mapper) { // async
    if(prop in target) {
      // ditch Proxy when directly invoking Promise/Observable method
      return bound;
    } else {
      // transparently map; keep Proxy.
      let value = target[mapper]((o) => bindFn(o[prop], o));
      return new Proxy(() => value, handler);
    }
  } else {
    // sync: no-op, ditch proxy
    return bound;
  }
};

let pretend = (v) => new Proxy(() => v, handler);
// now test our shiny `pretend` method.
let later = (v) => new Promise((resolve, reject) => setTimeout(() => resolve(v), 1000));
let obj = { greet: (name) => console.log('Hey ' + name) };
let prom = later(obj);
let greeter = pretend(prom);
// this is a Proxy'd Promise...
// yet we can call its methods using traditional syntax.
greeter.greet('you');
// ^ look mom, no `then`!
let res = greeter.then(() => console.log('sup'));
// un-Proxy by calling Promise methods like `then` (which `await` transpiles to AFAIK).
// This works similarly for Observables.
console.log('res', res);
// value: Promise<{ greet }>