bt-core-app 2.1.37 → 2.2.1

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

@@ -0,0 +1,172 @@
+import { defineComponent as N, computed as V, toValue as D, resolveComponent as i, openBlock as a, createElementBlock as r, normalizeClass as c, createVNode as p, withCtx as f, unref as t, createBlock as v, createCommentVNode as g, normalizeStyle as E, renderSlot as l, createTextVNode as d, toDisplayString as s, createElementVNode as B } from "vue";
+import { useItem as F } from "../composables/item.mjs";
+import { useFilters as L } from "../composables/filters.mjs";
+import { nestedValue as b } from "../composables/helpers.mjs";
+import { useNavigation as P } from "../composables/navigation.mjs";
+const w = {
+  key: 0,
+  class: "align-center justify-center text-center"
+}, R = { key: "3" }, z = /* @__PURE__ */ N({
+  __name: "BT-Entity",
+  props: {
+    alternateText: {},
+    assignToObject: {},
+    assignToProp: {},
+    hideLoader: { type: Boolean, default: !1 },
+    inline: { type: Boolean },
+    isEditing: { type: Boolean },
+    itemText: {},
+    label: {},
+    prefix: {},
+    suffix: {},
+    textFilter: {},
+    textFunction: {},
+    truncate: { type: Boolean },
+    additionalUrl: {},
+    alwaysEditing: { type: Boolean },
+    bladeGroup: {},
+    bladeName: {},
+    bladeStartShowing: { type: Boolean },
+    canSave: { type: Boolean },
+    closeBladeNames: {},
+    confirmOnDelete: { type: Boolean },
+    eager: { type: Boolean, default: !1 },
+    eagerWithID: { type: Boolean, default: !0 },
+    errorMsg: {},
+    findItem: {},
+    ignorePermissions: { type: Boolean },
+    isSingle: { type: Boolean, default: !0 },
+    item: {},
+    itemID: {},
+    loadingMsg: {},
+    localPredicate: {},
+    nav: {},
+    navSuffix: {},
+    onBeforeEditAsync: {},
+    onBeforeViewAsync: {},
+    onCanDelete: {},
+    onCanDeleteAsync: {},
+    onCanEdit: {},
+    onCanRestore: {},
+    onCanRestoreAsync: {},
+    onCanSave: {},
+    onCanSaveAsync: {},
+    onDeleteAsync: {},
+    onDeleteSuccessAsync: {},
+    onError: {},
+    onGetAsync: {},
+    onGetListAsync: {},
+    onGetListSuccessAsync: {},
+    onGetSuccessAsync: {},
+    onGetNew: {},
+    onGetNewAsync: {},
+    onGetNotFound: {},
+    onGetSaveAsync: {},
+    onRefreshAsync: {},
+    onRestoreAsync: {},
+    onRestoreSuccessAsync: {},
+    onSaveAsync: {},
+    onSaveSuccessAsync: {},
+    onUpdateAsyncItem: {},
+    params: {},
+    proxyID: {},
+    proxyKey: {},
+    queryParams: {},
+    refreshOnChange: { type: Boolean },
+    refreshLiteToggle: { type: Boolean },
+    refreshToggle: { type: Boolean },
+    resetTrackerToggle: { type: Boolean },
+    startEditing: { type: Boolean },
+    storeMode: {},
+    storageMode: {},
+    trackChanges: { type: Boolean },
+    trackIgnoreProps: {},
+    trackProps: {},
+    useBladeSrc: { type: Boolean },
+    useRouteSrc: { type: Boolean },
+    variant: {}
+  },
+  emits: ["fetched", "saved"],
+  setup(h, { emit: I }) {
+    const S = I, o = h, A = L(), n = F(o, S, {
+      onGetItem: (e) => {
+        o.assignToObject != null && o.assignToProp != null && (o.assignToObject[o.assignToProp] = e);
+      }
+    }), T = P(), u = o.itemText ?? (o.nav != null ? T.findItemText(o.nav) : void 0) ?? void 0, C = V(() => {
+      var e = D(n.asyncItem);
+      return o.textFunction != null && (e = o.textFunction(e)), u != null && (e = b(n.asyncItem.value, u)), o.textFilter != null ? A.findFilter(o.textFilter)(e) : e;
+    });
+    return (e, y) => {
+      const m = i("v-progress-circular"), k = i("v-slide-x-transition"), x = i("v-overlay");
+      return a(), r("div", {
+        class: c(e.inline ? "d-inline" : "")
+      }, [
+        p(k, { "hide-on-leave": "" }, {
+          default: f(() => [
+            e.inline && t(n).isLoading.value ? (a(), r("div", w, [
+              e.hideLoader ? g("", !0) : (a(), v(m, {
+                key: 0,
+                indeterminate: "",
+                size: "20"
+              }))
+            ])) : t(n).asyncItem.value != null ? (a(), r("div", {
+              key: "1",
+              class: c({ "d-inline": e.inline, "text-truncate": e.truncate }),
+              style: E(e.truncate == !0 ? "display: inline-block;" : "")
+            }, [
+              l(e.$slots, "prepend", {
+                item: t(n).asyncItem.value,
+                refresh: t(n).refresh
+              }, () => [
+                d(s(e.prefix), 1)
+              ]),
+              l(e.$slots, "default", {
+                isChanged: t(n).isChanged,
+                item: t(n).asyncItem.value,
+                deleteItem: t(n).deleteItem,
+                refresh: t(n).refresh,
+                save: () => t(n).saveItem(t(n).asyncItem.value)
+              }, () => [
+                d(s(C.value), 1)
+              ]),
+              l(e.$slots, "append", {
+                item: t(n).asyncItem.value,
+                refresh: t(n).refresh
+              }, () => [
+                d(s(e.suffix), 1)
+              ])
+            ], 6)) : (a(), r("div", {
+              key: "2",
+              class: c(e.inline ? "d-inline" : "")
+            }, [
+              l(e.$slots, "alternate", {
+                item: t(n).asyncItem.value,
+                refresh: t(n).refresh
+              }, () => [
+                B("span", R, s(e.alternateText), 1)
+              ])
+            ], 2))
+          ]),
+          _: 3
+        }),
+        !e.inline && !e.hideLoader ? (a(), v(x, {
+          key: 0,
+          modelValue: t(n).isLoading.value,
+          "onUpdate:modelValue": y[0] || (y[0] = (G) => t(n).isLoading.value = G),
+          class: "align-center justify-center text-center",
+          contained: "",
+          persistent: ""
+        }, {
+          default: f(() => [
+            p(m, { indeterminate: "" }),
+            B("p", null, s(t(n).loadingMsg), 1)
+          ]),
+          _: 1
+        }, 8, ["modelValue"])) : g("", !0)
+      ], 2);
+    };
+  }
+});
+export {
+  z as default
+};

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

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

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

@@ -0,0 +1,15 @@
+declare const _default: import('vue').DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    errorMsg?: string | undefined;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    errorMsg?: string | undefined;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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;
+    };
+};

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

@@ -0,0 +1,35 @@
+import { defineComponent as p, ref as u, watch as d, resolveComponent as t, openBlock as _, createBlock as m, withCtx as l, createVNode as f, createTextVNode as v, toDisplayString as g } from "vue";
+const h = /* @__PURE__ */ p({
+  __name: "BT-Error",
+  props: {
+    errorMsg: {}
+  },
+  setup(n) {
+    const a = n, e = u(!1);
+    return d(() => a.errorMsg, (o) => {
+      e.value = o != null;
+    }), (o, r) => {
+      const s = t("v-alert"), c = t("v-slide-y-transition");
+      return _(), m(c, null, {
+        default: l(() => [
+          f(s, {
+            closable: "",
+            title: "Error",
+            color: "red-lighten-1",
+            modelValue: e.value,
+            "onUpdate:modelValue": r[0] || (r[0] = (i) => e.value = i)
+          }, {
+            default: l(() => [
+              v(g(o.errorMsg), 1)
+            ]),
+            _: 1
+          }, 8, ["modelValue"])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+export {
+  h as default
+};

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

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

package/dist/components/BT-Field-Checkbox.vue.d.ts

@@ -0,0 +1,57 @@
+import { BladeDensity } from '../composables/blade.ts';
+
+interface FieldProps {
+    cols?: string | boolean;
+    density?: BladeDensity;
+    horizontal?: boolean;
+    isEditing?: boolean;
+    isMobile?: boolean;
+    label: any;
+    lg?: string | boolean;
+    md?: string | boolean;
+    modelValue: any;
+    required?: boolean;
+    rules?: any;
+    sm?: string | boolean;
+}
+declare const _default: import('vue').DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FieldProps>, {
+    isEditing: undefined;
+    cols: string;
+    lg: boolean;
+    md: boolean;
+    sm: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FieldProps>, {
+    isEditing: undefined;
+    cols: string;
+    lg: boolean;
+    md: boolean;
+    sm: string;
+}>>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    isEditing: boolean;
+    sm: string | boolean;
+    cols: string | boolean;
+    lg: string | boolean;
+    md: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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];
+} & {};

package/dist/components/BT-Field-Checkbox.vue.mjs

@@ -0,0 +1,61 @@
+import { defineComponent as V, computed as o, inject as i, ref as u, resolveComponent as r, openBlock as _, createBlock as M, withCtx as k, createVNode as E, mergeProps as S } from "vue";
+import { TestRequired as C } from "../composables/rules.mjs";
+const I = /* @__PURE__ */ V({
+  inheritAttrs: !1,
+  __name: "BT-Field-Checkbox",
+  props: {
+    cols: { type: [String, Boolean], default: "12" },
+    density: {},
+    horizontal: { type: Boolean },
+    isEditing: { type: Boolean, default: void 0 },
+    isMobile: { type: Boolean },
+    label: {},
+    lg: { type: [String, Boolean], default: !1 },
+    md: { type: [String, Boolean], default: !1 },
+    modelValue: {},
+    required: { type: Boolean },
+    rules: {},
+    sm: { type: [String, Boolean], default: "6" }
+  },
+  emits: ["update:modelValue"],
+  setup(d, { emit: m }) {
+    const e = d, c = m, a = o({
+      get() {
+        return e.modelValue;
+      },
+      set(l) {
+        c("update:modelValue", l);
+      }
+    }), p = i("isEditing", () => u(!1), !0), f = o(() => e.isEditing ?? p.value), t = i("isMobile", () => u(!1), !0), s = o(() => {
+      var l = [
+        ...e.rules ?? []
+      ];
+      return e.required && l.push(C), l.length > 0 ? l : void 0;
+    }), v = o(() => e.isMobile ?? t.value ? !1 : e.lg), g = o(() => e.isMobile ?? t.value ? !1 : e.md), b = o(() => e.isMobile ?? t.value ? !1 : e.sm);
+    return (l, n) => {
+      const y = r("v-checkbox"), B = r("v-col");
+      return _(), M(B, {
+        lg: v.value,
+        md: g.value,
+        sm: b.value,
+        cols: l.cols
+      }, {
+        default: k(() => [
+          E(y, S(l.$attrs, {
+            modelValue: a.value,
+            "onUpdate:modelValue": n[0] || (n[0] = (h) => a.value = h),
+            color: "primary",
+            "hide-details": s.value == null,
+            label: l.label,
+            readonly: !f.value,
+            rules: s.value
+          }), null, 16, ["modelValue", "hide-details", "label", "readonly", "rules"])
+        ]),
+        _: 1
+      }, 8, ["lg", "md", "sm", "cols"]);
+    };
+  }
+});
+export {
+  I as default
+};

package/dist/components/BT-Field-Checkbox.vue2.mjs

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

package/dist/components/BT-Field-Date.vue.d.ts

@@ -0,0 +1,69 @@
+
+interface FieldProps {
+    canSelectNone?: boolean;
+    cols?: string | boolean;
+    colClass?: any;
+    dateFrom?: string;
+    format?: string;
+    fromNow?: boolean;
+    horizontal?: boolean;
+    ignoreMinDate?: boolean;
+    isEditing?: boolean;
+    isMobile?: boolean;
+    label?: string;
+    lg?: string | boolean;
+    md?: string | boolean;
+    modelValue: any;
+    prependIcon?: string;
+    required?: boolean;
+    rules?: any;
+    sm?: string | boolean;
+    useTime?: boolean;
+}
+declare const _default: import('vue').DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FieldProps>, {
+    isEditing: undefined;
+    cols: string;
+    lg: boolean;
+    md: boolean;
+    sm: string;
+    format: string;
+    fromNow: boolean;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FieldProps>, {
+    isEditing: undefined;
+    cols: string;
+    lg: boolean;
+    md: boolean;
+    sm: string;
+    format: string;
+    fromNow: boolean;
+}>>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    format: string;
+    isEditing: boolean;
+    sm: string | boolean;
+    cols: string | boolean;
+    lg: string | boolean;
+    md: string | boolean;
+    fromNow: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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];
+} & {};

package/dist/components/BT-Field-Date.vue.mjs

@@ -0,0 +1,120 @@
+import { defineComponent as j, computed as t, ref as c, inject as r, resolveComponent as n, openBlock as v, createBlock as f, normalizeClass as P, withCtx as a, unref as i, createVNode as u, createTextVNode as k, toDisplayString as S, mergeProps as M } from "vue";
+import Q from "../bt-core/core/node_modules/@vuepic/vue-datepicker/dist/vue-datepicker.mjs";
+import "../bt-core/core/node_modules/@vuepic/vue-datepicker/dist/main.css.mjs";
+import { useAuth as G } from "../composables/auth.mjs";
+import { useDates as H } from "../composables/dates.mjs";
+import { useTheme as J } from "vuetify";
+import { TestRequired as K } from "../composables/rules.mjs";
+const te = /* @__PURE__ */ j({
+  inheritAttrs: !1,
+  __name: "BT-Field-Date",
+  props: {
+    canSelectNone: { type: Boolean },
+    cols: { type: [String, Boolean], default: "12" },
+    colClass: {},
+    dateFrom: {},
+    format: { default: "ccc dd/LL/yyyy" },
+    fromNow: { type: Boolean, default: !1 },
+    horizontal: { type: Boolean },
+    ignoreMinDate: { type: Boolean },
+    isEditing: { type: Boolean, default: void 0 },
+    isMobile: { type: Boolean },
+    label: {},
+    lg: { type: [String, Boolean], default: !1 },
+    md: { type: [String, Boolean], default: !1 },
+    modelValue: {},
+    prependIcon: {},
+    required: { type: Boolean },
+    rules: {},
+    sm: { type: [String, Boolean], default: "6" },
+    useTime: { type: Boolean }
+  },
+  emits: ["update:modelValue"],
+  setup(T, { emit: h }) {
+    const C = J(), e = T, D = h, { btString: I, tzString: g } = H(), N = G(), s = t({
+      get() {
+        return e.modelValue == "0001-01-01T00:00:00" && e.ignoreMinDate ? I() : e.modelValue;
+      },
+      set(l) {
+        D("update:modelValue", l == null ? l : `${l.split(".")[0]}Z`);
+      }
+    }), m = t(() => e.modelValue ? g(e.modelValue, e.format) : void 0), y = c(), w = r("isEditing", () => c(!1), !0), V = t(() => e.isEditing ?? w.value), d = r("isMobile", () => c(!1), !0), _ = r("viewVariant", "list-item"), z = r("editVariant", "outlined"), b = t(() => {
+      var l = [
+        ...e.rules ?? []
+      ];
+      return e.required && l.push(K), l.length > 0 ? l : void 0;
+    }), E = t(() => e.isMobile ?? d.value ? !1 : e.lg), F = t(() => e.isMobile ?? d.value ? !1 : e.md), $ = t(() => e.isMobile ?? d.value ? !1 : e.sm);
+    return e.dateFrom != null ? y.value = e.dateFrom : e.fromNow && (y.value = g()), (l, o) => {
+      const q = n("v-list-item-subtitle"), L = n("v-list-item-title"), A = n("v-list-item"), R = n("v-text-field"), U = n("v-menu"), Z = n("v-col");
+      return v(), f(Z, {
+        class: P(l.colClass),
+        lg: E.value,
+        md: F.value,
+        sm: $.value,
+        cols: l.cols
+      }, {
+        default: a(() => [
+          !V.value && i(_) == "list-item" ? (v(), f(A, {
+            key: 0,
+            density: "compact",
+            "prepend-icon": l.prependIcon
+          }, {
+            default: a(() => [
+              u(q, null, {
+                default: a(() => [
+                  k(S(l.label), 1)
+                ]),
+                _: 1
+              }),
+              u(L, null, {
+                default: a(() => [
+                  k(S(m.value), 1)
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }, 8, ["prepend-icon"])) : (v(), f(U, {
+            key: 1,
+            "open-delay": "5"
+          }, {
+            activator: a(({ props: p }) => [
+              u(R, M({
+                "append-inner-icon": l.canSelectNone && s.value != null && s.value.length > 0 ? "$close" : void 0,
+                "onClick:appendInner": o[0] || (o[0] = (B) => s.value = void 0)
+              }, p, {
+                "hide-details": b.value == null,
+                label: l.label,
+                readonly: "",
+                rules: b.value,
+                variant: V.value ? i(z) : i(_),
+                modelValue: m.value,
+                "onUpdate:modelValue": o[1] || (o[1] = (B) => m.value = B)
+              }), null, 16, ["append-inner-icon", "hide-details", "label", "rules", "variant", "modelValue"])
+            ]),
+            default: a(() => [
+              u(i(Q), M({
+                "auto-apply": "",
+                dark: i(C).global.current.value.dark,
+                "enable-time-picker": l.useTime,
+                inline: "",
+                "is-24": !1,
+                "time-picker-inline": l.useTime,
+                timezone: i(N).timeZone.value,
+                utc: ""
+              }, l.$attrs, {
+                modelValue: s.value,
+                "onUpdate:modelValue": o[2] || (o[2] = (p) => s.value = p)
+              }), null, 16, ["dark", "enable-time-picker", "time-picker-inline", "timezone", "modelValue"])
+            ]),
+            _: 1
+          }))
+        ]),
+        _: 1
+      }, 8, ["class", "lg", "md", "sm", "cols"]);
+    };
+  }
+});
+export {
+  te as default
+};

package/dist/components/BT-Field-Date.vue2.mjs

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

package/dist/components/BT-Field-Entity.vue.d.ts

@@ -0,0 +1,48 @@
+interface FieldProps {
+    cols?: string | boolean;
+    isMobile?: boolean;
+    label?: string;
+    lg?: string | boolean;
+    md?: string | boolean;
+    prependIcon?: string;
+    prependSrc?: string;
+    sm?: string | boolean;
+}
+declare const _default: import('vue').DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FieldProps>, {
+    cols: string;
+    lg: boolean;
+    md: boolean;
+    sm: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FieldProps>, {
+    cols: string;
+    lg: boolean;
+    md: boolean;
+    sm: string;
+}>>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    sm: string | boolean;
+    cols: string | boolean;
+    lg: string | boolean;
+    md: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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];
+} & {};

package/dist/components/BT-Field-Entity.vue.mjs

@@ -0,0 +1,55 @@
+import { defineComponent as g, inject as y, ref as B, computed as s, resolveComponent as l, openBlock as a, createBlock as m, withCtx as o, createVNode as i, createTextVNode as S, toDisplayString as M, createCommentVNode as C, mergeProps as V } from "vue";
+const N = /* @__PURE__ */ g({
+  inheritAttrs: !1,
+  __name: "BT-Field-Entity",
+  props: {
+    cols: { type: [String, Boolean], default: "12" },
+    isMobile: { type: Boolean },
+    label: {},
+    lg: { type: [String, Boolean], default: !1 },
+    md: { type: [String, Boolean], default: !1 },
+    prependIcon: {},
+    prependSrc: {},
+    sm: { type: [String, Boolean], default: "6" }
+  },
+  emits: ["update:modelValue"],
+  setup(c, { emit: h }) {
+    const e = c, n = y("isMobile", () => B(!1), !0), p = s(() => e.isMobile ?? n.value ? !1 : e.lg), r = s(() => e.isMobile ?? n.value ? !1 : e.md), u = s(() => e.isMobile ?? n.value ? !1 : e.sm);
+    return (t, k) => {
+      const d = l("v-list-item-subtitle"), _ = l("bt-entity"), f = l("v-list-item-title"), v = l("v-list-item"), b = l("v-col");
+      return a(), m(b, {
+        lg: p.value,
+        md: r.value,
+        sm: u.value,
+        cols: t.cols
+      }, {
+        default: o(() => [
+          i(v, {
+            density: "compact",
+            "prepend-icon": t.prependIcon
+          }, {
+            default: o(() => [
+              t.label != null ? (a(), m(d, { key: 0 }, {
+                default: o(() => [
+                  S(M(t.label), 1)
+                ]),
+                _: 1
+              })) : C("", !0),
+              i(f, null, {
+                default: o(() => [
+                  i(_, V(t.$attrs, { isSingle: !0 }), null, 16)
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }, 8, ["prepend-icon"])
+        ]),
+        _: 1
+      }, 8, ["lg", "md", "sm", "cols"]);
+    };
+  }
+});
+export {
+  N as default
+};

package/dist/components/BT-Field-Entity.vue2.mjs

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