mezzanine/es/utils/props.js

Fantasy land union types with pattern matching

import { dropRepeatsWith } from 'ramda';

import { transducer, forEach, map, reverse, concat } from './list';


export function copyObject(orig) {
  // 1. copy has same prototype as orig
  var copy = Object.create(Object.getPrototypeOf(orig));

  // 2. copy has all of orig’s properties
  copyOwnPropertiesFrom(copy, orig);

  return copy;
}


export function copyOwnPropertiesFrom(


target, source) {
  var ownProps = Object.getOwnPropertyNames(source);
  var ln = ownProps.length;
  var descBuffer = void 0,
  propKey = '';
  for (var i = 0; i < ln; i++) {
    propKey = ownProps[i];
    descBuffer = Object.getOwnPropertyDescriptor(source, propKey);
    Object.defineProperty(target, propKey, descBuffer);
  }
  return target;
}

export function addLazyProperty(
name,
initializer,
enumerable) {
  return function (object, klass) {
    Object.defineProperty(object, name, {
      get() {
        var v = initializer(this, klass);
        Object.defineProperty(this, name, {
          value: v,
          enumerable: !!enumerable,
          writable: true });

        return v;
      },
      set(v) {
        Object.defineProperty(this, name, {
          value: v,
          enumerable: !!enumerable,
          writable: true });

        return v;
      },
      enumerable: !!enumerable,
      configurable: true });

  };
}

export function addProperty(
name,
value,
enumerable = true,
writable = true,
injected = false) {
  return function property(target, klass) {
    var val = injected ?
    value(target, klass) :
    value;
    // console.log(val)
    Object.defineProperty(target, name, {
      value: val,
      enumerable,
      configurable: writable,
      writable });

  };
}

export function addGetSetter(
name,
//$FlowIssue
get,
set,
enumerable = false,
writable = false) {
  var desc = {
    enumerable,
    configurable: writable };

  if (get != null)
  desc.get = get;
  if (set != null)
  desc.set = set;
  return function getSetter(target) {
    Object.defineProperty(target, name, desc);
  };
}
















var funcToProperty =
property =>
typeof property === 'function' ?
{
  value: property,
  enumerable: false,
  writable: true,
  inject: true } :

property;

function ownKeys(desc) {
  //$FlowIssue
  var keys = Object.getOwnPropertyNames(desc).
  concat(Object.getOwnPropertySymbols(desc));
  return keys;
}

function toKeyVal(desc) {
  if (Array.isArray(desc)) return desc;
  var keys = ownKeys(desc);
  var ln = keys.length;
  var keyVal = Array(ln);
  for (var i = 0; i < ln; i++) {
    keyVal[i] = [keys[i], desc[keys[i]]];}
  return keyVal;
}

var internalAdd = ([key, val]) => {
  var get = val.get;
  var getter = get;
  if (val.lazy)
    //$FlowIssue
    return addLazyProperty(key, val.value, true);
  var isGet = get !== undefined;
  var isGetSet = isGet || val.set != null;
  if (isGetSet) {
    if (isGet && typeof get !== 'function')
    get = () => getter;
    return addGetSetter(key, get, val.set, val.enumerable, val.writable);
  } else
  return addProperty(key, val.value, val.enumerable, val.writable, val.inject);
};

var addPipe = [
([key, val]) => [
key,
funcToProperty(val)],

internalAdd];

export function addProperties(desc) {
  var pairs = toKeyVal(desc);
  var funcs = transducer(addPipe, pairs);
  var funcsCount = funcs.length;
  return function addProps(target, klass) {
    //$FlowIssue
    forEach(funcsCount, fn => fn(target, klass), funcs);
  };
}

var filterNames = dropRepeatsWith((a, b) => a[0] === b[0]);

export function injector(list) {
  var pairsLists = reverse(filterNames(reverse(concat(map(toKeyVal, list)))));
  var propMap = addProperties(pairsLists);
  return propMap;
}
//# sourceMappingURL=props.js.map