bitboss-ui 2.0.117 → 2.0.118

package/dist/components/ListBox.vue.d.ts

@@ -1,60 +1,56 @@
 import { Option } from '../types/Option';
-type Props = {
-    /**
-     * Sets the listbox in a compact state.
-     */
-    compact?: boolean;
-    options: Option[];
-    open?: boolean;
-    loading?: boolean;
-    transitionDuration?: number;
-    loadingText?: string;
-    noDataText?: string;
-};
-declare function __VLS_template(): {
+declare const _default: <Item = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onOption:unselected"?: ((option: Option) => any) | undefined;
+        readonly "onOption:selected"?: ((option: Option) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onOption:unselected" | "onOption:selected"> & {
+        /**
+         * Sets the listbox in a compact state.
+         */
+        compact?: boolean;
+        options: Option<Item>[];
+        open?: boolean;
+        loading?: boolean;
+        transitionDuration?: number;
+        loadingText?: string;
+        noDataText?: string;
+    }> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        focusNext: () => void;
+        focusPrevious: () => Promise<void>;
+        focusFirst: () => void;
+        focusFirstSelected: () => void;
+        focusLast: () => void;
+        focusLastSelected: () => void;
+        blur: () => void;
+        confirmOption: () => void;
+        focusByHash: (hash: Option["valueHash"]) => void;
+        getHighlighted: () => Option<Item> | undefined;
+    }>): void;
+    attrs: any;
     slots: Partial<Record<"loading", (_: {}) => any>> & Partial<Record<"no-data", (_: {}) => any>> & {
         "options:prepend"?(_: {}): any;
         option?(_: {
             disabled: boolean;
             focused: boolean;
             index: number;
-            item: any;
+            item: Item;
             selected: boolean;
             text: string;
             value: any;
         }): any;
         "options:append"?(_: {}): any;
     };
-    refs: {
-        inner: HTMLDivElement;
+    emit: {
+        (e: "option:selected", option: Option): void;
+        (e: "option:unselected", option: Option): void;
     };
-    attrs: Partial<{}>;
+}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: Awaited<typeof __VLS_setup>;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<Props, {
-    focusNext: () => void;
-    focusPrevious: () => Promise<void>;
-    focusFirst: () => void;
-    focusFirstSelected: () => void;
-    focusLast: () => void;
-    focusLastSelected: () => void;
-    blur: () => void;
-    confirmOption: () => void;
-    focusByHash: (hash: Option["valueHash"]) => void;
-    getHighlighted: () => Option | undefined;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    "option:unselected": (option: Option) => any;
-    "option:selected": (option: Option) => any;
-}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
-    "onOption:unselected"?: ((option: Option) => any) | undefined;
-    "onOption:selected"?: ((option: Option) => any) | undefined;
-}>, {
-    transitionDuration: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/index100.js

@@ -1,16 +1,16 @@
-import { defineComponent as R, mergeModels as b, computed as I, toRef as m, reactive as j, useModel as B, watch as E, openBlock as g, createElementBlock as k, Fragment as H, renderSlot as p, unref as x, createCommentVNode as G, renderList as U } from "vue";
-import { useItemValue as W } from "./index291.js";
-import { isNil as w } from "./index252.js";
-import { indexBy as q } from "./index305.js";
-import { hash as M } from "./index235.js";
-import { useItemsGetter as z } from "./index231.js";
-import { usePrefill as J } from "./index237.js";
-import { useIndexById as K } from "./index232.js";
-import { useBaseOptions as Q } from "./index233.js";
-import { useHashedWatcher as X } from "./index236.js";
-const de = /* @__PURE__ */ R({
+import { defineComponent as D, computed as V, toRef as r, reactive as E, watch as m, ref as L, openBlock as b, createElementBlock as B, Fragment as g, renderSlot as i, unref as P, createCommentVNode as R, renderList as j } from "vue";
+import { useItemValue as G } from "./index269.js";
+import { isNil as k } from "./index252.js";
+import { indexBy as U } from "./index270.js";
+import { hash as p } from "./index231.js";
+import { useItemsGetter as W } from "./index245.js";
+import { usePrefill as q } from "./index250.js";
+import { useIndexById as z } from "./index246.js";
+import { useBaseOptions as J } from "./index247.js";
+import { useHashedWatcher as K } from "./index249.js";
+const oe = /* @__PURE__ */ D({
   __name: "BbRows",
-  props: /* @__PURE__ */ b({
+  props: {
     columns: { default: () => [] },
     dependencies: { default: () => [] },
     depsDebounceTime: { default: 0 },
@@ -21,109 +21,118 @@ const de = /* @__PURE__ */ R({
     max: { default: 1 / 0 },
     modelValue: { default: () => [] },
     multiple: { type: Boolean, default: !0 },
-    selectable: { type: [Boolean, Function] }
-  }, {
-    "unselected-items": {
-      default: () => []
-    },
-    "unselected-itemsModifiers": {},
-    "select-all": { type: Boolean, default: !1 },
-    "select-allModifiers": {}
-  }),
-  emits: /* @__PURE__ */ b(["update:modelValue"], ["update:unselected-items", "update:select-all"]),
-  setup(r, { emit: O }) {
-    const l = r, o = O, { getItemValue: S } = W(), f = I(() => !!(l.loading || F.value)), {
+    selectable: { type: [Boolean, Function] },
+    selectAll: { type: Boolean },
+    unselectedItems: { default: () => [] }
+  },
+  emits: ["update:modelValue", "update:unselectedItems"],
+  setup(H, { emit: x }) {
+    const t = H, u = x, { getItemValue: A } = G(), f = V(() => !!(t.loading || w.value)), {
       getter: v,
       items: y,
-      loading: F
-    } = z({
-      items: m(l, "items")
-    }), { hasPrefilled: N } = J({
+      loading: w
+    } = W({
+      items: r(t, "items")
+    }), { hasPrefilled: O } = q({
       onStart: !0,
-      currentValue: l.modelValue,
-      multiple: l.multiple,
+      currentValue: t.modelValue,
+      multiple: t.multiple,
       fn: async ({ prefill: e }) => {
-        await v(e, l.modelValue);
+        await v(e, t.modelValue);
       }
-    }), { data: h } = K({
-      items: m(l, "modelValue")
-    }), { options: T } = Q({
-      disabled: m(l, "disabled"),
+    }), { data: h } = z({
+      items: r(t, "modelValue")
+    }), { options: S } = J({
+      disabled: r(t, "disabled"),
       items: y,
       itemText: void 0,
-      itemValue: l.itemValue,
-      max: l.max,
+      itemValue: t.itemValue,
+      max: t.max,
       selectable: !0,
       selectedIndexedByHash: h
-    }), $ = async (e) => {
-      l.multiple ? o("update:modelValue", l.modelValue.concat(e.value)) : o("update:modelValue", e.value);
-    }, A = async (e) => {
-      if (l.multiple) {
-        const t = { ...h.value };
-        delete t[e.valueHash], o("update:modelValue", Object.values(t));
+    }), F = async (e) => {
+      t.multiple ? u("update:modelValue", t.modelValue.concat(e.value)) : u("update:modelValue", e.value);
+    }, N = async (e) => {
+      if (t.multiple) {
+        const l = { ...h.value };
+        delete l[e.valueHash], u("update:modelValue", Object.values(l));
       } else
-        o("update:modelValue", null);
+        u("update:modelValue", null);
     };
-    X(
-      () => [l.dependencies, l.items],
+    K(
+      () => [t.dependencies, t.items],
       async () => {
-        N.value && await v(!1, l.modelValue);
+        O.value && await v(!1, t.modelValue);
       },
       {
-        debounce: l.depsDebounceTime
+        debounce: t.depsDebounceTime
       }
     );
-    const V = I(() => T.value.map((e) => {
-      let t = !l.selectable;
-      typeof l.selectable == "function" && (t = !l.selectable(e.item)), t = t || !!e.disabled;
-      const a = q(
-        l.columns.map((s) => {
-          const { label: L, key: P } = s;
-          let u = S(e.item, s.key);
+    const I = V(() => S.value.map((e) => {
+      let l = !t.selectable;
+      typeof t.selectable == "function" && (l = !t.selectable(e.item)), l = l || !!e.disabled;
+      const a = U(
+        t.columns.map((s) => {
+          const { label: $, key: C } = s;
+          let n = A(e.item, s.key);
           return s.formatter && // By default the formatter runs anyway
-          (!w(u) || s.formatOnNull !== !1) && (u = s.formatter(u, s.key, e.item)), s.placeholder && w(u) && (u = s.placeholder), {
-            value: u,
-            key: P,
-            label: L
+          (!k(n) || s.formatOnNull !== !1) && (n = s.formatter(n, s.key, e.item)), s.placeholder && k(n) && (n = s.placeholder), {
+            value: n,
+            key: C,
+            label: $
           };
         }),
         (s) => s.key
-      ), i = !!(e.selected || c.value) && !n.has(e.valueHash);
+      ), c = !!(e.selected || d.value) && !o.has(e.valueHash);
       return {
         columns: a,
         item: e.item,
         text: e.text,
         valueHash: e.valueHash,
         value: e.value,
-        selected: i,
-        disabled: t
+        selected: c,
+        disabled: l
       };
-    })), C = (e) => {
-      c.value || $(e), n.delete(e.valueHash), d.value = d.value.filter(
-        (t) => M(t) !== M(e.value)
+    })), T = (e) => {
+      d.value || F(e), o.delete(e.valueHash), u(
+        "update:unselectedItems",
+        t.unselectedItems.filter((l) => p(l) !== p(e.value))
       );
-    }, D = (e) => {
-      n.add(e.valueHash), d.value.push(e.value), A(e);
-    }, n = j(/* @__PURE__ */ new Set()), d = B(r, "unselected-items");
-    let c = B(r, "select-all");
-    return E(c, () => {
-      n.clear(), d.value = [], o("update:modelValue", []);
-    }), (e, t) => (g(), k(H, null, [
-      f.value ? p(e.$slots, "loading", {
+    }, _ = (e) => {
+      o.add(e.valueHash), u("update:unselectedItems", [...t.unselectedItems, e.value]), N(e);
+    }, o = E(/* @__PURE__ */ new Set());
+    m(
+      () => t.unselectedItems,
+      () => {
+        o.clear(), t.unselectedItems.forEach((e) => {
+          o.add(p(e));
+        });
+      }
+    );
+    const d = L(t.selectAll);
+    return m(
+      () => t.selectAll,
+      () => {
+        d.value = t.selectAll;
+      }
+    ), m(d, () => {
+      o.clear(), u("update:unselectedItems", []), u("update:modelValue", []);
+    }), (e, l) => (b(), B(g, null, [
+      f.value ? i(e.$slots, "loading", {
         key: 0,
-        items: x(y)
-      }) : G("", !0),
-      V.value.length ? (g(!0), k(H, { key: 2 }, U(V.value, (a, i) => p(e.$slots, "default", {
-        key: a.valueHash + x(c),
+        items: P(y)
+      }) : R("", !0),
+      I.value.length ? (b(!0), B(g, { key: 2 }, j(I.value, (a, c) => i(e.$slots, "default", {
+        key: a.valueHash + d.value,
         checked: a.selected,
         columns: a.columns,
         disabled: a.disabled,
-        index: i,
+        index: c,
         item: a.item,
-        select: () => C(a),
-        unselect: () => D(a),
+        select: () => T(a),
+        unselect: () => _(a),
         value: a.value
-      })), 128)) : p(e.$slots, "no-data", {
+      })), 128)) : i(e.$slots, "no-data", {
         key: 1,
         loading: f.value
       })
@@ -131,5 +140,5 @@ const de = /* @__PURE__ */ R({
   }
 });
 export {
-  de as default
+  oe as default
 };

package/dist/index101.js

@@ -54,16 +54,16 @@ const k = /* @__PURE__ */ h({
   },
   emits: ["blur", "change", "click", "focus", "inactive", "input", "update:modelValue", "option:add"],
   setup(d, { emit: m }) {
-    const r = d, t = m, p = y(!1), u = g(() => r.persistentHint || p.value), c = {
+    const r = d, t = m, s = y(!1), u = g(() => r.persistentHint || s.value), c = {
       onBlur: (e) => t("blur", e),
       onChange: (e) => t("change", e),
       onClick: (e) => t("click", e),
       "onOption:add": (e) => t("option:add", e),
       onFocus: (e) => {
-        p.value = !0, t("focus", e);
+        s.value = !0, t("focus", e);
       },
       onInactive: () => {
-        p.value = !1, t("inactive");
+        s.value = !1, t("inactive");
       },
       onInput: (e) => t("input", e),
       "onUpdate:modelValue": (e) => t("update:modelValue", e)
@@ -84,12 +84,12 @@ const k = /* @__PURE__ */ h({
       reverse: e.reverse,
       "show-hint": u.value
     }, {
-      label: a((s) => [
-        n(e.$slots, "label", l(i(s)))
+      label: a((p) => [
+        n(e.$slots, "label", l(i(p)))
       ]),
-      input: a(({ id: s, hasErrors: b, ariaDescribedby: f }) => [
+      input: a(({ id: p, hasErrors: b, ariaDescribedby: f }) => [
         $(w, T({
-          id: s,
+          id: p,
           "allow-writing": e.allowWriting,
           "append:icon": r["append:icon"],
           "aria-describedby": f,
@@ -146,12 +146,6 @@ const k = /* @__PURE__ */ h({
           "no-data": a((o) => [
             n(e.$slots, "no-data", l(i(o)))
           ]),
-          "option:append": a((o) => [
-            n(e.$slots, "option:append", l(i(o)))
-          ]),
-          "option:prepend": a((o) => [
-            n(e.$slots, "option:prepend", l(i(o)))
-          ]),
           option: a((o) => [
             n(e.$slots, "option", l(i(o)))
           ]),
@@ -170,9 +164,6 @@ const k = /* @__PURE__ */ h({
           suffix: a((o) => [
             n(e.$slots, "suffix", l(i(o)))
           ]),
-          spinner: a((o) => [
-            n(e.$slots, "spinner", l(i(o)))
-          ]),
           _: 2
         }, 1040, ["id", "allow-writing", "append:icon", "aria-describedby", "autocomplete", "autofocus", "clearable", "comma", "compact", "dependencies", "deps-debounce-time", "disabled", "enforce-coherence", "filter-by", "has-errors", "item-text", "item-value", "items", "loading", "loading-text", "max", "max-selected-labels", "model-value", "model-value-debounce-time", "multiple", "name", "no-data-text", "placeholder", "prefill", "prepend:icon", "query-debounce-time", "readonly", "required", "selected-labels-fn", "stash", "teleport-target", "transition-duration", "update-on-animation-frame"])
       ]),