cnhis-design-vue 3.3.1-beta.9 → 3.3.1-release.4

package/es/shared/components/TextOverTooltip/index.js

@@ -1 +1,2 @@
-import e from"./TextOverTooltip.vue.js";export{default}from"./TextOverTooltip.vue.js";
+import script from './TextOverTooltip.vue.js';
+export { default } from './TextOverTooltip.vue.js';

package/es/shared/components/VueDraggable/index.js

@@ -1 +1,2 @@
-import r from"./src/vuedraggable.js";export{default}from"./src/vuedraggable.js";
+import draggableComponent from './src/vuedraggable.js';
+export { default } from './src/vuedraggable.js';

package/es/shared/components/VueDraggable/src/core/componentBuilderHelper.js

@@ -1 +1,35 @@
-import{camelize as t}from"../util/string.js";import{events as r,isReadOnly as e}from"./sortableEvents.js";import{isHtmlAttribute as n}from"../util/tags.js";function a(t){return t.reduce(((t,[r,e])=>(t[r]=e,t)),{})}function o({$attrs:t,componentData:r={}}){return{...a(Object.entries(t).filter((([t,r])=>n(t)))),...r}}function i({$attrs:t,callBackBuilder:e}){const n=a(c(t));Object.entries(e).forEach((([t,e])=>{r[t].forEach((t=>{n[`on${t}`]=e(t)}))}));const o=`[data-draggable]${n.draggable||""}`;return{...n,draggable:o}}function c(r){return Object.entries(r).filter((([t,r])=>!n(t))).map((([r,e])=>[t(r),e])).filter((([t,r])=>!e(t)))}export{i as createSortableOption,o as getComponentAttributes,c as getValidSortableEntries};
+import { camelize } from '../util/string.js';
+import { events, isReadOnly } from './sortableEvents.js';
+import { isHtmlAttribute } from '../util/tags.js';
+
+function project(entries) {
+  return entries.reduce((res, [key, value]) => {
+    res[key] = value;
+    return res;
+  }, {});
+}
+function getComponentAttributes({ $attrs, componentData = {} }) {
+  const attributes = project(Object.entries($attrs).filter(([key, _]) => isHtmlAttribute(key)));
+  return {
+    ...attributes,
+    ...componentData
+  };
+}
+function createSortableOption({ $attrs, callBackBuilder }) {
+  const options = project(getValidSortableEntries($attrs));
+  Object.entries(callBackBuilder).forEach(([eventType, eventBuilder]) => {
+    events[eventType].forEach((event) => {
+      options[`on${event}`] = eventBuilder(event);
+    });
+  });
+  const draggable = `[data-draggable]${options.draggable || ""}`;
+  return {
+    ...options,
+    draggable
+  };
+}
+function getValidSortableEntries(value) {
+  return Object.entries(value).filter(([key, _]) => !isHtmlAttribute(key)).map(([key, value2]) => [camelize(key), value2]).filter(([key, _]) => !isReadOnly(key));
+}
+
+export { createSortableOption, getComponentAttributes, getValidSortableEntries };

package/es/shared/components/VueDraggable/src/core/componentStructure.js

@@ -1 +1,54 @@
-const t=({el:t})=>t,e=t=>t.__draggable_context;class n{constructor({nodes:{header:t,default:e,footer:n},root:o,realList:r}){this.defaultNodes=e,this.children=[...t,...e,...n],this.externalComponent=o.externalComponent,this.rootTransition=o.transition,this.tag=o.tag,this.realList=r}get _isRootComponent(){return this.externalComponent||this.rootTransition}render(t,e){const{tag:n,children:o,_isRootComponent:r}=this;return t(n,e,r?{default:()=>o}:o)}updated(){const{defaultNodes:e,realList:n}=this;e.forEach(((e,o)=>{var r,i;r=t(e),i={element:n[o],index:o},r.__draggable_context=i}))}getUnderlyingVm(t){return e(t)}getVmIndexFromDomIndex(n,o){const{defaultNodes:r}=this,{length:i}=r,s=o.children,a=s.item(n);if(null===a)return i;const d=e(a);if(d)return d.index;if(0===i)return 0;const l=t(r[0]);return n<[...s].findIndex((t=>t===l))?0:i}}export{n as ComponentStructure};
+const getHtmlElementFromNode = ({ el }) => el;
+const addContext = (domElement, context) => domElement.__draggable_context = context;
+const getContext = (domElement) => domElement.__draggable_context;
+class ComponentStructure {
+  constructor({ nodes: { header, default: defaultNodes, footer }, root, realList }) {
+    this.defaultNodes = defaultNodes;
+    this.children = [...header, ...defaultNodes, ...footer];
+    this.externalComponent = root.externalComponent;
+    this.rootTransition = root.transition;
+    this.tag = root.tag;
+    this.realList = realList;
+  }
+  get _isRootComponent() {
+    return this.externalComponent || this.rootTransition;
+  }
+  render(h, attributes) {
+    const { tag, children, _isRootComponent } = this;
+    const option = !_isRootComponent ? children : { default: () => children };
+    return h(tag, attributes, option);
+  }
+  updated() {
+    const { defaultNodes, realList } = this;
+    defaultNodes.forEach((node, index) => {
+      addContext(getHtmlElementFromNode(node), {
+        element: realList[index],
+        index
+      });
+    });
+  }
+  getUnderlyingVm(domElement) {
+    return getContext(domElement);
+  }
+  getVmIndexFromDomIndex(domIndex, element) {
+    const { defaultNodes } = this;
+    const { length } = defaultNodes;
+    const domChildren = element.children;
+    const domElement = domChildren.item(domIndex);
+    if (domElement === null) {
+      return length;
+    }
+    const context = getContext(domElement);
+    if (context) {
+      return context.index;
+    }
+    if (length === 0) {
+      return 0;
+    }
+    const firstDomListElement = getHtmlElementFromNode(defaultNodes[0]);
+    const indexFirstDomListElement = [...domChildren].findIndex((element2) => element2 === firstDomListElement);
+    return domIndex < indexFirstDomListElement ? 0 : length;
+  }
+}
+
+export { ComponentStructure };

package/es/shared/components/VueDraggable/src/core/renderHelper.js

@@ -1 +1,47 @@
-import{ComponentStructure as t}from"./componentStructure.js";import{isTransition as e,isHtmlTag as o}from"../util/tags.js";import{resolveComponent as r,TransitionGroup as n}from"vue";function s({$slots:s,tag:a,realList:l,getKey:i}){const m=function({$slots:t,realList:e,getKey:o}){const r=e||[],[n,s]=["header","footer"].map((e=>function(t,e){const o=t[e];return o?o():[]}(t,e))),{item:a}=t;if(!a)throw new Error("draggable element must have an item slot");const l=r.flatMap(((t,e)=>a({element:t,index:e}).map((e=>(e.key=o(t),e.props={...e.props||{},"data-draggable":!0},e)))));if(l.length!==r.length)throw new Error("Item slot must have only one child");return{header:n,footer:s,default:l}}({$slots:s,realList:l,getKey:i}),u=function(t){const s=e(t),a=!o(t)&&!s;return{transition:s,externalComponent:a,tag:a?r(t):s?n:t}}(a);return new t({nodes:m,root:u,realList:l})}export{s as computeComponentStructure};
+import { ComponentStructure } from './componentStructure.js';
+import { isTransition, isHtmlTag } from '../util/tags.js';
+import { resolveComponent, TransitionGroup } from 'vue';
+
+function getSlot(slots, key) {
+  const slotValue = slots[key];
+  return slotValue ? slotValue() : [];
+}
+function computeNodes({ $slots, realList, getKey }) {
+  const normalizedList = realList || [];
+  const [header, footer] = ["header", "footer"].map((name) => getSlot($slots, name));
+  const { item } = $slots;
+  if (!item) {
+    throw new Error("draggable element must have an item slot");
+  }
+  const defaultNodes = normalizedList.flatMap(
+    (element, index) => item({ element, index }).map((node) => {
+      node.key = getKey(element);
+      node.props = { ...node.props || {}, "data-draggable": true };
+      return node;
+    })
+  );
+  if (defaultNodes.length !== normalizedList.length) {
+    throw new Error("Item slot must have only one child");
+  }
+  return {
+    header,
+    footer,
+    default: defaultNodes
+  };
+}
+function getRootInformation(tag) {
+  const transition = isTransition(tag);
+  const externalComponent = !isHtmlTag(tag) && !transition;
+  return {
+    transition,
+    externalComponent,
+    tag: externalComponent ? resolveComponent(tag) : transition ? TransitionGroup : tag
+  };
+}
+function computeComponentStructure({ $slots, tag, realList, getKey }) {
+  const nodes = computeNodes({ $slots, realList, getKey });
+  const root = getRootInformation(tag);
+  return new ComponentStructure({ nodes, root, realList });
+}
+
+export { computeComponentStructure };

package/es/shared/components/VueDraggable/src/core/sortableEvents.js

@@ -1 +1,14 @@
-const e=["Start","Add","Remove","Update","End"],n=["Choose","Unchoose","Sort","Filter","Clone"],o=["Move"],t=[o,e,n].flatMap((e=>e)).map((e=>`on${e}`)),a={manage:o,manageAndEmit:e,emit:n};function d(e){return-1!==t.indexOf(e)}export{a as events,d as isReadOnly};
+const manageAndEmit = ["Start", "Add", "Remove", "Update", "End"];
+const emit = ["Choose", "Unchoose", "Sort", "Filter", "Clone"];
+const manage = ["Move"];
+const eventHandlerNames = [manage, manageAndEmit, emit].flatMap((events2) => events2).map((evt) => `on${evt}`);
+const events = {
+  manage,
+  manageAndEmit,
+  emit
+};
+function isReadOnly(eventName) {
+  return eventHandlerNames.indexOf(eventName) !== -1;
+}
+
+export { events, isReadOnly };

package/es/shared/components/VueDraggable/src/util/console.js

@@ -1 +1,9 @@
-const o="undefined"!=typeof window?window.console:global.console;export{o as console};
+function getConsole() {
+  if (typeof window !== "undefined") {
+    return window.console;
+  }
+  return global.console;
+}
+const console = getConsole();
+
+export { console };

package/es/shared/components/VueDraggable/src/util/htmlHelper.js

@@ -1 +1,11 @@
-function e(e){null!==e.parentElement&&e.parentElement.removeChild(e)}function n(e,n,t){const i=0===t?e.children[0]:e.children[t-1].nextSibling;e.insertBefore(n,i)}export{n as insertNodeAt,e as removeNode};
+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);
+}
+
+export { insertNodeAt, removeNode };

package/es/shared/components/VueDraggable/src/util/string.js

@@ -1 +1,11 @@
-const e=/-(\w)/g,t=function(e){const t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}((t=>t.replace(e,((e,t)=>t.toUpperCase()))));export{t as camelize};
+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.toUpperCase()));
+
+export { camelize };

package/es/shared/components/VueDraggable/src/util/tags.js

@@ -1 +1,130 @@
-const t=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","iframe","img","input","ins","kbd","label","legend","li","link","main","map","mark","math","menu","menuitem","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","param","picture","pre","progress","q","rb","rp","rt","rtc","ruby","s","samp","script","section","select","slot","small","source","span","strong","style","sub","summary","sup","svg","table","tbody","td","template","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr"];function e(e){return t.includes(e)}function a(t){return["transition-group","TransitionGroup"].includes(t)}function r(t){return["id","class","role","style"].includes(t)||t.startsWith("data-")||t.startsWith("aria-")||t.startsWith("on")}export{r as isHtmlAttribute,e as isHtmlTag,a as isTransition};
+const tags = [
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "math",
+  "menu",
+  "menuitem",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "param",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rb",
+  "rp",
+  "rt",
+  "rtc",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "section",
+  "select",
+  "slot",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "svg",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr"
+];
+function isHtmlTag(name) {
+  return tags.includes(name);
+}
+function isTransition(name) {
+  return ["transition-group", "TransitionGroup"].includes(name);
+}
+function isHtmlAttribute(value) {
+  return ["id", "class", "role", "style"].includes(value) || value.startsWith("data-") || value.startsWith("aria-") || value.startsWith("on");
+}
+
+export { isHtmlAttribute, isHtmlTag, isTransition };

package/es/shared/components/VueDraggable/src/vuedraggable.js

@@ -1 +1,265 @@
-import e from"sortablejs";import{removeNode as t,insertNodeAt as n}from"./util/htmlHelper.js";import{console as r}from"./util/console.js";import{getComponentAttributes as o,createSortableOption as i,getValidSortableEntries as s}from"./core/componentBuilderHelper.js";import{computeComponentStructure as l}from"./core/renderHelper.js";import{events as a}from"./core/sortableEvents.js";import{defineComponent as m,h as d,nextTick as u}from"vue";function c(e,t){u((()=>this.$emit(e.toLowerCase(),t)))}function h(e){return(t,n)=>{if(null!==this.realList)return this[`onDrag${e}`](t,n)}}function p(e){const t=h.call(this,e);return(n,r)=>{t.call(this,n,r),c.call(this,e,n)}}let g=null;const x=m({name:"draggable",inheritAttrs:!1,props:{list:{type:Array,required:!1,default:null},modelValue:{type:Array,required:!1,default:null},itemKey:{type:[String,Function],required:!0},clone:{type:Function,default:e=>e},tag:{type:String,default:"div"},move:{type:Function,default:null},componentData:{type:Object,required:!1,default:null}},emits:["update:modelValue","change",...[...a.manageAndEmit,...a.emit].map((e=>e.toLowerCase()))],data:()=>({error:!1}),render(){try{this.error=!1;const{$slots:e,$attrs:t,tag:n,componentData:r,realList:i,getKey:s}=this,a=l({$slots:e,tag:n,realList:i,getKey:s});this.componentStructure=a;const m=o({$attrs:t,componentData:r});return a.render(d,m)}catch(e){return this.error=!0,d("pre",{style:{color:"red"}},e.stack)}},created(){null!==this.list&&null!==this.modelValue&&r.error("modelValue and list props are mutually exclusive! Please set one or another.")},mounted(){if(this.error)return;const{$attrs:t,$el:n,componentStructure:r}=this;r.updated();const o=i({$attrs:t,callBackBuilder:{manageAndEmit:e=>p.call(this,e),emit:e=>c.bind(this,e),manage:e=>h.call(this,e)}}),s=1===n.nodeType?n:n.parentElement;this._sortable=new e(s,o),this.targetDomElement=s,s.__draggable_component__=this},updated(){this.componentStructure.updated()},beforeUnmount(){void 0!==this._sortable&&this._sortable.destroy()},computed:{realList(){const{list:e}=this;return e||this.modelValue},getKey(){const{itemKey:e}=this;return"function"==typeof e?e:t=>t[e]}},watch:{$attrs:{handler(e){const{_sortable:t}=this;t&&s(e).forEach((([e,n])=>{t.option(e,n)}))},deep:!0}},methods:{getUnderlyingVm(e){return this.componentStructure.getUnderlyingVm(e)||null},getUnderlyingPotencialDraggableComponent:e=>e.__draggable_component__,emitChanges(e){u((()=>this.$emit("change",e)))},alterList(e){if(this.list)return void e(this.list);const t=[...this.modelValue];e(t),this.$emit("update:modelValue",t)},spliceList(){this.alterList((e=>e.splice(...arguments)))},updatePosition(e,t){this.alterList((n=>n.splice(t,0,n.splice(e,1)[0])))},getRelatedContextFromMoveEvent({to:e,related:t}){const n=this.getUnderlyingPotencialDraggableComponent(e);if(!n)return{component:n};const r=n.realList,o={list:r,component:n};if(e!==t&&r){return{...n.getUnderlyingVm(t)||{},...o}}return o},getVmIndexFromDomIndex(e){return this.componentStructure.getVmIndexFromDomIndex(e,this.targetDomElement)},onDragStart(e){this.context=this.getUnderlyingVm(e.item),e.item._underlying_vm_=this.clone(this.context.element),g=e.item},onDragAdd(e){const n=e.item._underlying_vm_;if(void 0===n)return;t(e.item);const r=this.getVmIndexFromDomIndex(e.newIndex);this.spliceList(r,0,n);const o={element:n,newIndex:r};this.emitChanges({added:o})},onDragRemove(e){if(n(this.$el,e.item,e.oldIndex),"clone"===e.pullMode)return void t(e.clone);const{index:r,element:o}=this.context;this.spliceList(r,1);const i={element:o,oldIndex:r};this.emitChanges({removed:i})},onDragUpdate(e){t(e.item),n(e.from,e.item,e.oldIndex);const r=this.context.index,o=this.getVmIndexFromDomIndex(e.newIndex);this.updatePosition(r,o);const i={element:this.context.element,oldIndex:r,newIndex:o};this.emitChanges({moved:i})},computeFutureIndex(e,t){if(!e.element)return 0;const n=[...t.to.children].filter((e=>"none"!==e.style.display)),r=n.indexOf(t.related),o=e.component.getVmIndexFromDomIndex(r);return-1!==n.indexOf(g)||!t.willInsertAfter?o:o+1},onDragMove(e,t){const{move:n,realList:r}=this;if(!n||!r)return!0;const o=this.getRelatedContextFromMoveEvent(e),i=this.computeFutureIndex(o,e),s={...this.context,futureIndex:i};return n({...e,relatedContext:o,draggedContext:s},t)},onDragEnd(){g=null}}});export{x as default};
+import Sortable from 'sortablejs';
+import { removeNode, insertNodeAt } from './util/htmlHelper.js';
+import { console } from './util/console.js';
+import { getComponentAttributes, createSortableOption, getValidSortableEntries } from './core/componentBuilderHelper.js';
+import { computeComponentStructure } from './core/renderHelper.js';
+import { events } from './core/sortableEvents.js';
+import { defineComponent, h, nextTick } from 'vue';
+
+function emit(evtName, evtData) {
+  nextTick(() => this.$emit(evtName.toLowerCase(), evtData));
+}
+function manage(evtName) {
+  return (evtData, originalElement) => {
+    if (this.realList !== null) {
+      return this[`onDrag${evtName}`](evtData, originalElement);
+    }
+  };
+}
+function manageAndEmit(evtName) {
+  const delegateCallBack = manage.call(this, evtName);
+  return (evtData, originalElement) => {
+    delegateCallBack.call(this, evtData, originalElement);
+    emit.call(this, evtName, evtData);
+  };
+}
+let draggingElement = null;
+const props = {
+  list: {
+    type: Array,
+    required: false,
+    default: null
+  },
+  modelValue: {
+    type: Array,
+    required: false,
+    default: null
+  },
+  itemKey: {
+    type: [String, Function],
+    required: true
+  },
+  clone: {
+    type: Function,
+    default: (original) => {
+      return original;
+    }
+  },
+  tag: {
+    type: String,
+    default: "div"
+  },
+  move: {
+    type: Function,
+    default: null
+  },
+  componentData: {
+    type: Object,
+    required: false,
+    default: null
+  }
+};
+const emits = [
+  "update:modelValue",
+  "change",
+  ...[...events.manageAndEmit, ...events.emit].map((evt) => evt.toLowerCase())
+];
+const draggableComponent = defineComponent({
+  name: "draggable",
+  inheritAttrs: false,
+  props,
+  emits,
+  data() {
+    return {
+      error: false
+    };
+  },
+  render() {
+    try {
+      this.error = false;
+      const { $slots, $attrs, tag, componentData, realList, getKey } = this;
+      const componentStructure = computeComponentStructure({
+        $slots,
+        tag,
+        realList,
+        getKey
+      });
+      this.componentStructure = componentStructure;
+      const attributes = getComponentAttributes({ $attrs, componentData });
+      return componentStructure.render(h, attributes);
+    } catch (err) {
+      this.error = true;
+      return h("pre", { style: { color: "red" } }, err.stack);
+    }
+  },
+  created() {
+    if (this.list !== null && this.modelValue !== null) {
+      console.error("modelValue and list props are mutually exclusive! Please set one or another.");
+    }
+  },
+  mounted() {
+    if (this.error) {
+      return;
+    }
+    const { $attrs, $el, componentStructure } = this;
+    componentStructure.updated();
+    const sortableOptions = createSortableOption({
+      $attrs,
+      callBackBuilder: {
+        manageAndEmit: (event) => manageAndEmit.call(this, event),
+        emit: (event) => emit.bind(this, event),
+        manage: (event) => manage.call(this, event)
+      }
+    });
+    const targetDomElement = $el.nodeType === 1 ? $el : $el.parentElement;
+    this._sortable = new Sortable(targetDomElement, sortableOptions);
+    this.targetDomElement = targetDomElement;
+    targetDomElement.__draggable_component__ = this;
+  },
+  updated() {
+    this.componentStructure.updated();
+  },
+  beforeUnmount() {
+    if (this._sortable !== void 0)
+      this._sortable.destroy();
+  },
+  computed: {
+    realList() {
+      const { list } = this;
+      return list ? list : this.modelValue;
+    },
+    getKey() {
+      const { itemKey } = this;
+      if (typeof itemKey === "function") {
+        return itemKey;
+      }
+      return (element) => element[itemKey];
+    }
+  },
+  watch: {
+    $attrs: {
+      handler(newOptionValue) {
+        const { _sortable } = this;
+        if (!_sortable)
+          return;
+        getValidSortableEntries(newOptionValue).forEach(([key, value]) => {
+          _sortable.option(key, value);
+        });
+      },
+      deep: true
+    }
+  },
+  methods: {
+    getUnderlyingVm(domElement) {
+      return this.componentStructure.getUnderlyingVm(domElement) || null;
+    },
+    getUnderlyingPotencialDraggableComponent(htmElement) {
+      return htmElement.__draggable_component__;
+    },
+    emitChanges(evt) {
+      nextTick(() => this.$emit("change", evt));
+    },
+    alterList(onList) {
+      if (this.list) {
+        onList(this.list);
+        return;
+      }
+      const newList = [...this.modelValue];
+      onList(newList);
+      this.$emit("update:modelValue", newList);
+    },
+    spliceList() {
+      const spliceList = (list) => list.splice(...arguments);
+      this.alterList(spliceList);
+    },
+    updatePosition(oldIndex, newIndex) {
+      const updatePosition = (list) => list.splice(newIndex, 0, list.splice(oldIndex, 1)[0]);
+      this.alterList(updatePosition);
+    },
+    getRelatedContextFromMoveEvent({ to, related }) {
+      const component = this.getUnderlyingPotencialDraggableComponent(to);
+      if (!component) {
+        return { component };
+      }
+      const list = component.realList;
+      const context = { list, component };
+      if (to !== related && list) {
+        const destination = component.getUnderlyingVm(related) || {};
+        return { ...destination, ...context };
+      }
+      return context;
+    },
+    getVmIndexFromDomIndex(domIndex) {
+      return this.componentStructure.getVmIndexFromDomIndex(domIndex, this.targetDomElement);
+    },
+    onDragStart(evt) {
+      this.context = this.getUnderlyingVm(evt.item);
+      evt.item._underlying_vm_ = this.clone(this.context.element);
+      draggingElement = evt.item;
+    },
+    onDragAdd(evt) {
+      const element = evt.item._underlying_vm_;
+      if (element === void 0) {
+        return;
+      }
+      removeNode(evt.item);
+      const newIndex = this.getVmIndexFromDomIndex(evt.newIndex);
+      this.spliceList(newIndex, 0, element);
+      const added = { element, newIndex };
+      this.emitChanges({ added });
+    },
+    onDragRemove(evt) {
+      insertNodeAt(this.$el, evt.item, evt.oldIndex);
+      if (evt.pullMode === "clone") {
+        removeNode(evt.clone);
+        return;
+      }
+      const { index: oldIndex, element } = this.context;
+      this.spliceList(oldIndex, 1);
+      const removed = { element, oldIndex };
+      this.emitChanges({ removed });
+    },
+    onDragUpdate(evt) {
+      removeNode(evt.item);
+      insertNodeAt(evt.from, evt.item, evt.oldIndex);
+      const oldIndex = this.context.index;
+      const newIndex = this.getVmIndexFromDomIndex(evt.newIndex);
+      this.updatePosition(oldIndex, newIndex);
+      const moved = { element: this.context.element, oldIndex, newIndex };
+      this.emitChanges({ moved });
+    },
+    computeFutureIndex(relatedContext, evt) {
+      if (!relatedContext.element) {
+        return 0;
+      }
+      const domChildren = [...evt.to.children].filter((el) => el.style["display"] !== "none");
+      const currentDomIndex = domChildren.indexOf(evt.related);
+      const currentIndex = relatedContext.component.getVmIndexFromDomIndex(currentDomIndex);
+      const draggedInList = domChildren.indexOf(draggingElement) !== -1;
+      return draggedInList || !evt.willInsertAfter ? currentIndex : currentIndex + 1;
+    },
+    onDragMove(evt, originalEvent) {
+      const { move, realList } = this;
+      if (!move || !realList) {
+        return true;
+      }
+      const relatedContext = this.getRelatedContextFromMoveEvent(evt);
+      const futureIndex = this.computeFutureIndex(relatedContext, evt);
+      const draggedContext = {
+        ...this.context,
+        futureIndex
+      };
+      const sendEvent = {
+        ...evt,
+        relatedContext,
+        draggedContext
+      };
+      return move(sendEvent, originalEvent);
+    },
+    onDragEnd() {
+      draggingElement = null;
+    }
+  }
+});
+
+export { draggableComponent as default };

package/es/shared/components/no-data/NoData.vue.js

@@ -1 +1,6 @@
-import e from"./NoData.vue2.js";import r from"../../../_virtual/_plugin-vue_export-helper.js";var a=r(e,[["__file","NoData.vue"]]);export{a as default};
+import _sfc_main from './NoData.vue2.js';
+import _export_sfc from '../../../_virtual/_plugin-vue_export-helper.js';
+
+var script = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "NoData.vue"]]);
+
+export { script as default };