@ozdao/martyrs 0.2.604 → 0.2.605

package/dist/{node_modules/.pnpm/vue-draggable-next@2.2.1_sortablejs@1.15.6_vue@3.5.13_typescript@5.8.3_ → martyrs/node_modules/.pnpm/vue-draggable-next@2.3.0_sortablejs@1.15.7_vue@3.5.13}/node_modules/vue-draggable-next/dist/vue-draggable-next.esm-bundler.js

@@ -1,9 +1,34 @@
-import { defineComponent, resolveComponent, h } from "vue";
+import { defineComponent, h, ref, computed, getCurrentInstance, onMounted, nextTick, resolveComponent } from "vue";
 /*!
-  * vue-draggable-next v2.2.0
-  * (c) 2023 Anish George
+  * vue-draggable-next v2.3.0
+  * (c) 2025 Anish George
   * @license MIT
   */
+function getConsole() {
+  if (typeof window !== "undefined") {
+    return window.console;
+  }
+  return global.console;
+}
+const console = getConsole();
+function cached(fn) {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return function cachedFn(str) {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+}
+const regex = /-(\w)/g;
+const camelize = cached((str) => str.replace(regex, (_, c) => c ? c.toUpperCase() : ""));
+function removeNode(node) {
+  if (node.parentElement !== null) {
+    node.parentElement.removeChild(node);
+  }
+}
+function insertNodeAt(fatherNode, node, position) {
+  const refNode = position === 0 ? fatherNode.children[0] : fatherNode.children[position - 1].nextSibling;
+  fatherNode.insertBefore(node, refNode);
+}
 /**!
  * Sortable 1.14.0
  * @author	RubaXa   <trash@rubaxa.org>
@@ -2121,31 +2146,6 @@ _extends(Remove, {
 });
 Sortable.mount(new AutoScrollPlugin());
 Sortable.mount(Remove, Revert);
-function getConsole() {
-  if (typeof window !== "undefined") {
-    return window.console;
-  }
-  return global.console;
-}
-const console = getConsole();
-function cached(fn) {
-  const cache = /* @__PURE__ */ Object.create(null);
-  return function cachedFn(str) {
-    const hit = cache[str];
-    return hit || (cache[str] = fn(str));
-  };
-}
-const regex = /-(\w)/g;
-const camelize = cached((str) => str.replace(regex, (_, c) => c ? c.toUpperCase() : ""));
-function removeNode(node) {
-  if (node.parentElement !== null) {
-    node.parentElement.removeChild(node);
-  }
-}
-function insertNodeAt(fatherNode, node, position) {
-  const refNode = position === 0 ? fatherNode.children[0] : fatherNode.children[position - 1].nextSibling;
-  fatherNode.insertBefore(node, refNode);
-}
 function computeVmIndex(vnodes, element) {
   return Object.values(vnodes).indexOf(element);
 }
@@ -2158,17 +2158,6 @@ function computeIndexes(slots, children, isTransition2, footerOffset) {
   const rawIndexes = [...children].map((elt, idx) => idx >= footerIndex ? elmFromNodes.length : elmFromNodes.indexOf(elt));
   return rawIndexes;
 }
-function emit(evtName, evtData) {
-  this.$nextTick(() => this.$emit(evtName.toLowerCase(), evtData));
-}
-function delegateAndEmit(evtName) {
-  return (evtData) => {
-    if (this.realList !== null) {
-      this["onDrag" + evtName](evtData);
-    }
-    emit.call(this, evtName, evtData);
-  };
-}
 function isTransitionName(name) {
   return ["transition-group", "TransitionGroup"].includes(name);
 }
@@ -2192,49 +2181,49 @@ const eventsListened = ["Start", "Add", "Remove", "Update", "End"];
 const eventsToEmit = ["Choose", "Unchoose", "Sort", "Filter", "Clone"];
 const readonlyProperties = ["Move", ...eventsListened, ...eventsToEmit].map((evt) => "on" + evt);
 let draggingElement = null;
-const props = {
-  options: Object,
-  list: {
-    type: Array,
-    required: false,
-    default: null
-  },
-  noTransitionOnDrag: {
-    type: Boolean,
-    default: false
-  },
-  clone: {
-    type: Function,
-    default: (original) => {
-      return original;
-    }
-  },
-  tag: {
-    type: String,
-    default: "div"
-  },
-  move: {
-    type: Function,
-    default: null
-  },
-  componentData: {
-    type: Object,
-    required: false,
-    default: null
-  },
-  component: {
-    type: String,
-    default: null
-  },
-  modelValue: {
-    type: Array,
-    required: false,
-    default: null
-  }
-};
 const VueDraggableNext = defineComponent({
   name: "VueDraggableNext",
   inheritAttrs: false,
+  props: {
+    options: Object,
+    list: {
+      type: Array,
+      required: false,
+      default: null
+    },
+    noTransitionOnDrag: {
+      type: Boolean,
+      default: false
+    },
+    clone: {
+      type: Function,
+      default: (original) => {
+        return original;
+      }
+    },
+    tag: {
+      type: String,
+      default: "div"
+    },
+    move: {
+      type: Function,
+      default: null
+    },
+    componentData: {
+      type: Object,
+      required: false,
+      default: null
+    },
+    component: {
+      type: String,
+      default: null
+    },
+    modelValue: {
+      type: Array,
+      required: false,
+      default: null
+    }
+  },
   emits: [
     "update:modelValue",
     "move",
@@ -2242,232 +2231,152 @@ const VueDraggableNext = defineComponent({
     ...eventsListened.map((s) => s.toLowerCase()),
     ...eventsToEmit.map((s) => s.toLowerCase())
   ],
-  props,
-  data() {
-    return {
-      transitionMode: false,
-      noneFunctionalComponentMode: false,
-      headerOffset: 0,
-      footerOffset: 0,
-      _sortable: {},
-      visibleIndexes: [],
-      context: {}
-    };
-  },
-  render() {
-    const slots = this.$slots.default ? this.$slots.default() : null;
-    const attrs = getComponentAttributes(this.$attrs, this.componentData);
-    if (!slots)
-      return h(this.getTag(), attrs, []);
-    this.transitionMode = isTransition(slots);
-    return h(this.getTag(), attrs, slots);
-  },
-  created() {
-    if (this.list !== null && this.modelValue !== null) {
-      console.error("list props are mutually exclusive! Please set one.");
-    }
-  },
-  mounted() {
-    const optionsAdded = {};
-    eventsListened.forEach((elt) => {
-      optionsAdded["on" + elt] = delegateAndEmit.call(this, elt);
-    });
-    eventsToEmit.forEach((elt) => {
-      optionsAdded["on" + elt] = emit.bind(this, elt);
-    });
-    const attributes = Object.keys(this.$attrs).reduce((res, key) => {
-      res[camelize(key)] = this.$attrs[key];
-      return res;
-    }, {});
-    const options = Object.assign({}, attributes, optionsAdded, {
-      onMove: (evt, originalEvent) => {
-        return this.onDragMove(evt, originalEvent);
-      }
-    });
-    !("draggable" in options) && (options.draggable = ">*");
-    const targetDomElement = this.$el.nodeType === 1 ? this.$el : this.$el.parentElement;
-    this._sortable = new Sortable(targetDomElement, options);
-    targetDomElement.__draggable_component__ = this;
-    this.computeIndexes();
-  },
-  beforeUnmount() {
-    try {
-      if (this._sortable !== void 0)
-        this._sortable.destroy();
-    } catch (error) {
-    }
-  },
-  computed: {
-    realList() {
-      return this.list ? this.list : this.modelValue;
-    }
-  },
-  watch: {
-    $attrs: {
-      handler(newOptionValue) {
-        this.updateOptions(newOptionValue);
-      },
-      deep: true
-    },
-    realList() {
-      this.computeIndexes();
-    }
-  },
-  methods: {
-    getTag() {
-      return this.component ? resolveComponent(this.component) : this.tag;
-    },
-    updateOptions(newOptionValue) {
-      for (var property in newOptionValue) {
+  setup(props, { emit, slots, attrs }) {
+    const transitionMode = ref(false);
+    const noneFunctionalComponentMode = ref(false);
+    const headerOffset = ref(0);
+    const footerOffset = ref(0);
+    const visibleIndexes = ref([]);
+    const context = ref(null);
+    const sortableInstance = ref(null);
+    const realList = computed(() => props.list ? props.list : props.modelValue);
+    const instance = getCurrentInstance();
+    function getTag() {
+      return props.component ? resolveComponent(props.component) : props.tag;
+    }
+    function updateOptions(newOptionValue) {
+      if (!sortableInstance.value)
+        return;
+      for (const property in newOptionValue) {
         const value = camelize(property);
         if (readonlyProperties.indexOf(value) === -1) {
-          this._sortable.option(value, newOptionValue[property]);
+          sortableInstance.value.option(value, newOptionValue[property]);
         }
       }
-    },
-    getChildrenNodes() {
-      return this.$el.children;
-    },
-    computeIndexes() {
-      this.$nextTick(() => {
-        this.visibleIndexes = computeIndexes(this.getChildrenNodes(), this.$el.children, this.transitionMode, this.footerOffset);
-      });
-    },
-    getUnderlyingVm(htmlElt) {
-      const index2 = computeVmIndex(this.getChildrenNodes() || [], htmlElt);
+    }
+    function getChildrenNodes() {
+      return instance?.proxy?.$el.children || [];
+    }
+    async function computeIndexesFn() {
+      await nextTick();
+      visibleIndexes.value = computeIndexes(getChildrenNodes(), instance?.proxy?.$el.children || [], transitionMode.value, footerOffset.value);
+    }
+    function getUnderlyingVm(htmlElt) {
+      const index2 = computeVmIndex(getChildrenNodes() || [], htmlElt);
       if (index2 === -1) {
         return null;
       }
-      const element = this.realList[index2];
+      const element = realList.value ? realList.value[index2] : null;
       return { index: index2, element };
-    },
-    emitChanges(evt) {
-      this.$nextTick(() => {
-        this.$emit("change", evt);
-      });
-    },
-    alterList(onList) {
-      if (this.list) {
-        onList(this.list);
+    }
+    function emitChanges(evt) {
+      nextTick(() => emit("change", evt));
+    }
+    function alterList(onList) {
+      if (props.list) {
+        onList(props.list);
         return;
       }
-      const newList = [...this.modelValue];
+      const newList = [...props.modelValue || []];
       onList(newList);
-      this.$emit("update:modelValue", newList);
-    },
-    spliceList() {
-      const spliceList = (list) => list.splice(...arguments);
-      this.alterList(spliceList);
-    },
-    updatePosition(oldIndex2, newIndex2) {
-      const updatePosition = (list) => list.splice(newIndex2, 0, list.splice(oldIndex2, 1)[0]);
-      this.alterList(updatePosition);
-    },
-    getVmIndex(domIndex) {
-      const indexes = this.visibleIndexes;
+      emit("update:modelValue", newList);
+    }
+    function spliceList(...args) {
+      const spliceList2 = (list) => list.splice(...args);
+      alterList(spliceList2);
+    }
+    function updatePosition(oldIndex2, newIndex2) {
+      const updatePosition2 = (list) => list.splice(newIndex2, 0, list.splice(oldIndex2, 1)[0]);
+      alterList(updatePosition2);
+    }
+    function getVmIndex(domIndex) {
+      const indexes = visibleIndexes.value;
       const numberIndexes = indexes.length;
       return domIndex > numberIndexes - 1 ? numberIndexes : indexes[domIndex];
-    },
-    getComponent() {
-      return this.$slots.default ? (
-        //@ts-ignore
-        this.$slots.default()[0].componentInstance
-      ) : null;
-    },
-    resetTransitionData(index2) {
-      if (!this.noTransitionOnDrag || !this.transitionMode) {
+    }
+    function getComponent() {
+      if (!slots.default)
+        return null;
+      const sl = slots.default();
+      return sl[0]?.component?.proxy || null;
+    }
+    function resetTransitionData(index2) {
+      if (!props.noTransitionOnDrag || !transitionMode.value)
         return;
+      const nodes = getChildrenNodes();
+      if (nodes[index2]) {
+        nodes[index2].data = null;
       }
-      var nodes = this.getChildrenNodes();
-      nodes[index2].data = null;
-      const transitionContainer = this.getComponent();
-      transitionContainer.children = [];
-      transitionContainer.kept = void 0;
-    },
-    onDragStart(evt) {
-      this.computeIndexes();
-      this.context = this.getUnderlyingVm(evt.item);
-      if (!this.context)
+      const transitionContainer = getComponent();
+      if (transitionContainer) {
+        transitionContainer.children = [];
+        transitionContainer.kept = void 0;
+      }
+    }
+    function onDragStart(evt) {
+      computeIndexesFn();
+      context.value = getUnderlyingVm(evt.item);
+      if (!context.value)
         return;
-      evt.item._underlying_vm_ = this.clone(this.context.element);
+      evt.item._underlying_vm_ = props.clone(context.value.element);
       draggingElement = evt.item;
-    },
-    onDragAdd(evt) {
+    }
+    function onDragAdd(evt) {
       const element = evt.item._underlying_vm_;
-      if (element === void 0) {
+      if (element === void 0)
         return;
-      }
       removeNode(evt.item);
-      const newIndex2 = this.getVmIndex(evt.newIndex);
-      this.spliceList(newIndex2, 0, element);
-      this.computeIndexes();
-      const added = { element, newIndex: newIndex2 };
-      this.emitChanges({ added });
-    },
-    onDragRemove(evt) {
-      insertNodeAt(this.$el, evt.item, evt.oldIndex);
+      const newIndex2 = getVmIndex(evt.newIndex);
+      spliceList(newIndex2, 0, element);
+      computeIndexesFn();
+      emitChanges({ added: { element, newIndex: newIndex2 } });
+    }
+    function onDragRemove(evt) {
+      insertNodeAt(instance?.proxy?.$el, evt.item, evt.oldIndex);
       if (evt.pullMode === "clone") {
         removeNode(evt.clone);
         return;
       }
-      if (!this.context)
+      if (!context.value)
         return;
-      const oldIndex2 = this.context.index;
-      this.spliceList(oldIndex2, 1);
-      const removed = { element: this.context.element, oldIndex: oldIndex2 };
-      this.resetTransitionData(oldIndex2);
-      this.emitChanges({ removed });
-    },
-    onDragUpdate(evt) {
+      const oldIndex2 = context.value.index;
+      spliceList(oldIndex2, 1);
+      resetTransitionData(oldIndex2);
+      emitChanges({ removed: { element: context.value.element, oldIndex: oldIndex2 } });
+    }
+    function onDragUpdate(evt) {
       removeNode(evt.item);
       insertNodeAt(evt.from, evt.item, evt.oldIndex);
-      const oldIndex2 = this.context.index;
-      const newIndex2 = this.getVmIndex(evt.newIndex);
-      this.updatePosition(oldIndex2, newIndex2);
-      const moved2 = { element: this.context.element, oldIndex: oldIndex2, newIndex: newIndex2 };
-      this.emitChanges({ moved: moved2 });
-    },
-    updateProperty(evt, propertyName) {
-      evt.hasOwnProperty(propertyName) && (evt[propertyName] += this.headerOffset);
-    },
-    onDragMove(evt, originalEvent) {
-      const onMove = this.move;
-      if (!onMove || !this.realList) {
-        return true;
-      }
-      const relatedContext = this.getRelatedContextFromMoveEvent(evt);
-      const draggedContext = this.context;
-      const futureIndex = this.computeFutureIndex(relatedContext, evt);
-      Object.assign(draggedContext, { futureIndex });
-      const sendEvt = Object.assign({}, evt, {
-        relatedContext,
-        draggedContext
+      const oldIndex2 = context.value?.index;
+      const newIndex2 = getVmIndex(evt.newIndex);
+      updatePosition(oldIndex2, newIndex2);
+      emitChanges({
+        moved: { element: context.value?.element, oldIndex: oldIndex2, newIndex: newIndex2 }
       });
-      return onMove(sendEvt, originalEvent);
-    },
-    onDragEnd() {
-      this.computeIndexes();
-      draggingElement = null;
-    },
-    getTrargetedComponent(htmElement) {
-      return htmElement.__draggable_component__;
-    },
-    getRelatedContextFromMoveEvent({ to, related }) {
-      const component = this.getTrargetedComponent(to);
+    }
+    function updateProperty(evt, propertyName) {
+      if (Object.prototype.hasOwnProperty.call(evt, propertyName))
+        evt[propertyName] += headerOffset.value;
+    }
+    function getTargetedComponent(htmlElement) {
+      return htmlElement.__draggable_component__;
+    }
+    function getRelatedContextFromMoveEvent({ to, related }) {
+      const component = getTargetedComponent(to);
       if (!component) {
         return { component };
       }
       const list = component.realList;
-      const context = { list, component };
+      const contextLocal = { list, component };
       if (to !== related && list && component.getUnderlyingVm) {
         const destination = component.getUnderlyingVm(related);
         if (destination) {
-          return Object.assign(destination, context);
+          return Object.assign(destination, contextLocal);
         }
       }
-      return context;
-    },
-    computeFutureIndex(relatedContext, evt) {
+      return contextLocal;
+    }
+    function computeFutureIndex(relatedContext, evt) {
       const domChildren = [...evt.to.children].filter((el) => el.style["display"] !== "none");
       if (domChildren.length === 0)
         return 0;
@@ -2476,6 +2385,134 @@ const VueDraggableNext = defineComponent({
       const draggedInList = domChildren.indexOf(draggingElement) !== -1;
       return draggedInList || !evt.willInsertAfter ? currentIndex : currentIndex + 1;
     }
+    const mounted = () => {
+      const optionsAdded = {};
+      eventsListened.forEach((elt) => {
+        optionsAdded["on" + elt] = delegateAndEmit(elt);
+      });
+      eventsToEmit.forEach((elt) => {
+        optionsAdded["on" + elt] = emitEvent.bind(null, elt);
+      });
+      const attributes = Object.keys(attrs).reduce((res, key) => {
+        res[camelize(key)] = attrs[key];
+        return res;
+      }, {});
+      const options = Object.assign({}, attributes, optionsAdded, {
+        onMove: (evt, originalEvent) => {
+          return onDragMove(evt, originalEvent);
+        }
+      });
+      if (!("draggable" in options)) {
+        options.draggable = ">*";
+      }
+      const targetDomElement = instance?.proxy?.$el.nodeType === 1 ? instance.proxy.$el : instance?.proxy?.$el.parentElement || null;
+      if (targetDomElement) {
+        sortableInstance.value = new Sortable(targetDomElement, options);
+        targetDomElement.__draggable_component__ = instance?.proxy;
+        computeIndexesFn();
+      }
+    };
+    function emitEvent(evtName, evtData) {
+      nextTick(() => emit(evtName.toLowerCase(), evtData));
+    }
+    function delegateAndEmit(evtName) {
+      return (evtData) => {
+        if (realList.value !== null) {
+          const handlerName = "onDrag" + evtName;
+          const handler = methods[handlerName];
+          if (handler) {
+            handler(evtData);
+          }
+        }
+        emitEvent(evtName, evtData);
+      };
+    }
+    function onDragMove(evt, originalEvent) {
+      const onMove = props.move;
+      if (!onMove || !realList.value) {
+        return true;
+      }
+      const relatedContext = getRelatedContextFromMoveEvent(evt);
+      const draggedContext = context.value;
+      const futureIndex = computeFutureIndex(relatedContext, evt);
+      if (draggedContext) {
+        Object.assign(draggedContext, { futureIndex });
+      }
+      const sendEvt = Object.assign({}, evt, {
+        relatedContext,
+        draggedContext
+      });
+      return onMove(sendEvt, originalEvent);
+    }
+    function onDragEnd() {
+      computeIndexesFn();
+      draggingElement = null;
+    }
+    const methods = {
+      onDragStart,
+      onDragAdd,
+      onDragRemove,
+      onDragUpdate,
+      onDragMove,
+      onDragEnd
+    };
+    onMounted(() => {
+      mounted();
+    });
+    if (props.list !== null && props.modelValue !== null) {
+      console.error("list props are mutually exclusive! Please set one.");
+    }
+    return {
+      getTag,
+      realList,
+      visibleIndexes,
+      noneFunctionalComponentMode,
+      headerOffset,
+      footerOffset,
+      transitionMode,
+      computeIndexes: computeIndexesFn,
+      updateOptions,
+      getChildrenNodes,
+      getUnderlyingVm,
+      emitChanges,
+      alterList,
+      spliceList,
+      updatePosition,
+      getVmIndex,
+      getComponent,
+      resetTransitionData,
+      onDragStart,
+      onDragAdd,
+      onDragRemove,
+      onDragUpdate,
+      updateProperty,
+      onDragMove,
+      onDragEnd,
+      mounted,
+      context,
+      sortableInstance,
+      getRelatedContextFromMoveEvent,
+      getTargetedComponent,
+      computeFutureIndex
+      // ... other exposed functions as needed
+    };
+  },
+  render() {
+    const tag = this.getTag();
+    const attrs = getComponentAttributes(this.$attrs, this.componentData);
+    if (typeof tag === "string") {
+      const slots = this.$slots.default && typeof this.$slots.default === "function" ? this.$slots.default() : null;
+      if (!slots)
+        return h(tag, attrs, []);
+      this.transitionMode = isTransition(slots);
+      return h(tag, attrs, slots);
+    }
+    const slotFunctions = this.$slots.default ? { default: this.$slots.default } : {};
+    if (this.$slots.default) {
+      const slotResult = typeof this.$slots.default === "function" ? this.$slots.default() : null;
+      this.transitionMode = isTransition(slotResult || []);
+    }
+    return h(tag, attrs, slotFunctions);
   }
 });
 export {