@kp-ui/lowcode 1.0.25 → 1.0.26

package/src/lib/vuedraggable/src/core/componentStructure.js

@@ -1,46 +1,63 @@
-var a = function(t) {
-  var n = t.el || Array.isArray(t.children) && t.children[0].el.parentNode;
-  return n || console.error("使用 transition-group , 需要在slot中template内至少2层html标签"), n || {};
+var getHtmlElementFromNode = function getHtmlElementFromNode2(node) {
+  var el = node.el || Array.isArray(node.children) && node.children[0].el.parentNode;
+  if (!el) {
+    console.error("使用 transition-group , 需要在slot中template内至少2层html标签");
+  }
+  return el || {};
 };
-const u = (i, t) => i.__draggable_context = t, c = (i) => i.__draggable_context;
-class g {
-  constructor({ nodes: { header: t, default: n, footer: o }, root: e, realList: r }) {
-    this.defaultNodes = n, this.children = [...t, ...n, ...o], this.externalComponent = e.externalComponent, this.rootTransition = e.transition, this.tag = e.tag, this.realList = r;
+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(t, n) {
-    const { tag: o, children: e, _isRootComponent: r } = this;
-    return t(o, n, r ? { default: () => e } : e);
+  render(h, attributes) {
+    const { tag, children, _isRootComponent } = this;
+    const option = !_isRootComponent ? children : { default: () => children };
+    return h(tag, attributes, option);
   }
   updated() {
-    const { defaultNodes: t, realList: n } = this;
-    t.forEach((o, e) => {
-      u(a(o), {
-        element: n[e],
-        index: e
+    const { defaultNodes, realList } = this;
+    defaultNodes.forEach((node, index) => {
+      addContext(getHtmlElementFromNode(node), {
+        element: realList[index],
+        index
       });
     });
   }
-  getUnderlyingVm(t) {
-    return c(t);
+  getUnderlyingVm(domElement) {
+    return getContext(domElement);
   }
-  getVmIndexFromDomIndex(t, n) {
-    const { defaultNodes: o } = this, { length: e } = o, r = n.children, s = r.item(t);
-    if (s === null)
-      return e;
-    const l = c(s);
-    if (l)
-      return l.index;
-    if (e === 0)
+  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 d = a(o[0]), m = [...r].findIndex(
-      (h) => h === d
+    }
+    const firstDomListElement = getHtmlElementFromNode(defaultNodes[0]);
+    const indexFirstDomListElement = [...domChildren].findIndex(
+      (element2) => element2 === firstDomListElement
     );
-    return t < m ? 0 : e;
+    return domIndex < indexFirstDomListElement ? 0 : length;
   }
 }
 export {
-  g as ComponentStructure
+  ComponentStructure
 };

package/src/lib/vuedraggable/src/core/renderHelper.js

@@ -1,39 +1,49 @@
-import { ComponentStructure as p } from "./componentStructure.js";
-import { isTransition as l, isHtmlTag as f } from "../util/tags.js";
-import { resolveComponent as d, TransitionGroup as h } from "vue";
-function g(t, n) {
-  const o = t[n];
-  return o ? o() : [];
+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 w({ $slots: t, realList: n, getKey: o }) {
-  const r = n || [], [a, i] = ["header", "footer"].map(
-    (e) => g(t, e)
-  ), { item: m } = t;
-  if (!m)
+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 u = r.flatMap(
-    (e, c) => m({ element: e, index: c }).map((s) => (s.key = o(e), s.props = { ...s.props || {}, "data-draggable": !0 }, s))
+  }
+  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 (u.length !== r.length)
+  if (defaultNodes.length !== normalizedList.length) {
     throw new Error("Item slot must have only one child");
+  }
   return {
-    header: a,
-    footer: i,
-    default: u
+    header,
+    footer,
+    default: defaultNodes
   };
 }
-function C(t) {
-  const n = l(t), o = !f(t) && !n;
+function getRootInformation(tag) {
+  const transition = isTransition(tag);
+  const externalComponent = !isHtmlTag(tag) && !transition;
   return {
-    transition: n,
-    externalComponent: o,
-    tag: o ? d(t) : n ? h : t
+    transition,
+    externalComponent,
+    tag: externalComponent ? resolveComponent(tag) : transition ? TransitionGroup : tag
   };
 }
-function b({ $slots: t, tag: n, realList: o, getKey: r }) {
-  const a = w({ $slots: t, realList: o, getKey: r }), i = C(n);
-  return new p({ nodes: a, root: i, realList: o });
+function computeComponentStructure({ $slots, tag, realList, getKey }) {
+  const nodes = computeNodes({ $slots, realList, getKey });
+  const root = getRootInformation(tag);
+  return new ComponentStructure({ nodes, root, realList });
 }
 export {
-  b as computeComponentStructure
+  computeComponentStructure
 };

package/src/lib/vuedraggable/src/core/sortableEvents.js

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

package/src/lib/vuedraggable/src/util/console.js

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

package/src/lib/vuedraggable/src/util/htmlHelper.js

@@ -1,11 +1,13 @@
-function i(e) {
-  e.parentElement !== null && e.parentElement.removeChild(e);
+function removeNode(node) {
+  if (node.parentElement !== null) {
+    node.parentElement.removeChild(node);
+  }
 }
-function l(e, r, n) {
-  const t = n === 0 ? e.children[0] : e.children[n - 1].nextSibling;
-  e.insertBefore(r, t);
+function insertNodeAt(fatherNode, node, position) {
+  const refNode = position === 0 ? fatherNode.children[0] : fatherNode.children[position - 1].nextSibling;
+  fatherNode.insertBefore(node, refNode);
 }
 export {
-  l as insertNodeAt,
-  i as removeNode
+  insertNodeAt,
+  removeNode
 };

package/src/lib/vuedraggable/src/util/string.js

@@ -1,10 +1,12 @@
-function o(e) {
-  const c = /* @__PURE__ */ Object.create(null);
-  return function(n) {
-    return c[n] || (c[n] = e(n));
+function cached(fn) {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return function cachedFn(str) {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
   };
 }
-const a = /-(\w)/g, h = o((e) => e.replace(a, (c, t) => t.toUpperCase()));
+const regex = /-(\w)/g;
+const camelize = cached((str) => str.replace(regex, (_, c) => c.toUpperCase()));
 export {
-  h as camelize
+  camelize
 };

package/src/lib/vuedraggable/src/util/tags.js

@@ -1,4 +1,4 @@
-const e = [
+const tags = [
   "a",
   "abbr",
   "address",
@@ -117,17 +117,17 @@ const e = [
   "video",
   "wbr"
 ];
-function r(t) {
-  return e.includes(t);
+function isHtmlTag(name) {
+  return tags.includes(name);
 }
-function a(t) {
-  return ["transition-group", "TransitionGroup"].includes(t);
+function isTransition(name) {
+  return ["transition-group", "TransitionGroup"].includes(name);
 }
-function i(t) {
-  return ["id", "class", "role", "style"].includes(t) || t.startsWith("data-") || t.startsWith("aria-") || t.startsWith("on");
+function isHtmlAttribute(value) {
+  return ["id", "class", "role", "style"].includes(value) || value.startsWith("data-") || value.startsWith("aria-") || value.startsWith("on");
 }
 export {
-  i as isHtmlAttribute,
-  r as isHtmlTag,
-  a as isTransition
+  isHtmlAttribute,
+  isHtmlTag,
+  isTransition
 };