roiact/dist/Redux/Canvas.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.SET_SELECTED_TOOL = exports.SET_SELECTED_MODE = exports.SET_SAVING = exports.SET_DRAWING = exports.SET_DIRTY = exports.SET_BG_OPACITY = exports.RESET_CANVAS = exports.REMOVE_SHAPE = exports.INIT_SHAPES = exports.INITIAL_STATE = exports.EDIT_SHAPE_META = exports.EDIT_SHAPE = exports.ADD_SHAPE = void 0;
exports.reducer = reducer;

var _Config = _interopRequireDefault(require("../Config"));

var _Utils = require("./Utils");

var _EventDispatcher = _interopRequireDefault(require("../Services/EventDispatcher"));

var _Root = require("./Root");

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

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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; }

// Type
var INIT_SHAPES = 'INIT_SHAPES';
exports.INIT_SHAPES = INIT_SHAPES;
var ADD_SHAPE = 'ADD_SHAPE';
exports.ADD_SHAPE = ADD_SHAPE;
var EDIT_SHAPE = 'EDIT_SHAPE';
exports.EDIT_SHAPE = EDIT_SHAPE;
var EDIT_SHAPE_META = 'EDIT_SHAPE_META';
exports.EDIT_SHAPE_META = EDIT_SHAPE_META;
var REMOVE_SHAPE = 'REMOVE_SHAPE';
exports.REMOVE_SHAPE = REMOVE_SHAPE;
var SET_SAVING = 'SET_SAVING';
exports.SET_SAVING = SET_SAVING;
var SET_DIRTY = 'SET_DIRTY';
exports.SET_DIRTY = SET_DIRTY;
var SET_DRAWING = 'SET_DRAWING';
exports.SET_DRAWING = SET_DRAWING;
var SET_BG_OPACITY = 'SET_BG_OPACITY';
exports.SET_BG_OPACITY = SET_BG_OPACITY;
var SET_SELECTED_TOOL = 'SET_SELECTED_TOOL';
exports.SET_SELECTED_TOOL = SET_SELECTED_TOOL;
var SET_SELECTED_MODE = 'SET_SELECTED_MODE';
exports.SET_SELECTED_MODE = SET_SELECTED_MODE;
var RESET_CANVAS = 'RESET_CANVAS'; // Actions

exports.RESET_CANVAS = RESET_CANVAS;
var _default = {
  setBgOpacity: (0, _Utils.actionCreator)(SET_BG_OPACITY),
  setSelectedTool: (0, _Utils.actionCreator)(SET_SELECTED_TOOL),
  setSelectedMode: (0, _Utils.actionCreator)(SET_SELECTED_MODE),
  setSaving: (0, _Utils.actionCreator)(SET_SAVING),
  setDirty: (0, _Utils.actionCreator)(SET_DIRTY),
  setDrawing: (0, _Utils.actionCreator)(SET_DRAWING),
  initShapes: (0, _Utils.actionCreator)(INIT_SHAPES),
  addShape: (0, _Utils.actionCreator)(ADD_SHAPE),
  editShape: (0, _Utils.actionCreator)(EDIT_SHAPE),
  editShapeMeta: (0, _Utils.actionCreator)(EDIT_SHAPE_META),
  removeShape: (0, _Utils.actionCreator)(REMOVE_SHAPE),
  resetCanvas: (0, _Utils.actionCreator)(RESET_CANVAS)
}; // Initial state

exports.default = _default;
var INITIAL_STATE = {
  tools: {
    opacity: 80,
    mode: 'inbound',
    selected: null
  },
  shapes: [],
  dirty: false,
  saving: false,
  drawing: false
}; // Reducers

exports.INITIAL_STATE = INITIAL_STATE;

var setSaving = function setSaving(state, isSaving) {
  return Object.assign({}, state, {
    saving: isSaving
  });
};

var setDirty = function setDirty(state, isDirty) {
  return Object.assign({}, state, {
    dirty: isDirty
  });
};

var setDrawing = function setDrawing(state, isDrawing) {
  return Object.assign({}, state, {
    drawing: isDrawing
  });
};

var setBgOpacity = function setBgOpacity(state, value) {
  return Object.assign({}, state, {
    tools: _objectSpread(_objectSpread({}, state.tools), {}, {
      opacity: value
    })
  });
};

var setSelectedTool = function setSelectedTool(state, value) {
  return Object.assign({}, state, {
    tools: _objectSpread(_objectSpread({}, state.tools), {}, {
      selected: value
    })
  });
};

var setSelectedMode = function setSelectedMode(state, mode) {
  return Object.assign({}, state, {
    tools: _objectSpread(_objectSpread({}, state.tools), {}, {
      mode: mode
    })
  });
};

var initShapes = function initShapes(state, shapes) {
  return Object.assign({}, state, {
    shapes: shapes
  });
};

var addShape = function addShape(state, shape) {
  var newState = Object.assign({}, state, {
    dirty: true,
    shapes: [].concat(_toConsumableArray(state.shapes), [shape])
  });
  setTimeout(function () {
    return _EventDispatcher.default.emit('save', newState['shapes']);
  }, 200);
  return newState;
};

var editShape = function editShape(state, _ref) {
  var id = _ref.id,
      shape = _ref.shape;
  var newState = Object.assign({}, state, {
    dirty: true,
    shapes: state.shapes.map(function (s) {
      return s.id === id ? _objectSpread(_objectSpread({}, s), {}, {
        data: shape
      }) : s;
    })
  });
  setTimeout(function () {
    return _EventDispatcher.default.emit('save', newState['shapes']);
  }, 200);
  return newState;
};

var editShapeMeta = function editShapeMeta(state, _ref2) {
  var id = _ref2.id,
      meta = _ref2.meta;
  setTimeout(function () {
    return _EventDispatcher.default.emit('redraw');
  }, 100);
  var newState = Object.assign({}, state, {
    dirty: true,
    shapes: state.shapes.map(function (s) {
      return s.id === id ? _objectSpread(_objectSpread(_objectSpread({}, s), meta), {}, {
        data: _objectSpread(_objectSpread({}, s.data), {}, {
          stroke: _Config.default.canvas["".concat(meta.mode, "Stroke")],
          fill: _Config.default.canvas["".concat(meta.mode, "Fill")]
        })
      }) : s;
    })
  });
  setTimeout(function () {
    return _EventDispatcher.default.emit('save', newState['shapes']);
  }, 200);
  return newState;
};

var removeShape = function removeShape(state, id) {
  var newState = Object.assign({}, state, {
    dirty: true,
    shapes: _toConsumableArray(state.shapes).filter(function (s) {
      return s.id !== id;
    })
  });
  setTimeout(function () {
    return _EventDispatcher.default.emit('save', newState['shapes']);
  }, 200);
  return newState;
};

function reducer() {
  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : INITIAL_STATE;

  var _ref3 = arguments.length > 1 ? arguments[1] : undefined,
      type = _ref3.type,
      payload = _ref3.payload;

  switch (type) {
    case SET_SAVING:
      return setSaving(state, payload);

    case SET_DIRTY:
      return setDirty(state, payload);

    case SET_DRAWING:
      return setDrawing(state, payload);

    case SET_BG_OPACITY:
      return setBgOpacity(state, payload);

    case SET_SELECTED_TOOL:
      return setSelectedTool(state, payload);

    case SET_SELECTED_MODE:
      return setSelectedMode(state, payload);

    case INIT_SHAPES:
      return initShapes(state, payload);

    case ADD_SHAPE:
      return addShape(state, payload);

    case EDIT_SHAPE:
      return editShape(state, payload);

    case EDIT_SHAPE_META:
      return editShapeMeta(state, payload);

    case REMOVE_SHAPE:
      return removeShape(state, payload);

    case RESET_CANVAS:
      return INITIAL_STATE;

    case _Root.RESET:
      return INITIAL_STATE;

    default:
      return state;
  }
}