vue3-dnd/dist/esm/core/DndProvider.js

Drag and Drop for Vue Composition API

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 _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
}
function _iterableToArrayLimit(arr, i) {
    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
    if (_i == null) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _s, _e;
    try {
        for(_i = _i.call(arr); !(_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 _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 _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
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(n);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
import { defineComponent, onUnmounted } from "vue-demi";
import { useDndContextProvider } from "./DndContext";
import { createDragDropManager } from "dnd-core";
var refCount = 0;
var INSTANCE_SYM = Symbol.for("__VUE_DND_CONTEXT_INSTANCE__");
function isManagerProps(props) {
    return "manager" in props && props.manager;
}
function getDndContextValue(props) {
    if (isManagerProps(props)) {
        var manager = props.manager;
        return [
            manager,
            false
        ];
    }
    var manager1 = createSingletonDndContext(props.backend, props.context, props.options, props.debugMode);
    var isGlobalInstance = !props.context;
    return [
        manager1,
        isGlobalInstance
    ];
}
function createSingletonDndContext(backend) {
    var context = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getGlobalContext(), options = arguments.length > 2 ? arguments[2] : void 0, debugMode = arguments.length > 3 ? arguments[3] : void 0;
    var ctx = context;
    if (!ctx[INSTANCE_SYM]) {
        ctx[INSTANCE_SYM] = createDragDropManager(backend, context, options, debugMode);
    }
    return ctx[INSTANCE_SYM];
}
function getGlobalContext() {
    return typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : window;
}
export default defineComponent({
    name: "DndProvider",
    props: {
        manager: {
            type: Object
        },
        backend: {
            type: Function
        },
        context: {
            type: Object
        },
        options: {
            type: Object
        },
        debugMode: {
            type: Boolean
        }
    },
    setup: function setup(props, param) {
        var slots = param.slots;
        var ref2 = _slicedToArray(getDndContextValue(props), 2), manager = ref2[0], isGlobalInstance = ref2[1];
        if (isGlobalInstance) {
            ++refCount;
        }
        onUnmounted(function() {
            if (isGlobalInstance) {
                var context = getGlobalContext();
                if (--refCount === 0) {
                    context[INSTANCE_SYM] = null;
                }
            }
        });
        useDndContextProvider(manager);
        var ref1;
        return function() {
            var ref;
            return (ref1 = (ref = slots.default) === null || ref === void 0 ? void 0 : ref.call(slots)) !== null && ref1 !== void 0 ? ref1 : null;
        };
    }
});