bt-core-app 2.1.37 → 2.2.1

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

@@ -0,0 +1,138 @@
+import { defineComponent as h, computed as A, resolveComponent as p, openBlock as C, createBlock as I, mergeProps as R, unref as n, withCtx as m, renderSlot as u, normalizeProps as a, guardReactiveProps as l, createVNode as d } from "vue";
+import { useList as T } from "../composables/list.mjs";
+import { useNavigation as P } from "../composables/navigation.mjs";
+import { TestRequired as D } from "../composables/rules.mjs";
+const k = /* @__PURE__ */ h({
+  __name: "BT-Select",
+  props: {
+    additionalUrl: {},
+    canRefresh: { type: Boolean },
+    canSelectNone: { type: Boolean },
+    fieldVariant: {},
+    items: {},
+    itemText: {},
+    itemValue: {},
+    multiple: { type: Boolean },
+    nav: {},
+    required: { type: Boolean },
+    rules: {},
+    textFilter: {},
+    addBladeName: {},
+    bladeGroup: {},
+    bladeName: {},
+    bladeStartShowing: { type: Boolean },
+    canSelect: { type: Boolean },
+    canUnselect: { type: Boolean },
+    closeBladeNames: {},
+    confirmOnDelete: { type: Boolean },
+    customFilters: {},
+    dateFrom: {},
+    dateTo: {},
+    defaultFilters: {},
+    eager: { type: Boolean, default: !0 },
+    errorMsg: {},
+    filterToggle: { type: Boolean },
+    headers: {},
+    hideActions: { type: Boolean },
+    idSelector: {},
+    ignoreID: { type: Boolean },
+    inactiveProp: {},
+    isSingle: { type: Boolean },
+    itemBladeName: {},
+    itemID: {},
+    itemsPerPage: {},
+    keyStrategy: {},
+    loadingMsg: {},
+    localFilters: {},
+    localOnly: { type: Boolean },
+    navType: {},
+    onCanDelete: {},
+    onCanDeleteAsync: {},
+    onCanIntegrate: {},
+    onCanRestore: {},
+    onCanRestoreAsync: {},
+    onCanSave: {},
+    onCanSaveAsync: {},
+    onCanSelectItem: {},
+    onDeleteAsync: {},
+    onDeleteSuccessAsync: {},
+    onError: {},
+    onFilter: {},
+    onFinished: {},
+    onGetAsync: {},
+    onGetSingleAsync: {},
+    onGetSaveAsync: {},
+    onGetSingleSuccessAsync: {},
+    onGetSuccessAsync: {},
+    onRestoreAsync: {},
+    onRestoreSuccessAsync: {},
+    onSaveAsync: {},
+    onSaveSuccessAsync: {},
+    onSelectItem: {},
+    onSyncAsync: {},
+    onUpdateAsyncItem: {},
+    paginate: {},
+    params: {},
+    proxyID: {},
+    proxyKey: {},
+    refreshOnChange: { type: Boolean },
+    queryParams: {},
+    refreshLiteToggle: { type: Boolean },
+    refreshToggle: { type: Boolean },
+    searchKey: {},
+    searchProps: {},
+    searchStr: {},
+    selectProps: {},
+    sortDirection: {},
+    sortProp: {},
+    startEditing: { type: Boolean },
+    startShowingInactive: { type: Boolean },
+    startShowingSearch: { type: Boolean },
+    storeMode: {},
+    storageMode: {},
+    trackSearchQuery: { type: Boolean },
+    useBladeSrc: { type: Boolean },
+    useRouteSrc: { type: Boolean },
+    variant: {}
+  },
+  emits: ["change", "deleted", "fetched", "input", "select", "confirm", "mouse-over-item"],
+  setup(y, { emit: v }) {
+    const g = v, S = P(), t = y, B = t.itemText ?? (t.nav != null ? S.findItemText(t.nav) : void 0) ?? void 0, r = T(t, g), s = A(() => {
+      var e = [
+        ...t.rules ?? []
+      ];
+      return t.required && e.push(D), e.length > 0 ? e : void 0;
+    });
+    return (e, i) => {
+      const c = p("v-list-item"), f = p("v-select");
+      return C(), I(f, R({
+        "append-icon": e.canRefresh ? "$refresh" : void 0,
+        clearable: e.canSelectNone,
+        "onClick:appendIcon": i[0] || (i[0] = (o) => n(r).refresh({ deepRefresh: !0 })),
+        "hide-details": s.value == null,
+        items: n(r).filteredItems.value,
+        "item-title": n(B),
+        "item-value": e.itemValue,
+        loading: n(r).isLoading.value,
+        multiple: e.multiple,
+        rules: s.value,
+        variant: e.fieldVariant
+      }, e.$attrs), {
+        item: m((o) => [
+          u(e.$slots, "item", a(l(o)), () => [
+            d(c, a(l(o.props)), null, 16)
+          ])
+        ]),
+        selection: m((o) => [
+          u(e.$slots, "selection", a(l(o)), () => [
+            d(c, a(l(o.item.props)), null, 16)
+          ])
+        ]),
+        _: 3
+      }, 16, ["append-icon", "clearable", "hide-details", "items", "item-title", "item-value", "loading", "multiple", "rules", "variant"]);
+    };
+  }
+});
+export {
+  k as default
+};

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

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

package/dist/components/BT-Signature-Overlay.vue.d.ts

@@ -0,0 +1,65 @@
+interface SignProps {
+    canEdit?: boolean;
+    color?: string;
+    fullscreen?: boolean;
+    hideButton?: boolean;
+    lineColor?: string;
+    modelValue?: string;
+    openToggle?: boolean;
+    signature?: string;
+    transparent?: boolean;
+    usedHeight?: number;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SignProps>, {
+    fullscreen: boolean;
+    hideButton: boolean;
+    transparent: boolean;
+    usedHeight: number;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+    cancel: (...args: any[]) => void;
+    change: (...args: any[]) => void;
+    open: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SignProps>, {
+    fullscreen: boolean;
+    hideButton: boolean;
+    transparent: boolean;
+    usedHeight: number;
+}>>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+    onCancel?: ((...args: any[]) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+    onOpen?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    transparent: boolean;
+    fullscreen: boolean;
+    hideButton: boolean;
+    usedHeight: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    top?(_: {}): 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-Signature-Overlay.vue.mjs

@@ -0,0 +1,146 @@
+import { defineComponent as O, computed as g, ref as h, watch as p, toValue as f, resolveComponent as m, openBlock as B, createElementBlock as P, createBlock as T, mergeProps as M, withModifiers as j, createCommentVNode as z, createVNode as n, withCtx as v, normalizeStyle as H, renderSlot as J, unref as A } from "vue";
+import { VueSignaturePad as L } from "../bt-core/core/node_modules/vue-signature-pad/dist/vue-signature-pad.esm.mjs";
+import { useTheme as U } from "vuetify";
+const F = /* @__PURE__ */ O({
+  __name: "BT-Signature-Overlay",
+  props: {
+    canEdit: { type: Boolean },
+    color: {},
+    fullscreen: { type: Boolean, default: !0 },
+    hideButton: { type: Boolean, default: !1 },
+    lineColor: {},
+    modelValue: {},
+    openToggle: { type: Boolean },
+    signature: {},
+    transparent: { type: Boolean, default: !1 },
+    usedHeight: { default: 0 }
+  },
+  emits: ["cancel", "change", "close", "open", "update:modelValue"],
+  setup(E, { emit: S }) {
+    const r = S, o = E, x = g(() => o.fullscreen == !0 ? `height: calc(100vh - ${o.usedHeight}px); width: 100%;` : ""), i = h(), s = h(!1), u = h(null), b = U(), _ = g(() => o.lineColor ?? (b.name.value == "dark" ? "white" : "black")), w = g(() => ({
+      penColor: _.value
+    }));
+    function y(e, a) {
+      if (e != null)
+        if (a == null)
+          e.clearSignature();
+        else {
+          const l = JSON.parse(a);
+          l != null && l.length > 0 && e.fromData([{ color: _.value, points: l }]);
+        }
+    }
+    p(u, (e) => {
+      y(e, o.modelValue ?? o.signature);
+    }), p(() => o.openToggle, () => {
+      k();
+    }), p(() => o.modelValue, (e) => {
+      y(f(u), e);
+    }), p(() => o.signature, (e) => {
+      y(f(u), e);
+    });
+    function $() {
+      const e = f(u);
+      if (e != null && !e.isEmpty()) {
+        const a = e.toData(), l = [];
+        a.forEach((t) => {
+          t.points.forEach((C) => {
+            l.push({ x: C.x, y: C.y });
+          });
+        });
+        let d = Math.min(...l.map((t) => t.x)), c = Math.min(...l.map((t) => t.y));
+        d > 1 && l.forEach((t) => {
+          t.x -= d;
+        }), c > 1 && l.forEach((t) => {
+          t.y -= c;
+        }), i.value = JSON.stringify(l), (o.modelValue ?? o.signature) != i.value && (r("update:modelValue", i.value), r("change", i.value), r("close"), s.value = !1);
+      }
+    }
+    function D() {
+      r("cancel"), r("close"), s.value = !1;
+    }
+    function N() {
+      const e = f(u);
+      e != null && !e.isEmpty() && e.clearSignature(), i.value = void 0;
+    }
+    function k() {
+      i.value = o.modelValue ?? o.signature, s.value = !0, r("open");
+    }
+    return (e, a) => {
+      const l = m("v-btn"), d = m("v-slide-x-reverse-transition"), c = m("v-card"), V = m("v-overlay");
+      return B(), P("div", null, [
+        !e.hideButton && !s.value ? (B(), T(l, M({
+          key: 0,
+          onClick: j(k, ["stop"])
+        }, e.$attrs), null, 16)) : z("", !0),
+        n(V, {
+          modelValue: s.value,
+          "onUpdate:modelValue": a[0] || (a[0] = (t) => s.value = t),
+          "z-index": "1001"
+        }, {
+          default: v(() => [
+            n(c, {
+              class: "pa-0 ma-0 d-flex align-center justify-center",
+              color: e.color,
+              style: H(x.value)
+            }, {
+              default: v(() => [
+                J(e.$slots, "top"),
+                n(A(L), {
+                  options: w.value,
+                  ref_key: "signaturePad",
+                  ref: u
+                }, null, 8, ["options"]),
+                n(c, {
+                  class: "d-flex flex-column align-center justify-center",
+                  color: "primary",
+                  style: { position: "fixed", opacity: "0.75", right: "0" },
+                  width: "60"
+                }, {
+                  default: v(() => [
+                    n(d, {
+                      "hide-on-leave": "",
+                      group: ""
+                    }, {
+                      default: v(() => [
+                        n(l, {
+                          class: "my-3",
+                          onClick: D,
+                          icon: "$close",
+                          key: "1",
+                          variant: "tonal"
+                        }),
+                        n(l, {
+                          class: "my-3",
+                          onClick: N,
+                          disabled: !e.canEdit,
+                          icon: "$eraser",
+                          key: "3",
+                          variant: "tonal"
+                        }, null, 8, ["disabled"]),
+                        n(l, {
+                          class: "my-3",
+                          onClick: $,
+                          disabled: !e.canEdit,
+                          icon: "$check",
+                          key: "4",
+                          variant: "tonal"
+                        }, null, 8, ["disabled"])
+                      ]),
+                      _: 1
+                    })
+                  ]),
+                  _: 1
+                })
+              ]),
+              _: 3
+            }, 8, ["color", "style"])
+          ]),
+          _: 3
+        }, 8, ["modelValue"])
+      ]);
+    };
+  }
+});
+export {
+  F as default
+};

package/dist/components/BT-Signature-Overlay.vue2.mjs

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

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

@@ -0,0 +1,70 @@
+interface SignProps {
+    canEdit?: boolean;
+    clearOnOk?: boolean;
+    color?: string;
+    fullscreen?: boolean;
+    height?: string;
+    hideToolbar?: boolean;
+    lineColor?: string;
+    modelValue?: string;
+    refreshToggle?: boolean;
+    usedHeight?: number;
+    width?: string;
+}
+declare function apply(): void;
+declare function clear(): void;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SignProps>, {
+    color: string;
+    fullscreen: boolean;
+    height: string;
+    usedHeight: number;
+    width: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SignProps>, {
+    color: string;
+    fullscreen: boolean;
+    height: string;
+    usedHeight: number;
+    width: string;
+}>>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    width: string;
+    height: string;
+    color: string;
+    fullscreen: boolean;
+    usedHeight: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    top?(_: {
+        apply: typeof apply;
+        canApply: boolean;
+        canEdit: boolean;
+        clear: typeof clear;
+    }): 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-Signature.vue.mjs

@@ -0,0 +1,155 @@
+import { defineComponent as R, ref as g, computed as v, toValue as c, watch as y, onMounted as A, onUnmounted as D, resolveComponent as x, openBlock as _, createBlock as k, normalizeStyle as z, withCtx as S, renderSlot as J, createVNode as w, createCommentVNode as B, unref as W } from "vue";
+import { VueSignaturePad as j } from "../bt-core/core/node_modules/vue-signature-pad/dist/vue-signature-pad.esm.mjs";
+import { useTheme as L } from "vuetify";
+const q = /* @__PURE__ */ R({
+  __name: "BT-Signature",
+  props: {
+    canEdit: { type: Boolean },
+    clearOnOk: { type: Boolean },
+    color: { default: "transparent" },
+    fullscreen: { type: Boolean, default: !1 },
+    height: { default: "400px" },
+    hideToolbar: { type: Boolean },
+    lineColor: {},
+    modelValue: {},
+    refreshToggle: { type: Boolean },
+    usedHeight: { default: 0 },
+    width: { default: "100%" }
+  },
+  emits: ["change", "update:modelValue"],
+  setup(O, { emit: T }) {
+    const V = T, l = O, t = g(), m = g(!1), n = g(null), $ = L(), p = v(() => {
+      const e = c(n);
+      if (e != null)
+        return e.signaturePad.canvas.height / window.devicePixelRatio;
+    }), h = v(() => {
+      const e = c(n);
+      if (e != null)
+        return e.signaturePad.canvas.width / window.devicePixelRatio;
+    }), M = v(() => l.fullscreen == !0 ? `height: calc(100vh - ${l.usedHeight}px); width: ${l.width};` : `height: ${l.height}; width: ${l.width};`), d = v(() => !!l.canEdit), b = v(() => l.lineColor ?? ($.name.value == "dark" ? "white" : "black")), C = v(() => t.value != null && t.value != l.modelValue), H = v(() => ({
+      dotSize: 0.5,
+      onEnd: () => {
+        const e = c(n);
+        if (e != null && !e.isEmpty()) {
+          const o = e.toData(), a = [];
+          o.forEach((u) => {
+            u.points.forEach((i) => {
+              a.push({ x: i.x, y: i.y });
+            });
+          });
+          let s = Math.min(...a.map((u) => u.x)), r = Math.min(...a.map((u) => u.y));
+          s > 1 && a.forEach((u) => {
+            u.x -= s;
+          }), r > 1 && a.forEach((u) => {
+            u.y -= r;
+          }), t.value = JSON.stringify(a);
+        }
+      },
+      penColor: b.value
+    }));
+    function f(e, o) {
+      if (e != null)
+        if (o == null)
+          e.clearSignature();
+        else {
+          const a = JSON.parse(o);
+          a != null && a.length > 0 && e.fromData([{ color: b.value, points: N(a) }]);
+        }
+    }
+    y(n, (e) => {
+      var o;
+      t.value = l.modelValue, f(e, l.modelValue), d.value || (o = n.value) == null || o.lockSignaturePad();
+    }), y(() => l.refreshToggle, () => {
+      var e;
+      t.value = l.modelValue, f(c(n), t.value), d.value || (e = n.value) == null || e.lockSignaturePad();
+    }), y(() => l.modelValue, (e) => {
+      var o;
+      t.value = e, f(c(n), e), d.value || (o = n.value) == null || o.lockSignaturePad();
+    });
+    function N(e) {
+      if (p.value != null && h.value != null) {
+        let o = Math.max(...e.map((i) => i.y)), a = Math.max(...e.map((i) => i.x)), s = 1, r = 1;
+        o > p.value && (s = p.value / o), a > h.value && (r = h.value / a);
+        let u = Math.min(s, r);
+        if (u < 1)
+          return e.map((i) => ({
+            x: i.x * u,
+            y: i.y * u
+          }));
+      }
+      return e;
+    }
+    function E() {
+      V("change", t.value), V("update:modelValue", t.value), l.clearOnOk && (t.value = void 0, f(c(n), t.value));
+    }
+    function P() {
+      const e = c(n);
+      e != null && !e.isEmpty() && e.clearSignature(), t.value = void 0;
+    }
+    return A(() => {
+      var e;
+      t.value = l.modelValue, f(c(n), t.value), d.value || (e = n.value) == null || e.lockSignaturePad(), m.value = !0;
+    }), D(() => {
+      m.value = !1;
+    }), (e, o) => {
+      const a = x("v-btn"), s = x("v-slide-x-reverse-transition"), r = x("v-card");
+      return _(), k(r, {
+        color: e.color,
+        style: z(M.value),
+        variant: "elevated"
+      }, {
+        default: S(() => [
+          J(e.$slots, "top", {
+            apply: E,
+            canApply: C.value,
+            canEdit: d.value,
+            clear: P
+          }, () => [
+            !e.hideToolbar && d.value ? (_(), k(r, {
+              key: 0,
+              class: "d-flex align-center justify-end mx-4",
+              flat: ""
+            }, {
+              default: S(() => [
+                w(s, {
+                  "hide-on-leave": "",
+                  group: ""
+                }, {
+                  default: S(() => [
+                    w(a, {
+                      class: "my-3",
+                      onClick: P,
+                      disabled: t.value == null,
+                      icon: "$eraser",
+                      key: "3"
+                    }, null, 8, ["disabled"]),
+                    w(a, {
+                      onClick: E,
+                      class: "my-3",
+                      disabled: !C.value,
+                      icon: "$check",
+                      key: "4"
+                    }, null, 8, ["disabled"])
+                  ]),
+                  _: 1
+                })
+              ]),
+              _: 1
+            })) : B("", !0)
+          ]),
+          m.value ? (_(), k(W(j), {
+            key: 0,
+            disabled: !d.value,
+            options: H.value,
+            ref_key: "signaturePad",
+            ref: n
+          }, null, 8, ["disabled", "options"])) : B("", !0)
+        ]),
+        _: 3
+      }, 8, ["color", "style"]);
+    };
+  }
+});
+export {
+  q as default
+};

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

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

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

@@ -0,0 +1,37 @@
+interface SliderOption {
+    disabled?: boolean;
+    hide?: boolean;
+    hideHeader?: boolean;
+    navHistory?: boolean;
+    title?: string;
+    value: any;
+}
+interface SliderProps {
+    hideHeader?: boolean;
+    options: SliderOption[];
+    modelValue?: number;
+    width?: number;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<SliderProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<SliderProps>>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, Partial<Record<`${any}-top`, (_: {}) => any>> & Partial<Record<`${any}-toolbar`, (_: {
+    back: () => void;
+    title: string | undefined;
+}) => any>> & Partial<Record<`${any}-toolbar-right`, (_: {}) => any>> & Partial<Record<any, (_: {}) => 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_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};