bt-core-app 2.1.37 → 2.2.0

package/dist/components/BT-Number.vue2.mjs

@@ -0,0 +1,43 @@
+import { defineComponent as d, computed as i, resolveComponent as p, openBlock as c, createBlock as f, mergeProps as V, unref as x } from "vue";
+import { useTheme as g } from "vuetify";
+const B = /* @__PURE__ */ d({
+  inheritAttrs: !1,
+  __name: "BT-Number",
+  props: {
+    negate: { type: Boolean },
+    min: {},
+    max: {},
+    onSelect: { type: Function },
+    modelValue: {},
+    textCenter: { type: Boolean }
+  },
+  emits: ["update:modelValue"],
+  setup(o, { emit: r }) {
+    const m = g(), e = o, u = r, l = i({
+      get() {
+        return e.modelValue != null && e.negate ? 0 - e.modelValue : e.modelValue;
+      },
+      set(t) {
+        if (!(e.min != null && t != null && t < e.min) && !(e.max != null && t != null && t > e.max)) {
+          var n = t != null && e.negate ? 0 - t : t;
+          u("update:modelValue", n), e.onSelect && e.onSelect(n);
+        }
+      }
+    });
+    return (t, n) => {
+      const a = p("v-text-field");
+      return c(), f(a, V({
+        class: { "centered-input": t.textCenter },
+        dark: x(m).global.current.value.dark,
+        type: "number"
+      }, t.$attrs, {
+        modelValue: l.value,
+        "onUpdate:modelValue": n[0] || (n[0] = (s) => l.value = s),
+        modelModifiers: { number: !0 }
+      }), null, 16, ["class", "dark", "modelValue"]);
+    };
+  }
+});
+export {
+  B as default
+};

package/dist/components/BT-Number.vue3.mjs

@@ -0,0 +1 @@
+

package/dist/components/BT-Numpad.vue.d.ts

@@ -0,0 +1,68 @@
+interface NumpadProps {
+    buttonClass?: string;
+    buttonHeight?: string;
+    canNegate?: boolean;
+    clearOnOk?: boolean;
+    currentValue?: number;
+    disableTextField?: boolean;
+    modelValue?: number;
+    showAddRemove?: boolean;
+    showDecimal?: boolean;
+    showOk?: boolean;
+    showNegative?: boolean;
+    startingValue?: number;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NumpadProps>, {
+    buttonHeight: string;
+    showAddRemove: boolean;
+    showDecimal: boolean;
+    showOk: boolean;
+    showNegative: boolean;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+    "update:currentValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NumpadProps>, {
+    buttonHeight: string;
+    showAddRemove: boolean;
+    showDecimal: boolean;
+    showOk: boolean;
+    showNegative: boolean;
+}>>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:currentValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    buttonHeight: string;
+    showAddRemove: boolean;
+    showDecimal: boolean;
+    showOk: boolean;
+    showNegative: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    display?(_: {
+        value: string;
+    }): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BT-Numpad.vue.mjs

@@ -0,0 +1,191 @@
+import { defineComponent as E, ref as C, computed as p, watch as N, resolveComponent as c, openBlock as d, createBlock as v, withCtx as o, renderSlot as z, createVNode as s, createElementBlock as I, Fragment as M, renderList as U, normalizeClass as f, createCommentVNode as g, createTextVNode as y } from "vue";
+const q = /* @__PURE__ */ E({
+  __name: "BT-Numpad",
+  props: {
+    buttonClass: {},
+    buttonHeight: { default: "75" },
+    canNegate: { type: Boolean },
+    clearOnOk: { type: Boolean },
+    currentValue: {},
+    disableTextField: { type: Boolean },
+    modelValue: {},
+    showAddRemove: { type: Boolean, default: !1 },
+    showDecimal: { type: Boolean, default: !1 },
+    showOk: { type: Boolean, default: !1 },
+    showNegative: { type: Boolean, default: !1 },
+    startingValue: {}
+  },
+  emits: ["change", "update:modelValue", "update:currentValue"],
+  setup(B, { emit: O }) {
+    var b, k;
+    const a = B, m = O, l = C(""), _ = p(() => l.value != null && l.value.length > 0 && !Number.isNaN(l.value)), n = p(() => {
+      const e = a.showDecimal == !1 ? Number.parseInt(l.value) : Number.parseFloat(l.value);
+      return isNaN(e) ? void 0 : e;
+    }), $ = C(4), S = p(() => {
+      const e = [
+        { cols: 4, num: 1 },
+        { cols: 4, num: 2 },
+        { cols: 4, num: 3 },
+        { cols: 4, num: 4 },
+        { cols: 4, num: 5 },
+        { cols: 4, num: 6 },
+        { cols: 4, num: 7 },
+        { cols: 4, num: 8 },
+        { cols: 4, num: 9 }
+      ], t = [{ cols: "auto", num: void 0, icon: "$backspace" }];
+      a.showNegative && t.push({ cols: "auto", num: "-" }), a.showDecimal && t.push({ cols: "auto", num: "." }), t.push({ cols: "4", num: 0 });
+      let h = t.length;
+      a.showOk !== !1 && h++;
+      const u = Math.floor(12 / h);
+      return $.value = u, t.forEach((r) => {
+        r.cols = u;
+      }), e.push(...t), e;
+    });
+    function T(e) {
+      e != null ? e == "-" ? l.value.startsWith("-") ? l.value = l.value.substring(1) : l.value = `${e}${l.value}` : e == "." && l.value.includes(".") || (l.value = `${l.value ?? ""}${e}`) : l.value.length == 1 ? l.value = "" : l.value = l.value.substring(0, l.value.length - 1), m("update:currentValue", n.value);
+    }
+    function A() {
+      n.value != null && (m("change", n.value), a.clearOnOk == !0 && (l.value = ""));
+    }
+    function H() {
+      n.value != null && (m("change", 0 - n.value), a.clearOnOk == !0 && (l.value = ""));
+    }
+    function R(e) {
+      if (n.value != null) {
+        const t = e ? n.value : 0 - n.value;
+        m("change", t), m("update:modelValue", t), a.clearOnOk == !0 && (l.value = "");
+      }
+    }
+    return N(() => a.modelValue, (e) => {
+      l.value = (e == null ? void 0 : e.toString()) ?? "";
+    }), N(() => a.startingValue, (e) => {
+      l.value = (e == null ? void 0 : e.toString()) ?? "";
+    }), l.value = ((b = a.modelValue) == null ? void 0 : b.toString()) ?? ((k = a.startingValue) == null ? void 0 : k.toString()) ?? "", (e, t) => {
+      const h = c("v-text-field"), u = c("v-btn"), r = c("v-col"), x = c("v-slide-x-transition"), w = c("v-row"), D = c("v-slide-y-reverse-transition"), F = c("v-container");
+      return d(), v(F, { class: "ma-0 pa-0 mt-3" }, {
+        default: o(() => [
+          z(e.$slots, "display", { value: l.value }, () => [
+            s(h, {
+              color: "transparent",
+              disabled: e.disableTextField,
+              "hide-details": "",
+              tile: "",
+              modelValue: l.value,
+              "onUpdate:modelValue": t[0] || (t[0] = (i) => l.value = i)
+            }, null, 8, ["disabled", "modelValue"])
+          ]),
+          s(w, { class: "ma-0 pa-0" }, {
+            default: o(() => [
+              (d(!0), I(M, null, U(S.value, (i, L) => (d(), v(r, {
+                class: "ma-0 pa-0",
+                cols: i.cols,
+                key: L
+              }, {
+                default: o(() => {
+                  var V;
+                  return [
+                    s(u, {
+                      onClick: (W) => T(i.num),
+                      class: f(["text-h6", e.buttonClass]),
+                      color: "transparent",
+                      height: e.buttonHeight,
+                      icon: i.icon,
+                      text: ((V = i.num) == null ? void 0 : V.toString()) ?? i.text,
+                      tile: "",
+                      width: "100%"
+                    }, null, 8, ["onClick", "class", "height", "icon", "text"])
+                  ];
+                }),
+                _: 2
+              }, 1032, ["cols"]))), 128)),
+              e.showOk ? (d(), v(r, {
+                key: 0,
+                class: "ma-0 pa-0"
+              }, {
+                default: o(() => [
+                  s(x, { "hide-on-leave": "" }, {
+                    default: o(() => [
+                      _.value ? (d(), v(u, {
+                        key: 0,
+                        class: f(["text-h6", e.buttonClass]),
+                        color: "transparent",
+                        disabled: e.showAddRemove,
+                        height: e.buttonHeight,
+                        icon: "$check",
+                        tile: "",
+                        onClick: t[1] || (t[1] = () => R(!0)),
+                        width: "100%"
+                      }, null, 8, ["class", "disabled", "height"])) : g("", !0)
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              })) : g("", !0)
+            ]),
+            _: 1
+          }),
+          s(D, { "hide-on-leave": "" }, {
+            default: o(() => [
+              _.value && e.showAddRemove ? (d(), v(w, {
+                key: 0,
+                class: "ma-0 pa-0"
+              }, {
+                default: o(() => [
+                  s(r, {
+                    cols: "6",
+                    class: "ma-0 pa-0"
+                  }, {
+                    default: o(() => [
+                      s(u, {
+                        onClick: H,
+                        class: f(["text-h6", e.buttonClass]),
+                        color: "error",
+                        height: e.buttonHeight,
+                        tile: "",
+                        width: "100%"
+                      }, {
+                        default: o(() => t[2] || (t[2] = [
+                          y("Remove")
+                        ])),
+                        _: 1
+                      }, 8, ["class", "height"])
+                    ]),
+                    _: 1
+                  }),
+                  s(r, {
+                    cols: "6",
+                    class: "ma-0 pa-0"
+                  }, {
+                    default: o(() => [
+                      s(u, {
+                        onClick: A,
+                        class: f(["text-h6", e.buttonClass]),
+                        color: "success",
+                        height: e.buttonHeight,
+                        tile: "",
+                        width: "100%"
+                      }, {
+                        default: o(() => t[3] || (t[3] = [
+                          y("Add")
+                        ])),
+                        _: 1
+                      }, 8, ["class", "height"])
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              })) : g("", !0)
+            ]),
+            _: 1
+          })
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+export {
+  q as default
+};

package/dist/components/BT-Numpad.vue2.mjs

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

package/dist/components/BT-Select-Inline.vue.d.ts

@@ -0,0 +1,121 @@
+declare const _default: import('vue').DefineComponent<import("vue").ExtractPropTypes<{
+    menuProps: {
+        type: ObjectConstructor;
+        default: () => {
+            maxHeight: string;
+        };
+    };
+    chipProps: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    modelValue: {
+        type: import("vue").PropType<any>;
+    };
+    selection: {
+        type: StringConstructor;
+    };
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    items: {
+        type: import("vue").PropType<any[]>;
+        default: () => never[];
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    cols: {
+        type: NumberConstructor;
+        default: number;
+    };
+    itemText: {
+        type: import("vue").PropType<string | ((item: any) => string)>;
+        default: string;
+    };
+    itemValue: {
+        type: import("vue").PropType<string | ((item: any) => any)>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    select: (item: any) => void;
+    selected: import("vue").Ref<any, any>;
+    selectedStr: import("vue").Ref<string, string>;
+    itemRows: any[][];
+    setItems: (items: any[]) => void;
+    setValues: (values: any) => void;
+    isEmpty: import("vue").ComputedRef<boolean>;
+    has: (item: any) => boolean;
+    values: Set<any>;
+    add: (item: any) => void;
+    toggle: (item: any) => void;
+    remove: (item: any) => void;
+    clear: () => void;
+    updated: import("vue").Ref<number, number>;
+    equals: (items: any[]) => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:model-value")[], "change" | "update:model-value", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    menuProps: {
+        type: ObjectConstructor;
+        default: () => {
+            maxHeight: string;
+        };
+    };
+    chipProps: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    modelValue: {
+        type: import("vue").PropType<any>;
+    };
+    selection: {
+        type: StringConstructor;
+    };
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    items: {
+        type: import("vue").PropType<any[]>;
+        default: () => never[];
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    cols: {
+        type: NumberConstructor;
+        default: number;
+    };
+    itemText: {
+        type: import("vue").PropType<string | ((item: any) => string)>;
+        default: string;
+    };
+    itemValue: {
+        type: import("vue").PropType<string | ((item: any) => any)>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+}>, {
+    items: any[];
+    multiple: boolean;
+    itemText: string | ((item: any) => string);
+    itemValue: string | ((item: any) => any);
+    disabled: boolean;
+    clearable: boolean;
+    cols: number;
+    menuProps: Record<string, any>;
+    chipProps: Record<string, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/BT-Select-Inline.vue.mjs

@@ -0,0 +1,74 @@
+import b from "./BT-Select-Inline.vue2.mjs";
+import { resolveComponent as o, openBlock as n, createBlock as l, mergeProps as p, withCtx as t, withModifiers as B, createCommentVNode as _, createVNode as r, createTextVNode as d, toDisplayString as v, createElementBlock as N, Fragment as P, renderList as S } from "vue";
+import "./BT-Select-Inline.vue3.mjs";
+import V from "../_virtual/_plugin-vue_export-helper.mjs";
+function z(e, i, s, E, T, D) {
+  const a = o("v-icon"), u = o("v-list-item"), f = o("v-col"), k = o("v-row"), h = o("v-virtual-scroll"), w = o("v-card"), y = o("v-menu"), C = o("v-chip");
+  return n(), l(C, p(s.chipProps, { disabled: e.disabled }), {
+    append: t(() => [
+      e.clearable && !e.isEmpty ? (n(), l(a, {
+        key: 0,
+        size: "small",
+        icon: "$close",
+        onClick: i[0] || (i[0] = B((m) => e.clear(), ["stop"]))
+      })) : _("", !0),
+      r(a, {
+        size: "small",
+        icon: "$chevron-down"
+      })
+    ]),
+    default: t(() => [
+      d(" " + v(e.selection ?? e.selectedStr) + " ", 1),
+      r(y, p({ activator: "parent" }, s.menuProps, {
+        "close-on-content-click": !e.multiple
+      }), {
+        default: t(() => [
+          r(w, null, {
+            default: t(() => [
+              r(h, {
+                class: "pa-0 ma-0",
+                height: 170,
+                items: e.itemRows
+              }, {
+                default: t(({ index: m, item: $ }) => [
+                  (n(), l(k, {
+                    key: m,
+                    "no-gutters": ""
+                  }, {
+                    default: t(() => [
+                      (n(!0), N(P, null, S($, (c, g) => (n(), l(f, { key: g }, {
+                        default: t(() => [
+                          c ? (n(), l(u, {
+                            key: 0,
+                            class: "vcron-v-item",
+                            onClick: (F) => e.select(c),
+                            active: e.has(c)
+                          }, {
+                            default: t(() => [
+                              d(v(c.text), 1)
+                            ]),
+                            _: 2
+                          }, 1032, ["onClick", "active"])) : _("", !0)
+                        ]),
+                        _: 2
+                      }, 1024))), 128))
+                    ]),
+                    _: 2
+                  }, 1024))
+                ]),
+                _: 1
+              }, 8, ["items"])
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 16, ["close-on-content-click"])
+    ]),
+    _: 1
+  }, 16, ["disabled"]);
+}
+const q = /* @__PURE__ */ V(b, [["render", z]]);
+export {
+  q as default
+};

package/dist/components/BT-Select-Inline.vue2.mjs

@@ -0,0 +1,24 @@
+import { selectProps as s, setupSelect as a } from "../composables/select.mjs";
+const r = {
+  inheritAttrs: !1,
+  name: "CustomSelect",
+  props: {
+    ...s(),
+    menuProps: {
+      type: Object,
+      default: () => ({ maxHeight: "300px" })
+    },
+    chipProps: {
+      type: Object,
+      default: () => {
+      }
+    }
+  },
+  emits: ["update:model-value", "change"],
+  setup(e, t) {
+    return a(e, () => e.modelValue, t);
+  }
+};
+export {
+  r as default
+};

package/dist/components/BT-Select-Inline.vue3.mjs

@@ -0,0 +1 @@
+

package/dist/components/BT-Select-List-Box.vue.d.ts

@@ -0,0 +1,137 @@
+import { ListProps } from '../composables/list.ts';
+
+interface SelectProps extends ListProps<any, any, any> {
+    alwaysOpen?: boolean;
+    canRefresh?: boolean;
+    canSearch?: boolean;
+    canSelectNone?: boolean;
+    colClass?: string;
+    cols?: string | boolean;
+    density?: 'compact' | 'comfortable' | 'default';
+    height?: string;
+    hideDividers?: boolean;
+    isMobile?: boolean;
+    isEditing?: boolean;
+    isSelecting?: boolean;
+    items?: [];
+    itemSubtext?: string;
+    itemText?: string;
+    itemValue?: string;
+    label?: string;
+    lg?: string | boolean;
+    maxHeight?: string | number;
+    modelValue?: any;
+    md?: string | boolean;
+    nav?: string;
+    placeholder?: string;
+    prependIcon?: string;
+    showSettings?: boolean;
+    sm?: string | boolean;
+    subtextFilter?: string;
+    subtextFunction?: Function;
+    textFilter?: string;
+    textFunction?: Function;
+    transparent?: boolean;
+    useVirtualScroller?: boolean;
+}
+declare function openList(): void;
+declare function selectItem(item: any): void;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SelectProps>, {
+    canRefresh: boolean;
+    density: string;
+    eager: boolean;
+    height: undefined;
+    isEditing: undefined;
+    maxHeight: undefined;
+    sortOrder: string;
+    cols: string;
+    lg: boolean;
+    md: boolean;
+    sm: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (item: any) => void;
+    change: (item: any) => void;
+    deleted: (item: any) => void;
+    fetched: (item: any) => void;
+    input: (item: any) => void;
+    select: (item: any) => void;
+    confirm: (item: any) => void;
+    "mouse-over-item": (item: any) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SelectProps>, {
+    canRefresh: boolean;
+    density: string;
+    eager: boolean;
+    height: undefined;
+    isEditing: undefined;
+    maxHeight: undefined;
+    sortOrder: string;
+    cols: string;
+    lg: boolean;
+    md: boolean;
+    sm: string;
+}>>> & Readonly<{
+    onInput?: ((item: any) => any) | undefined;
+    onSelect?: ((item: any) => any) | undefined;
+    onChange?: ((item: any) => any) | undefined;
+    onDeleted?: ((item: any) => any) | undefined;
+    onFetched?: ((item: any) => any) | undefined;
+    onConfirm?: ((item: any) => any) | undefined;
+    "onMouse-over-item"?: ((item: any) => any) | undefined;
+    "onUpdate:modelValue"?: ((item: any) => any) | undefined;
+}>, {
+    height: string;
+    eager: boolean;
+    density: "default" | "comfortable" | "compact";
+    maxHeight: string | number;
+    isEditing: boolean;
+    sm: string | boolean;
+    cols: string | boolean;
+    lg: string | boolean;
+    md: string | boolean;
+    canRefresh: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    actions?(_: {}): any;
+    actionsRight?(_: {}): any;
+    settings?(_: {}): any;
+    item?(_: {
+        item: any;
+        index: number;
+        size: string;
+        isActive: boolean;
+        selectItem: typeof selectItem;
+    }): any;
+    default?(_: {
+        item: any;
+        index: number;
+        size: string;
+    }): any;
+    topItem?(_: {}): any;
+    bottomItem?(_: {}): any;
+    selected?(_: {
+        item: any;
+        open: typeof openList;
+    }): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};