qtsd-fork/example/node_modules/dnd-core/src/HandlerRegistry.js

Do not use this please

import invariant from 'invariant'
import isArray from 'lodash/isArray'
import asap from 'asap'
import {
	addSource,
	addTarget,
	removeSource,
	removeTarget,
} from './actions/registry'
import getNextUniqueId from './utils/getNextUniqueId'

const HandlerRoles = {
	SOURCE: 'SOURCE',
	TARGET: 'TARGET',
}

function validateSourceContract(source) {
	invariant(
		typeof source.canDrag === 'function',
		'Expected canDrag to be a function.',
	)
	invariant(
		typeof source.beginDrag === 'function',
		'Expected beginDrag to be a function.',
	)
	invariant(
		typeof source.endDrag === 'function',
		'Expected endDrag to be a function.',
	)
}

function validateTargetContract(target) {
	invariant(
		typeof target.canDrop === 'function',
		'Expected canDrop to be a function.',
	)
	invariant(
		typeof target.hover === 'function',
		'Expected hover to be a function.',
	)
	invariant(
		typeof target.drop === 'function',
		'Expected beginDrag to be a function.',
	)
}

function validateType(type, allowArray) {
	if (allowArray && isArray(type)) {
		type.forEach(t => validateType(t, false))
		return
	}

	invariant(
		typeof type === 'string' || typeof type === 'symbol',
		allowArray
			? 'Type can only be a string, a symbol, or an array of either.'
			: 'Type can only be a string or a symbol.',
	)
}

function getNextHandlerId(role) {
	const id = getNextUniqueId().toString()
	switch (role) {
		case HandlerRoles.SOURCE:
			return `S${id}`
		case HandlerRoles.TARGET:
			return `T${id}`
		default:
			invariant(false, `Unknown role: ${role}`)
	}
}

function parseRoleFromHandlerId(handlerId) {
	switch (handlerId[0]) {
		case 'S':
			return HandlerRoles.SOURCE
		case 'T':
			return HandlerRoles.TARGET
		default:
			invariant(false, `Cannot parse handler ID: ${handlerId}`)
	}
}

export default class HandlerRegistry {
	constructor(store) {
		this.store = store

		this.types = {}
		this.handlers = {}

		this.pinnedSourceId = null
		this.pinnedSource = null
	}

	addSource(type, source) {
		validateType(type)
		validateSourceContract(source)

		const sourceId = this.addHandler(HandlerRoles.SOURCE, type, source)
		this.store.dispatch(addSource(sourceId))
		return sourceId
	}

	addTarget(type, target) {
		validateType(type, true)
		validateTargetContract(target)

		const targetId = this.addHandler(HandlerRoles.TARGET, type, target)
		this.store.dispatch(addTarget(targetId))
		return targetId
	}

	addHandler(role, type, handler) {
		const id = getNextHandlerId(role)
		this.types[id] = type
		this.handlers[id] = handler

		return id
	}

	containsHandler(handler) {
		return Object.keys(this.handlers).some(
			key => this.handlers[key] === handler,
		)
	}

	getSource(sourceId, includePinned) {
		invariant(this.isSourceId(sourceId), 'Expected a valid source ID.')

		const isPinned = includePinned && sourceId === this.pinnedSourceId
		const source = isPinned ? this.pinnedSource : this.handlers[sourceId]

		return source
	}

	getTarget(targetId) {
		invariant(this.isTargetId(targetId), 'Expected a valid target ID.')
		return this.handlers[targetId]
	}

	getSourceType(sourceId) {
		invariant(this.isSourceId(sourceId), 'Expected a valid source ID.')
		return this.types[sourceId]
	}

	getTargetType(targetId) {
		invariant(this.isTargetId(targetId), 'Expected a valid target ID.')
		return this.types[targetId]
	}

	isSourceId(handlerId) {
		const role = parseRoleFromHandlerId(handlerId)
		return role === HandlerRoles.SOURCE
	}

	isTargetId(handlerId) {
		const role = parseRoleFromHandlerId(handlerId)
		return role === HandlerRoles.TARGET
	}

	removeSource(sourceId) {
		invariant(this.getSource(sourceId), 'Expected an existing source.')
		this.store.dispatch(removeSource(sourceId))

		asap(() => {
			delete this.handlers[sourceId]
			delete this.types[sourceId]
		})
	}

	removeTarget(targetId) {
		invariant(this.getTarget(targetId), 'Expected an existing target.')
		this.store.dispatch(removeTarget(targetId))

		asap(() => {
			delete this.handlers[targetId]
			delete this.types[targetId]
		})
	}

	pinSource(sourceId) {
		const source = this.getSource(sourceId)
		invariant(source, 'Expected an existing source.')

		this.pinnedSourceId = sourceId
		this.pinnedSource = source
	}

	unpinSource() {
		invariant(this.pinnedSource, 'No source is pinned at the time.')

		this.pinnedSourceId = null
		this.pinnedSource = null
	}
}