Your IP : 216.73.216.86
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
import { invariant } from '@react-dnd/invariant';
import { addSource as _addSource, addTarget as _addTarget, removeSource as _removeSource, removeTarget as _removeTarget } from './actions/registry';
import { getNextUniqueId } from './utils/getNextUniqueId';
import { HandlerRole } from './interfaces';
import { validateSourceContract, validateTargetContract, validateType } from './contracts';
import { asap } from '@react-dnd/asap';
function getNextHandlerId(role) {
var id = getNextUniqueId().toString();
switch (role) {
case HandlerRole.SOURCE:
return "S".concat(id);
case HandlerRole.TARGET:
return "T".concat(id);
default:
throw new Error("Unknown Handler Role: ".concat(role));
}
}
function parseRoleFromHandlerId(handlerId) {
switch (handlerId[0]) {
case 'S':
return HandlerRole.SOURCE;
case 'T':
return HandlerRole.TARGET;
default:
invariant(false, "Cannot parse handler ID: ".concat(handlerId));
}
}
function mapContainsValue(map, searchValue) {
var entries = map.entries();
var isDone = false;
do {
var _entries$next = entries.next(),
done = _entries$next.done,
_entries$next$value = _slicedToArray(_entries$next.value, 2),
value = _entries$next$value[1];
if (value === searchValue) {
return true;
}
isDone = !!done;
} while (!isDone);
return false;
}
export var HandlerRegistryImpl = /*#__PURE__*/function () {
function HandlerRegistryImpl(store) {
_classCallCheck(this, HandlerRegistryImpl);
this.types = new Map();
this.dragSources = new Map();
this.dropTargets = new Map();
this.pinnedSourceId = null;
this.pinnedSource = null;
this.store = store;
}
_createClass(HandlerRegistryImpl, [{
key: "addSource",
value: function addSource(type, source) {
validateType(type);
validateSourceContract(source);
var sourceId = this.addHandler(HandlerRole.SOURCE, type, source);
this.store.dispatch(_addSource(sourceId));
return sourceId;
}
}, {
key: "addTarget",
value: function addTarget(type, target) {
validateType(type, true);
validateTargetContract(target);
var targetId = this.addHandler(HandlerRole.TARGET, type, target);
this.store.dispatch(_addTarget(targetId));
return targetId;
}
}, {
key: "containsHandler",
value: function containsHandler(handler) {
return mapContainsValue(this.dragSources, handler) || mapContainsValue(this.dropTargets, handler);
}
}, {
key: "getSource",
value: function getSource(sourceId) {
var includePinned = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
invariant(this.isSourceId(sourceId), 'Expected a valid source ID.');
var isPinned = includePinned && sourceId === this.pinnedSourceId;
var source = isPinned ? this.pinnedSource : this.dragSources.get(sourceId);
return source;
}
}, {
key: "getTarget",
value: function getTarget(targetId) {
invariant(this.isTargetId(targetId), 'Expected a valid target ID.');
return this.dropTargets.get(targetId);
}
}, {
key: "getSourceType",
value: function getSourceType(sourceId) {
invariant(this.isSourceId(sourceId), 'Expected a valid source ID.');
return this.types.get(sourceId);
}
}, {
key: "getTargetType",
value: function getTargetType(targetId) {
invariant(this.isTargetId(targetId), 'Expected a valid target ID.');
return this.types.get(targetId);
}
}, {
key: "isSourceId",
value: function isSourceId(handlerId) {
var role = parseRoleFromHandlerId(handlerId);
return role === HandlerRole.SOURCE;
}
}, {
key: "isTargetId",
value: function isTargetId(handlerId) {
var role = parseRoleFromHandlerId(handlerId);
return role === HandlerRole.TARGET;
}
}, {
key: "removeSource",
value: function removeSource(sourceId) {
var _this = this;
invariant(this.getSource(sourceId), 'Expected an existing source.');
this.store.dispatch(_removeSource(sourceId));
asap(function () {
_this.dragSources.delete(sourceId);
_this.types.delete(sourceId);
});
}
}, {
key: "removeTarget",
value: function removeTarget(targetId) {
invariant(this.getTarget(targetId), 'Expected an existing target.');
this.store.dispatch(_removeTarget(targetId));
this.dropTargets.delete(targetId);
this.types.delete(targetId);
}
}, {
key: "pinSource",
value: function pinSource(sourceId) {
var source = this.getSource(sourceId);
invariant(source, 'Expected an existing source.');
this.pinnedSourceId = sourceId;
this.pinnedSource = source;
}
}, {
key: "unpinSource",
value: function unpinSource() {
invariant(this.pinnedSource, 'No source is pinned at the time.');
this.pinnedSourceId = null;
this.pinnedSource = null;
}
}, {
key: "addHandler",
value: function addHandler(role, type, handler) {
var id = getNextHandlerId(role);
this.types.set(id, type);
if (role === HandlerRole.SOURCE) {
this.dragSources.set(id, handler);
} else if (role === HandlerRole.TARGET) {
this.dropTargets.set(id, handler);
}
return id;
}
}]);
return HandlerRegistryImpl;
}();