infamous/core/props.js

A CSS3D/WebGL UI library.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.mapPropTo = exports.props = void 0;

var _skatejs = require("@trusktr/skatejs");

var _three = require("three");

var _XYZValues = _interopRequireDefault(require("./XYZValues"));

var _XYZNumberValues = _interopRequireDefault(require("./XYZNumberValues"));

var _XYZNonNegativeValues = _interopRequireDefault(require("./XYZNonNegativeValues"));

var _XYZStringValues = _interopRequireDefault(require("./XYZStringValues"));

var _XYZSizeModeValues = _interopRequireDefault(require("./XYZSizeModeValues"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _objectSpread(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};
    var ownKeys = Object.keys(source);

    if (typeof Object.getOwnPropertySymbols === 'function') {
      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
      }));
    }

    ownKeys.forEach(function (key) {
      _defineProperty(target, key, source[key]);
    });
  }

  return target;
}

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function createXYZPropType(Type, override = {}) {
  return _objectSpread({
    attribute: {
      source: true,
      target: false
    },

    // get the value from an attribute (but don't mirror it back)
    coerce(val, propName) {
      return val === this.element[propName] ? val : this.element[propName].from(val);
    },

    default(propName) {
      return this.element[propName];
    },

    deserialize(val, propName) {
      return this.element[propName].fromString(val);
    },

    serialize(val, propName) {
      this.element[propName].toString();
    }

  }, override);
}

function createGenericPropType(Type, override = {}) {
  return _objectSpread({
    attribute: {
      source: true,
      target: false
    },
    // get the value from an attribute (but don't mirror it back)
    coerce: val => val instanceof Type ? val : new Type(val),
    default: new Type(),
    deserialize: val => new Type(val),
    serialize: val => val.toString()
  }, override);
}

const props = Object.assign({}, _skatejs.props, {
  boolean: _objectSpread({}, _skatejs.props.boolean, {
    deserialize: val => val != null && val !== 'false'
  }),
  THREE: {
    // TODO replace THREE.Color with a persistent object that can be
    // dynamically updated, like with XYZValues
    Color: createGenericPropType(_three.Color, {
      default: () => new _three.Color(Math.random(), Math.random(), Math.random()),
      serialize: val => new _three.Color(val).getStyle() // returns a CSS "rbg()" string

    })
  },
  XYZValues: createXYZPropType(_XYZValues.default),
  XYZNumberValues: createXYZPropType(_XYZNumberValues.default),
  XYZNonNegativeValues: createXYZPropType(_XYZNonNegativeValues.default),
  XYZStringValues: createXYZPropType(_XYZStringValues.default),
  XYZSizeModeValues: createXYZPropType(_XYZSizeModeValues.default)
}); // map a SkateJS prop value to a sub-object on the instance

exports.props = props;

const mapPropTo = (prop, subObj) => _objectSpread({}, prop, {
  coerce(val, key) {
    return this[subObj][key] = prop.coerce(val);
  },

  deserialize(val, key) {
    return this[subObj][key] = prop.deserialize(val);
  }

});

exports.mapPropTo = mapPropTo;