bt-core-app 2.1.36 → 2.2.0

package/dist/components/BT-Blade-Item.vue.mjs

@@ -0,0 +1,441 @@
+import { defineComponent as Z, ref as I, inject as _, provide as x, computed as p, resolveComponent as u, openBlock as r, createBlock as y, unref as e, withCtx as o, renderSlot as v, createVNode as c, createElementVNode as ee, createElementBlock as w, mergeProps as te, createCommentVNode as m, normalizeStyle as S, normalizeClass as B, withModifiers as ae, createTextVNode as A } from "vue";
+import { useItem as ne } from "../composables/item.mjs";
+import { useAuth as se } from "../composables/auth.mjs";
+import { useNavigation as ie } from "../composables/navigation.mjs";
+import { usePresets as oe } from "../composables/presets.mjs";
+import { useHeights as le } from "../composables/heights.mjs";
+const re = { key: "0" }, de = { key: "0.5" }, pe = /* @__PURE__ */ Z({
+  __name: "BT-Blade-Item",
+  props: {
+    actualHeight: {},
+    actualUsedHeight: {},
+    alwaysClose: { type: Boolean, default: !1 },
+    bordered: { type: Boolean },
+    canClose: { type: Boolean },
+    canDelete: { type: Boolean, default: !1 },
+    canEdit: { type: Boolean, default: !0 },
+    canRestore: { type: Boolean, default: !1 },
+    density: { default: "compact" },
+    flat: { type: Boolean, default: !0 },
+    getLabel: {},
+    heightStrat: { default: "fixed" },
+    hideBottomSave: { type: Boolean },
+    hideTopSave: { type: Boolean },
+    hideRefresh: { type: Boolean },
+    hideToolbar: { type: Boolean },
+    label: {},
+    opacity: {},
+    overrideSave: { type: Boolean },
+    preset: {},
+    showSettings: { type: Boolean },
+    transparent: { type: Boolean },
+    additionalUrl: {},
+    alwaysEditing: { type: Boolean, default: !1 },
+    bladeGroup: {},
+    bladeName: {},
+    bladeStartShowing: { type: Boolean },
+    canSave: { type: Boolean, default: !0 },
+    closeBladeNames: {},
+    confirmOnDelete: { type: Boolean },
+    eager: { type: Boolean, default: !0 },
+    eagerWithID: { type: Boolean },
+    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, default: !0 },
+    trackIgnoreProps: {},
+    trackProps: {},
+    useBladeSrc: { type: Boolean, default: void 0 },
+    useRouteSrc: { type: Boolean, default: void 0 },
+    variant: { default: "page" }
+  },
+  emits: ["fetched", "saved"],
+  setup(R, { emit: T }) {
+    const N = T, s = R, f = oe(s.preset), E = I(), { findSingleDisplay: D } = ie(), $ = se(), z = le(), i = _("size", () => I("small"), !0), t = ne(
+      s,
+      N
+    );
+    x("isEditing", t.isEditing);
+    const H = p(() => (f.canEdit ?? s.canEdit) && t.mode.value != "new"), M = p(() => f.canDelete ?? s.canDelete), U = p(() => f.canRestore ?? s.canRestore), h = p(() => !!s.overrideSave || !!(f.canSave ?? s.canSave) && t.isSaveable.value && (t.isChanged.value || t.mode.value == "new")), G = p(() => f.hideRefresh ?? s.hideRefresh), L = p(() => s.label ?? (s.getLabel != null ? s.getLabel(t.asyncItem.value) : void 0) ?? D(s.nav ?? "")), P = p(() => !!s.transparent || s.opacity != null), b = p(() => {
+      let a = "";
+      if (s.actualHeight != null)
+        return `${a} ${s.heightStrat == "upto" ? "max-height" : "height"}: calc(${s.actualHeight})`;
+      if (s.actualUsedHeight != null)
+        return `${a} ${s.heightStrat == "upto" ? "max-height" : "height"}: calc(100vh - ${z.getUsedHeight(s.actualUsedHeight)}px);`;
+      {
+        let n = 48;
+        return s.bordered ? n += 26 : s.variant == "page" && (n += 16), (s.hideToolbar == !0 || s.variant == "pure") && (n -= 48), `${a} ${s.heightStrat == "upto" ? "max-height" : "height"}: calc(100vh - ${z.getUsedHeight(n)}px)`;
+      }
+    });
+    async function l(a, n) {
+      if (E.value != null) {
+        const { valid: g } = await E.value.validate();
+        g && await t.saveItem(t.asyncItem.value, { navBack: a, stayEditing: n, updateUrl: !0 });
+      } else
+        await t.saveItem(t.asyncItem.value, { navBack: a, stayEditing: n, updateUrl: !0 });
+    }
+    return (a, n) => {
+      const g = u("v-btn"), V = u("v-list"), F = u("v-menu"), O = u("v-slide-y-transition"), j = u("v-form"), q = u("v-card-text"), K = u("v-spacer"), k = u("v-icon"), W = u("v-slide-x-transition"), J = u("v-card-actions"), Q = u("v-card"), X = u("bt-blade");
+      return r(), y(X, {
+        bladeBasic: "",
+        bladeName: a.bladeName,
+        bladeStartShowing: a.bladeStartShowing,
+        bordered: a.bordered,
+        density: a.density,
+        errorMsg: e(t).errorMsg.value,
+        flat: a.flat,
+        hideSubtoolbar: "",
+        hideToolbar: a.hideToolbar,
+        label: L.value,
+        loadingMsg: e(t).loadingMsg.value,
+        opacity: a.opacity,
+        preset: a.preset,
+        transparent: a.transparent,
+        variant: a.variant
+      }, {
+        "blade-label": o(() => [
+          v(a.$slots, "blade-label", {
+            density: a.density,
+            isChanged: e(t).isChanged.value,
+            isEditing: e(t).isEditing.value,
+            item: e(t).asyncItem.value,
+            mode: e(t).mode.value,
+            save: l,
+            size: e(i),
+            refresh: e(t).refresh,
+            ui: e(t)
+          })
+        ]),
+        "blade-title-left": o(() => [
+          v(a.$slots, "blade-title-left", {
+            density: a.density,
+            isChanged: e(t).isChanged.value,
+            isEditing: e(t).isEditing.value,
+            item: e(t).asyncItem.value,
+            mode: e(t).mode.value,
+            save: l,
+            size: e(i),
+            refresh: e(t).refresh,
+            ui: e(t)
+          })
+        ]),
+        "blade-toolbar-left": o(() => [
+          v(a.$slots, "toolbar-left", { ui: e(t) })
+        ]),
+        "blade-toolbar": o(() => [
+          v(a.$slots, "blade-toolbar", {
+            density: a.density,
+            isChanged: e(t).isChanged.value,
+            isEditing: e(t).isEditing.value,
+            item: e(t).asyncItem.value,
+            mode: e(t).mode.value,
+            save: l,
+            size: e(i),
+            refresh: e(t).refresh,
+            ui: e(t)
+          })
+        ]),
+        "blade-toolbar-right": o(() => [
+          c(O, {
+            group: "",
+            "hide-on-leave": ""
+          }, {
+            default: o(() => [
+              ee("div", re, [
+                v(a.$slots, "toolbar-right", {
+                  density: a.density,
+                  isChanged: e(t).isChanged.value,
+                  isEditing: e(t).isEditing.value,
+                  item: e(t).asyncItem.value,
+                  mode: e(t).mode.value,
+                  save: l,
+                  size: e(i),
+                  ui: e(t)
+                })
+              ]),
+              a.showSettings ? (r(), w("div", de, [
+                a.showSettings ? (r(), y(F, {
+                  "close-on-content-click": !1,
+                  density: a.density,
+                  key: "1"
+                }, {
+                  activator: o(({ props: d }) => [
+                    c(g, te({
+                      icon: "$cog",
+                      key: "2",
+                      size: e(i)
+                    }, d, { variant: "text" }), null, 16, ["size"])
+                  ]),
+                  default: o(() => [
+                    c(V, {
+                      density: a.density,
+                      "min-width": "300"
+                    }, {
+                      default: o(() => [
+                        v(a.$slots, "settings", {
+                          density: a.density,
+                          isChanged: e(t).isChanged.value,
+                          isEditing: e(t).isEditing.value,
+                          item: e(t).asyncItem.value,
+                          mode: e(t).mode.value,
+                          save: l,
+                          size: e(i),
+                          ui: e(t)
+                        })
+                      ]),
+                      _: 3
+                    }, 8, ["density"])
+                  ]),
+                  _: 3
+                }, 8, ["density"])) : m("", !0)
+              ])) : m("", !0),
+              h.value && !a.hideTopSave ? (r(), y(g, {
+                onClick: n[0] || (n[0] = (d) => l(!!a.alwaysClose)),
+                icon: "$content-save",
+                size: e(i),
+                title: "Save",
+                key: "3",
+                variant: "text"
+              }, null, 8, ["size"])) : m("", !0),
+              G.value ? m("", !0) : (r(), y(g, {
+                icon: "$refresh",
+                onClick: n[1] || (n[1] = (d) => e(t).runRefresh({ deepRefresh: !0 })),
+                size: e(i),
+                title: "Refresh",
+                key: "4",
+                variant: "text"
+              }, null, 8, ["size"])),
+              !a.alwaysEditing && !h.value && H.value && e(t).isEditable.value ? (r(), y(g, {
+                loading: e(t).isChangingMode.value,
+                icon: e(t).mode.value == "edit" ? "$pencil-off" : "$pencil",
+                onClick: e(t).toggleMode,
+                size: e(i),
+                disabled: !e($).canEdit(a.nav),
+                title: "Edit",
+                key: "5",
+                variant: "text"
+              }, null, 8, ["loading", "icon", "onClick", "size", "disabled"])) : m("", !0),
+              M.value && e(t).isDeletable.value ? (r(), y(g, {
+                icon: "$delete",
+                onClick: n[2] || (n[2] = (d) => e(t).deleteItem(e(t).asyncItem.value)),
+                size: e(i),
+                disabled: !e($).canEdit(a.nav),
+                title: "Delete",
+                key: "6",
+                variant: "text"
+              }, null, 8, ["size", "disabled"])) : m("", !0),
+              U.value && e(t).isRestorable.value ? (r(), y(g, {
+                icon: "$eraser-variant",
+                onClick: n[3] || (n[3] = (d) => e(t).restoreItem(e(t).asyncItem.value)),
+                size: e(i),
+                disabled: !e($).canEdit(a.nav),
+                title: "Restore",
+                key: "7",
+                variant: "text"
+              }, null, 8, ["size", "disabled"])) : m("", !0)
+            ]),
+            _: 3
+          })
+        ]),
+        content: o(({ isMobile: d, bladeData: C }) => [
+          v(a.$slots, "body", {
+            bladeData: C,
+            density: a.density,
+            isChanged: e(t).isChanged.value,
+            isEditing: e(t).isEditing.value,
+            isMobile: d,
+            item: e(t).asyncItem.value,
+            mode: e(t).mode.value,
+            save: l,
+            size: e(i),
+            style: S(b.value),
+            ui: e(t)
+          }, () => [
+            v(a.$slots, "top", {
+              density: a.density,
+              isChanged: e(t).isChanged.value,
+              isEditing: e(t).isEditing.value,
+              isMobile: d,
+              item: e(t).asyncItem.value,
+              mode: e(t).mode.value,
+              refresh: e(t).refresh,
+              save: l,
+              size: e(i),
+              ui: e(t)
+            }),
+            e(t).asyncItem.value == null && !e(t).isLoading.value ? (r(), w("div", {
+              key: 0,
+              class: B(["overflow-y-auto", {}]),
+              style: S(b.value)
+            }, [
+              v(a.$slots, "notFound", {
+                bladeData: C,
+                density: a.density,
+                isChanged: e(t).isChanged.value,
+                isEditing: e(t).isEditing.value,
+                isMobile: d,
+                mode: e(t).mode.value,
+                refresh: e(t).refresh,
+                save: l,
+                size: e(i),
+                style: S(b.value),
+                ui: e(t)
+              })
+            ], 4)) : e(t).asyncItem.value != null ? (r(), y(Q, {
+              key: 1,
+              class: B(["overflow-y-auto", P.value ? "transparent" : ""]),
+              flat: a.flat,
+              style: S(b.value)
+            }, {
+              default: o(() => [
+                c(q, { class: "pa-0" }, {
+                  default: o(() => [
+                    c(j, {
+                      ref_key: "form",
+                      ref: E,
+                      onSubmit: n[4] || (n[4] = ae(() => {
+                      }, ["prevent"]))
+                    }, {
+                      default: o(() => [
+                        v(a.$slots, "default", {
+                          bladeData: C,
+                          density: a.density,
+                          isChanged: e(t).isChanged.value,
+                          isEditing: e(t).isEditing.value,
+                          isMobile: d,
+                          item: e(t).asyncItem.value,
+                          mode: e(t).mode.value,
+                          refresh: e(t).refresh,
+                          save: l,
+                          size: e(i),
+                          style: S(b.value),
+                          ui: e(t)
+                        })
+                      ]),
+                      _: 2
+                    }, 1536)
+                  ]),
+                  _: 2
+                }, 1024),
+                h.value && !a.hideBottomSave ? (r(), y(J, { key: 0 }, {
+                  default: o(() => [
+                    v(a.$slots, "bottom-left", {
+                      bladeData: C,
+                      density: a.density,
+                      isChanged: e(t).isChanged.value,
+                      isEditing: e(t).isEditing.value,
+                      isMobile: d,
+                      item: e(t).asyncItem.value,
+                      mode: e(t).mode.value,
+                      refresh: e(t).refresh,
+                      save: l,
+                      size: e(i),
+                      ui: e(t)
+                    }),
+                    c(K),
+                    c(W, { group: "" }, {
+                      default: o(() => [
+                        !a.alwaysClose && h.value ? (r(), y(g, {
+                          key: 0,
+                          onClick: n[5] || (n[5] = (Y) => l(!1)),
+                          size: e(i),
+                          class: B(e(t).isMobile.value ? "ma-0" : "mr-4")
+                        }, {
+                          default: o(() => [
+                            c(k, {
+                              size: e(i),
+                              start: "",
+                              icon: "$content-save"
+                            }, null, 8, ["size"]),
+                            n[7] || (n[7] = A("Save "))
+                          ]),
+                          _: 2
+                        }, 1032, ["size", "class"])) : m("", !0),
+                        (a.canClose || a.alwaysClose) && h.value ? (r(), y(g, {
+                          key: 1,
+                          onClick: n[6] || (n[6] = (Y) => l(!0)),
+                          size: e(i),
+                          class: B(e(t).isMobile.value ? "ma-0" : "mr-4")
+                        }, {
+                          default: o(() => [
+                            c(k, {
+                              size: e(i),
+                              start: "",
+                              icon: "$content-save"
+                            }, null, 8, ["size"]),
+                            n[8] || (n[8] = A("Save/Close "))
+                          ]),
+                          _: 2
+                        }, 1032, ["size", "class"])) : m("", !0)
+                      ]),
+                      _: 2
+                    }, 1024)
+                  ]),
+                  _: 2
+                }, 1024)) : m("", !0)
+              ]),
+              _: 2
+            }, 1032, ["class", "flat", "style"])) : m("", !0),
+            v(a.$slots, "bottom", {
+              bladeData: C,
+              item: e(t).asyncItem.value,
+              density: a.density,
+              isEditing: e(t).isEditing.value,
+              isMobile: d,
+              mode: e(t).mode.value,
+              size: e(i)
+            })
+          ])
+        ]),
+        _: 3
+      }, 8, ["bladeName", "bladeStartShowing", "bordered", "density", "errorMsg", "flat", "hideToolbar", "label", "loadingMsg", "opacity", "preset", "transparent", "variant"]);
+    };
+  }
+});
+export {
+  pe as default
+};

package/dist/components/BT-Blade-Item.vue2.mjs

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