@aplus-frontend/ui 0.5.31 → 0.5.32

package/es/src/path-map.mjs

@@ -97,7 +97,8 @@ const e = {
   EditableGrid: ["ap-grid", "editable"],
   EditableGridFormItem: ["ap-grid", "editable"],
   ApText: ["text"],
-  Mask: ["mask"]
+  Mask: ["mask"],
+  Splitter: ["splitter"]
 };
 export {
   e as default

package/es/src/splitter/Panel.vue.d.ts

@@ -0,0 +1,21 @@
+import { PanelProps } from './interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, CSSProperties, ComponentProvideOptions } from 'vue';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<PanelProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PanelProps> & Readonly<{}>, {
+    style: CSSProperties;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/src/splitter/Panel.vue.mjs

@@ -0,0 +1,4 @@
+import f from "./Panel.vue2.mjs";
+export {
+  f as default
+};

package/es/src/splitter/Panel.vue2.mjs

@@ -0,0 +1,36 @@
+import { defineComponent as n, computed as r, createElementBlock as i, openBlock as p, normalizeStyle as m, normalizeClass as c, unref as s, renderSlot as u } from "vue";
+import "../config-provider/index.mjs";
+import { useNamespace as d } from "../config-provider/hooks/use-namespace.mjs";
+const B = /* @__PURE__ */ n({
+  name: "InternalSplitterPanel",
+  __name: "Panel",
+  props: {
+    className: {},
+    style: { default: () => ({}) },
+    min: {},
+    max: {},
+    size: {},
+    collapsible: { type: [Boolean, Object] },
+    resizable: { type: Boolean },
+    defaultSize: {}
+  },
+  setup(a) {
+    const t = a, { b: l } = d("splitter-panel"), o = r(() => {
+      const e = t.size !== void 0;
+      return {
+        ...t.style,
+        flexBasis: e ? `${t.size}px` : "auto",
+        flexGrow: e ? 0 : 1
+      };
+    });
+    return (e, f) => (p(), i("div", {
+      class: c([s(l)(), { [s(l)("hidden")]: e.size === 0 }, e.className]),
+      style: m(o.value)
+    }, [
+      u(e.$slots, "default")
+    ], 6));
+  }
+});
+export {
+  B as default
+};

package/es/src/splitter/SplitBar.vue.d.ts

@@ -0,0 +1,4 @@
+import { SplitBarProps } from './interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<SplitBarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SplitBarProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/es/src/splitter/SplitBar.vue.mjs

@@ -0,0 +1,4 @@
+import f from "./SplitBar.vue2.mjs";
+export {
+  f as default
+};

package/es/src/splitter/SplitBar.vue2.mjs

@@ -0,0 +1,129 @@
+import { defineComponent as U, ref as z, computed as w, unref as t, watchEffect as V, createElementBlock as h, openBlock as y, normalizeClass as s, createCommentVNode as O, createElementVNode as T, normalizeStyle as F, createVNode as C } from "vue";
+import "../config-provider/index.mjs";
+import { UpOutlined as A, LeftOutlined as D, DownOutlined as I, RightOutlined as R } from "@ant-design/icons-vue";
+import { useNamespace as $ } from "../config-provider/hooks/use-namespace.mjs";
+const j = ["aria-valuenow", "aria-valuemin", "aria-valuemax"], K = /* @__PURE__ */ U({
+  __name: "SplitBar",
+  props: {
+    index: {},
+    active: { type: Boolean },
+    resizable: { type: Boolean },
+    startCollapsible: { type: Boolean },
+    endCollapsible: { type: Boolean },
+    onOffsetStart: { type: Function },
+    onOffsetUpdate: { type: Function },
+    onOffsetEnd: {},
+    onCollapse: { type: Function },
+    vertical: { type: Boolean },
+    ariaNow: {},
+    ariaMin: {},
+    ariaMax: {},
+    lazy: { type: Boolean },
+    containerSize: {}
+  },
+  setup(x) {
+    function g(o) {
+      return typeof o == "number" && !Number.isNaN(o) ? Math.round(o) : 0;
+    }
+    const e = x, { b: n, cssVar: L } = $("splitter-bar"), p = z(null), l = z(0), N = w(
+      () => e.vertical ? 0 : t(l)
+    ), S = w(
+      () => e.vertical ? t(l) : 0
+    ), B = (o) => {
+      e.resizable && o.currentTarget && (p.value = [o.pageX, o.pageY], e.onOffsetStart(e.index));
+    }, k = (o) => {
+      if (e.resizable && o.touches.length === 1) {
+        const a = o.touches[0];
+        p.value = [a.pageX, a.pageY], e.onOffsetStart(e.index);
+      }
+    }, X = (o) => {
+      const { containerSize: a, ariaMax: i, ariaMin: v, ariaNow: m } = e, f = a * m / 100, r = f + o, c = Math.max(0, a * v / 100), d = Math.max(
+        a,
+        a * i / 100
+      );
+      return Math.max(c, Math.min(d, r)) - f;
+    }, b = (o, a) => {
+      const i = X(
+        e.vertical ? a : o
+      );
+      l.value = i;
+    }, M = () => {
+      e.onOffsetUpdate(
+        e.index,
+        t(N),
+        t(S)
+      ), l.value = 0;
+    };
+    V(
+      (o) => {
+        const a = t(p);
+        if (a) {
+          const i = (r) => {
+            const { pageX: c, pageY: d } = r, u = c - a[0], E = d - a[1];
+            e.lazy ? b(u, E) : e.onOffsetUpdate(e.index, u, E);
+          }, v = () => {
+            e.lazy && M(), p.value = null, e.onOffsetEnd();
+          }, m = (r) => {
+            if (r.touches.length === 1) {
+              const c = r.touches[0], d = c.pageX - a[0], u = c.pageY - a[1];
+              e.lazy ? b(d, u) : e.onOffsetUpdate(e.index, d, u);
+            }
+          }, f = () => {
+            e.lazy && M(), p.value = null, e.onOffsetEnd();
+          };
+          window.addEventListener("touchmove", m), window.addEventListener("touchend", f), window.addEventListener("mousemove", i), window.addEventListener("mouseup", v), o(() => {
+            window.removeEventListener("touchmove", m), window.removeEventListener("touchend", f), window.removeEventListener("mousemove", i), window.removeEventListener("mouseup", v);
+          });
+        }
+      },
+      { flush: "post" }
+    );
+    const Y = w(
+      () => e.vertical ? A : D
+    ), P = w(
+      () => e.vertical ? I : R
+    );
+    return (o, a) => (y(), h("div", {
+      class: s(t(n)()),
+      role: "separator",
+      "aria-valuenow": g(e.ariaNow),
+      "aria-valuemin": g(e.ariaMin),
+      "aria-valuemax": g(e.ariaMax)
+    }, [
+      e.lazy ? (y(), h("div", {
+        key: 0,
+        class: s([t(n)("preview"), { [t(n)("preview-active")]: !!l.value }]),
+        style: F(t(L)({ "preview-offset": `${l.value}px` }))
+      }, null, 6)) : O("", !0),
+      T("div", {
+        class: s([
+          t(n)("dragger"),
+          { [t(n)("dragger-disabled")]: !o.resizable, [t(n)("dragger-active")]: o.active }
+        ]),
+        onMousedown: B,
+        onTouchstart: k
+      }, null, 34),
+      o.startCollapsible ? (y(), h("div", {
+        key: 1,
+        class: s([t(n)("collapse-bar"), t(n)("collapse-bar-start")]),
+        onClick: a[0] || (a[0] = () => o.onCollapse(o.index, "start"))
+      }, [
+        C(t(Y), {
+          class: s([t(n)("collapse-icon"), t(n)("collapse-start")])
+        }, null, 8, ["class"])
+      ], 2)) : O("", !0),
+      o.endCollapsible ? (y(), h("div", {
+        key: 2,
+        class: s([t(n)("collapse-bar"), t(n)("collapse-bar-end")]),
+        onClick: a[1] || (a[1] = () => o.onCollapse(o.index, "end"))
+      }, [
+        C(t(P), {
+          class: s([t(n)("collapse-icon"), t(n)("collapse-end")])
+        }, null, 8, ["class"])
+      ], 2)) : O("", !0)
+    ], 10, j));
+  }
+});
+export {
+  K as default
+};

package/es/src/splitter/Splitter.vue.d.ts

@@ -0,0 +1,6 @@
+import { SplitterProps } from './interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<SplitterProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SplitterProps> & Readonly<{}>, {
+    layout: "horizontal" | "vertical";
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/es/src/splitter/Splitter.vue.mjs

@@ -0,0 +1,4 @@
+import f from "./Splitter.vue2.mjs";
+export {
+  f as default
+};

package/es/src/splitter/Splitter.vue2.mjs

@@ -0,0 +1,131 @@
+import { defineComponent as j, ref as q, unref as n, computed as _, createBlock as y, openBlock as i, withCtx as g, createElementVNode as G, normalizeClass as b, normalizeStyle as J, createElementBlock as u, createCommentVNode as h, Fragment as d, renderList as k, createVNode as K, mergeProps as Q, resolveDynamicComponent as T } from "vue";
+import { useItems as X } from "./hooks/useItems.mjs";
+import "../resize-observer/index.mjs";
+import { useSizes as Y } from "./hooks/useSizes.mjs";
+import { useResizable as Z } from "./hooks/useResizable.mjs";
+import { useResize as x } from "./hooks/useResize.mjs";
+import "../config-provider/index.mjs";
+import "./Panel.vue.mjs";
+import "./SplitBar.vue.mjs";
+import { omit as ee } from "lodash-unified";
+import { useNamespace as te } from "../config-provider/hooks/use-namespace.mjs";
+import ae from "../resize-observer/index.vue.mjs";
+import ne from "./Panel.vue2.mjs";
+import oe from "./SplitBar.vue2.mjs";
+const Ce = /* @__PURE__ */ j({
+  __name: "Splitter",
+  props: {
+    prefixCls: {},
+    className: {},
+    style: {},
+    rootClassName: {},
+    layout: { default: "horizontal" },
+    onResizeStart: {},
+    onResize: {},
+    onResizeEnd: {},
+    lazy: { type: Boolean }
+  },
+  setup(E) {
+    const a = E, { b: f } = te("splitter"), l = X(), m = q(), N = (e) => {
+      const { offsetWidth: o, offsetHeight: s } = e.target, t = a.layout === "vertical" ? s : o;
+      m.value !== 0 && (m.value = t);
+    }, [
+      I,
+      p,
+      v,
+      O,
+      P,
+      M
+    ] = Y(l, m), c = Z(l, p, !1), [B, U, $, w, C] = x(
+      l,
+      c,
+      v,
+      m,
+      M,
+      !1
+    ), V = (e) => {
+      var o;
+      B(e), (o = a.onResizeStart) == null || o.call(a, n(p));
+    }, A = (e, o) => {
+      var t;
+      const s = U(e, o);
+      (t = a.onResize) == null || t.call(a, s);
+    }, D = () => {
+      var e;
+      $(), (e = a.onResizeEnd) == null || e.call(a, n(p));
+    }, F = (e, o) => {
+      var t, r;
+      const s = w(e, o);
+      (t = a.onResize) == null || t.call(a, s), (r = a.onResizeEnd) == null || r.call(a, s);
+    }, H = _(() => [f(), a.className, f(a.layout)]), R = _(() => {
+      const e = [];
+      let o = 0;
+      for (let s = 0; s < l.value.length; s += 1)
+        o += n(v)[s], e.push(o);
+      return e;
+    }), z = (e) => {
+      const o = n(R), s = n(O), t = n(P);
+      return {
+        minStart: (o[e - 1] || 0) + s[e],
+        minEnd: (o[e + 1] || 100) - t[e + 1],
+        maxStart: (o[e - 1] || 0) + t[e],
+        maxEnd: (o[e + 1] || 100) - s[e + 1]
+      };
+    };
+    return (e, o) => (i(), y(n(ae), { onResize: N }, {
+      default: g(() => [
+        G("div", {
+          style: J(e.style),
+          class: b(H.value)
+        }, [
+          (i(!0), u(d, null, k(n(l), (s, t) => (i(), u(d, { key: t }, [
+            K(ne, Q({ ref_for: !0 }, n(ee)(s, "_child"), {
+              size: n(I)[t]
+            }), {
+              default: g(() => [
+                (i(!0), u(d, null, k(s._child, (r, S) => (i(), y(T(r), { key: S }))), 128))
+              ]),
+              _: 2
+            }, 1040, ["size"]),
+            n(c)[t] ? (i(), y(oe, {
+              key: 0,
+              lazy: e.lazy,
+              index: t,
+              active: n(C) === t,
+              vertical: e.layout === "vertical",
+              resizable: n(c)[t].resizable,
+              "aria-now": R.value[t] * 100,
+              "aria-min": Math.max(
+                z(t).minStart,
+                z(t).minEnd
+              ) * 100,
+              "aria-max": Math.min(
+                z(t).maxStart,
+                z(t).maxEnd
+              ) * 100,
+              "start-collapsible": n(c)[t].startCollapsible,
+              "end-collapsible": n(c)[t].endCollapsible,
+              "container-size": m.value || 0,
+              onOffsetStart: V,
+              onOffsetUpdate: (r, S, L) => {
+                let W = e.layout === "vertical" ? L : S;
+                A(r, W);
+              },
+              onOffsetEnd: D,
+              onCollapse: F
+            }, null, 8, ["lazy", "index", "active", "vertical", "resizable", "aria-now", "aria-min", "aria-max", "start-collapsible", "end-collapsible", "container-size", "onOffsetUpdate"])) : h("", !0)
+          ], 64))), 128)),
+          typeof n(C) == "number" ? (i(), u("div", {
+            key: 0,
+            "aria-hidden": "",
+            class: b([n(f)("mask"), n(f)(`mask-${e.layout}`)])
+          }, null, 2)) : h("", !0)
+        ], 6)
+      ]),
+      _: 1
+    }));
+  }
+});
+export {
+  Ce as default
+};

package/es/src/splitter/_Panel.vue.d.ts

@@ -0,0 +1,4 @@
+import { PanelProps } from './interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<PanelProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PanelProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/es/src/splitter/_Panel.vue.mjs

@@ -0,0 +1,4 @@
+import f from "./_Panel.vue2.mjs";
+export {
+  f as default
+};

package/es/src/splitter/_Panel.vue2.mjs

@@ -0,0 +1,22 @@
+import { defineComponent as e } from "vue";
+const l = /* @__PURE__ */ e({
+  name: "SplitterPanel",
+  __name: "_Panel",
+  props: {
+    className: {},
+    style: {},
+    min: {},
+    max: {},
+    size: {},
+    collapsible: { type: [Boolean, Object] },
+    resizable: { type: Boolean },
+    defaultSize: {}
+  },
+  setup(a) {
+    return () => {
+    };
+  }
+});
+export {
+  l as default
+};

package/es/src/splitter/hooks/useItems.d.ts

@@ -0,0 +1,10 @@
+import { VNode, ComputedRef } from 'vue';
+import { PanelProps } from '../interface';
+export type ItemType = Omit<PanelProps, 'collapsible'> & {
+    collapsible: {
+        start?: boolean;
+        end?: boolean;
+    };
+    _child: VNode[];
+};
+export declare const useItems: () => ComputedRef<ItemType[]>;

package/es/src/splitter/hooks/useItems.mjs

@@ -0,0 +1,26 @@
+import { useSlots as u, computed as d } from "vue";
+import { genRealChildren as l } from "../../ap-form/item-group/helper.mjs";
+function c(t) {
+  if (t && typeof t == "object")
+    return t;
+  const e = !!t || t === "";
+  return {
+    start: e,
+    end: e
+  };
+}
+const m = () => {
+  const t = u();
+  return d(() => t.default ? l(t.default()).map((r) => {
+    var o, s;
+    const { props: n } = r;
+    return {
+      ...n,
+      collapsible: c(n.collapsible),
+      _child: (s = (o = r.children).default) == null ? void 0 : s.call(o)
+    };
+  }) : []);
+};
+export {
+  m as useItems
+};

package/es/src/splitter/hooks/useResizable.d.ts

@@ -0,0 +1,8 @@
+import { Ref, ComputedRef } from 'vue';
+import { ItemType } from './useItems';
+export type ResizableInfo = {
+    resizable: boolean;
+    startCollapsible: boolean;
+    endCollapsible: boolean;
+};
+export declare const useResizable: (items: Ref<ItemType[]>, pxSizes: Ref<number[]>, isRTL: boolean) => ComputedRef<ResizableInfo[]>;

package/es/src/splitter/hooks/useResizable.mjs

@@ -0,0 +1,37 @@
+import { computed as R, unref as b } from "vue";
+const g = (z, m, n) => R(() => {
+  const o = [], l = b(z), i = b(m);
+  for (let e = 0; e < l.length - 1; e += 1) {
+    const u = l[e], x = l[e + 1], t = i[e], s = i[e + 1], {
+      resizable: d = !0,
+      min: C,
+      collapsible: r
+    } = u, {
+      resizable: v = !0,
+      min: f,
+      collapsible: a
+    } = x, I = (
+      // Both need to be resizable
+      d && v && // Prev is not collapsed and limit min size
+      (t !== 0 || !C) && // Next is not collapsed and limit min size
+      (s !== 0 || !f)
+    ), p = (
+      // Self is collapsible
+      r.end && t > 0 || // Collapsed and can be collapsed
+      a.start && s === 0 && t > 0
+    ), c = (
+      // Self is collapsible
+      a.start && s > 0 || // Collapsed and can be collapsed
+      r.end && t === 0 && s > 0
+    );
+    o[e] = {
+      resizable: I,
+      startCollapsible: !!(n ? c : p),
+      endCollapsible: !!(n ? p : c)
+    };
+  }
+  return o;
+});
+export {
+  g as useResizable
+};

package/es/src/splitter/hooks/useResize.d.ts

@@ -0,0 +1,4 @@
+import { Ref, ComputedRef } from 'vue';
+import { ItemType } from './useItems';
+import { ResizableInfo } from './useResizable';
+export declare const useResize: (items: Ref<ItemType[]>, resizableInfos: Ref<ResizableInfo[]>, percentSizes: Ref<number[]>, containerSize: Ref<number | undefined>, updateSizes: (sizes: number[]) => void, isRTL: boolean) => readonly [(index: number) => void, (index: number, offset: number) => number[], () => void, (index: number, type: "start" | "end") => number[], ComputedRef<number | undefined>];

package/es/src/splitter/hooks/useResize.mjs

@@ -0,0 +1,72 @@
+import { unref as m, computed as P, ref as _ } from "vue";
+import { getPtg as T } from "./useSizes.mjs";
+const J = (j, k, y, L, O, R) => {
+  const a = m(j).map((e) => [e.min, e.max]), x = P(() => m(L) || 0), v = (e) => e * x.value;
+  function l(e, f) {
+    return typeof e == "string" ? v(T(e)) : e ?? f;
+  }
+  const I = _([]), E = [], S = _(null), U = () => m(y).map(v);
+  return [
+    (e) => {
+      I.value = U(), S.value = {
+        index: e,
+        confirmed: !1
+      };
+    },
+    (e, f) => {
+      let n = null;
+      const u = m(S), r = m(I), i = m(x);
+      if ((!u || !u.confirmed) && f !== 0) {
+        if (f > 0)
+          n = e, S.value = {
+            index: e,
+            confirmed: !0
+          };
+        else
+          for (let d = e; d >= 0; d -= 1)
+            if (r[d] > 0 && m(k)[d].resizable) {
+              n = d, S.value = {
+                index: d,
+                confirmed: !0
+              };
+              break;
+            }
+      }
+      const s = n ?? (u == null ? void 0 : u.index) ?? e, t = [...r], c = s + 1, z = l(a[s][0], 0), g = l(a[c][0], 0), p = l(
+        a[s][1],
+        i
+      ), h = l(
+        a[c][1],
+        i
+      );
+      let o = f;
+      return t[s] + o < z && (o = z - t[s]), t[c] - o < g && (o = t[c] - g), t[s] + o > p && (o = p - t[s]), t[c] - o > h && (o = t[c] - h), t[s] += o, t[c] -= o, O(t), t;
+    },
+    () => {
+      S.value = null;
+    },
+    (e, f) => {
+      const n = U(), u = R ? f === "start" ? "end" : "start" : f, r = u === "start" ? e : e + 1, i = u === "start" ? e + 1 : e, s = n[r], t = n[i];
+      if (s !== 0 && t !== 0)
+        n[r] = 0, n[i] += s, E[e] = s;
+      else {
+        const c = m(x), z = s + t, g = l(a[r][0], 0), p = l(
+          a[r][1],
+          c
+        ), h = l(a[i][0], 0), o = l(
+          a[i][1],
+          c
+        ), d = Math.max(g, z - o), b = (Math.min(p, z - h) - d) / 2, C = E[e], M = z - C;
+        C && C <= o && C >= h && M <= p && M >= g ? (n[i] = C, n[r] = M) : (n[r] -= b, n[i] += b);
+      }
+      return O(n), n;
+    },
+    P(() => {
+      var e;
+      return (e = S.value) == null ? void 0 : e.index;
+    })
+  ];
+};
+export {
+  J as useResize
+};

package/es/src/splitter/hooks/useSizes.d.ts

@@ -0,0 +1,4 @@
+import { Ref, ComputedRef } from 'vue';
+import { PanelProps } from '../interface';
+export declare function getPtg(str: string): number;
+export declare const useSizes: (items: Ref<PanelProps[]>, containerSize?: Ref<number | undefined>) => readonly [ ComputedRef<(string | number | undefined)[]>, ComputedRef<number[]>, ComputedRef<number[]>, ComputedRef<number[]>, ComputedRef<number[]>, (nextSizes: (string | number | undefined)[]) => void];

package/es/src/splitter/hooks/useSizes.mjs

@@ -0,0 +1,58 @@
+import { computed as o, unref as r, ref as b } from "vue";
+function c(n) {
+  return typeof n == "string" && n.endsWith("%");
+}
+function p(n) {
+  return Number(n.slice(0, -1)) / 100;
+}
+const I = (n, l) => {
+  const S = o(() => r(n).map((e) => e.size)), f = o(() => r(n).length), a = o(() => r(l) || 0), x = (e) => e * r(a), m = b(
+    r(n).map(
+      (e) => e.defaultSize || e["default-size"]
+    )
+  ), v = o(() => {
+    const e = [];
+    for (let u = 0; u < f.value; u += 1)
+      e[u] = S.value[u] ?? m.value[u];
+    return e;
+  }), z = o(() => {
+    let e = [], u = 0;
+    for (let s = 0; s < f.value; s += 1) {
+      const t = v.value[s];
+      if (c(t))
+        e[s] = p(t);
+      else if (t || t === 0) {
+        const g = Number(t);
+        Number.isNaN(g) || (e[s] = g / a.value);
+      } else
+        u += 1, e[s] = void 0;
+    }
+    const i = e.reduce((s, t) => s + (t || 0), 0);
+    if (i > 1 || !u) {
+      const s = 1 / i;
+      e = e.map((t) => t === void 0 ? 0 : t * s);
+    } else {
+      const s = (1 - i) / u;
+      e = e.map((t) => t === void 0 ? s : t);
+    }
+    return e;
+  }), d = o(() => r(z).map(x)), P = o(
+    () => r(n).map((e) => c(e.min) ? p(e.min) : (e.min || 0) / a.value)
+  ), N = o(
+    () => r(n).map((e) => c(e.max) ? p(e.max) : (e.max || a.value) / a.value)
+  );
+  return [
+    o(() => l != null && l.value ? r(d) : r(v)),
+    d,
+    z,
+    P,
+    N,
+    (e) => {
+      m.value = e;
+    }
+  ];
+};
+export {
+  p as getPtg,
+  I as useSizes
+};

package/es/src/splitter/index.d.ts

@@ -0,0 +1,8 @@
+import { default as SplitterComp } from './Splitter.vue';
+import { default as Panel } from './_Panel.vue';
+type CompoundedComponent = typeof SplitterComp & {
+    Panel: typeof Panel;
+};
+declare const Splitter: CompoundedComponent;
+export { Splitter };
+export * from './interface';

package/es/src/splitter/index.mjs

@@ -0,0 +1,10 @@
+import "./Splitter.vue.mjs";
+import "./_Panel.vue.mjs";
+import "./interface.mjs";
+import m from "./Splitter.vue2.mjs";
+import o from "./_Panel.vue2.mjs";
+const r = m;
+r.Panel = o;
+export {
+  r as Splitter
+};