bt-core-app 2.1.36 → 2.2.0

package/dist/composables/item.d.ts

@@ -0,0 +1,132 @@
+import { PathOptions } from './api.ts';
+import { BladeData, BladeMode, BladeVariant } from '../composables/blade.ts';
+import { StorageMode, StoreMode } from './stores.ts';
+import { GetOptions, OnCanDoAsync, OnDoActionAsync, OnDoSuccessAsync, OnGetAsync, OnGetSuccessAsync, OnGetAllAsync, OnGetAllSuccessAsync, OnDoMaybeSuccessAsync } from './actions.ts';
+
+export interface ItemProps<T, TSave, TReturn> {
+    additionalUrl?: string;
+    alwaysEditing?: boolean;
+    bladeGroup?: string;
+    bladeName?: string;
+    bladeStartShowing?: boolean;
+    canSave?: boolean;
+    closeBladeNames?: string[] | string;
+    confirmOnDelete?: boolean;
+    eager?: boolean;
+    eagerWithID?: boolean;
+    errorMsg?: string;
+    findItem?: (list?: TReturn[]) => TReturn | undefined;
+    ignorePermissions?: boolean;
+    isSingle?: boolean;
+    item?: any;
+    itemID?: string;
+    loadingMsg?: string;
+    localPredicate?: (item: any) => boolean;
+    nav?: string;
+    navSuffix?: string;
+    onBeforeEditAsync?: (item: TReturn | TReturn[] | undefined) => Promise<TReturn | TReturn[] | undefined>;
+    onBeforeViewAsync?: (item: TReturn | TReturn[] | undefined) => Promise<TReturn | TReturn[] | undefined>;
+    onCanDelete?: (item: TReturn) => boolean;
+    onCanDeleteAsync?: OnCanDoAsync<TReturn>;
+    onCanEdit?: (item: TReturn) => boolean;
+    onCanRestore?: (item: TReturn) => boolean;
+    onCanRestoreAsync?: OnCanDoAsync<TReturn>;
+    onCanSave?: (item: TReturn) => boolean;
+    onCanSaveAsync?: OnCanDoAsync<TReturn | TSave>;
+    onDeleteAsync?: OnDoActionAsync<TReturn>;
+    onDeleteSuccessAsync?: OnDoMaybeSuccessAsync<TReturn, TReturn>;
+    onError?: (err: any) => any;
+    onGetAsync?: OnGetAsync<T>;
+    onGetListAsync?: OnGetAllAsync<T>;
+    onGetListSuccessAsync?: OnGetAllSuccessAsync<T, TReturn>;
+    onGetSuccessAsync?: OnGetSuccessAsync<T, TReturn>;
+    onGetNew?: (data?: PathOptions) => TReturn;
+    onGetNewAsync?: (data?: PathOptions) => Promise<TReturn>;
+    onGetNotFound?: (data?: PathOptions) => TReturn;
+    onGetSaveAsync?: OnDoSuccessAsync<TReturn, TSave>;
+    onRefreshAsync?: (refreshOptions?: ItemRefreshOptions) => Promise<void> | undefined;
+    onRestoreAsync?: OnDoActionAsync<TReturn>;
+    onRestoreSuccessAsync?: OnDoSuccessAsync<TReturn, TReturn>;
+    onSaveAsync?: (item: TSave | TReturn) => Promise<TReturn | undefined>;
+    onSaveSuccessAsync?: OnDoSuccessAsync<TReturn, TReturn>;
+    onUpdateAsyncItem?: (asyncItem: TReturn | TReturn[] | undefined, newVersionItem: T) => void;
+    params?: any;
+    proxyID?: string;
+    proxyKey?: string;
+    queryParams?: string[] | Record<string, string>[];
+    refreshOnChange?: boolean;
+    refreshLiteToggle?: boolean;
+    refreshToggle?: boolean;
+    resetTrackerToggle?: boolean;
+    startEditing?: boolean;
+    storeMode?: StoreMode;
+    storageMode?: StorageMode;
+    trackChanges?: boolean;
+    trackIgnoreProps?: string[];
+    trackProps?: string[];
+    useBladeSrc?: boolean;
+    useRouteSrc?: boolean;
+    variant?: BladeVariant;
+}
+export interface ItemRefreshOptions {
+    bladeData?: BladeData;
+    deepRefresh?: boolean;
+    resetMode?: boolean;
+}
+export interface SaveItemOptions {
+    navBack?: boolean;
+    stayEditing?: boolean;
+    updateUrl?: boolean;
+}
+export interface UseItemOptions {
+    onGetItem?: (item: any) => void;
+    onError?: (err: any) => any;
+    storeMode?: StoreMode;
+    storageMode?: StorageMode;
+    useRouteSrc?: boolean;
+    useBladeSrc?: boolean;
+}
+export interface ItemEvents {
+    (e: 'fetched', item: any): void;
+    (e: 'saved', item: any, isNew?: boolean): void;
+}
+/**
+ *
+ * @param props
+ * bladeName <-- props.bladeName ?? props.nav ?? 'basic'
+ * nav <-- props.nav ?? undefined
+ * @param options
+ * @returns
+ */
+export declare function useItem<T, TSave, TReturn>(props: ItemProps<T, TSave, TReturn>, emit?: ItemEvents, options?: UseItemOptions): {
+    blades: import('vue').Ref<BladeData[], BladeData[]>;
+    bladeData: BladeData;
+    closeBlade: (options?: import('../composables/blade.ts').CloseBladeOptions | undefined) => void;
+    closeBladeAsync: (options?: import('../composables/blade.ts').CloseBladeOptions | undefined) => Promise<void>;
+    isMobile: import('vue').Ref<boolean, boolean>;
+    isShowing: import('vue').ComputedRef<(bladeName?: string | undefined) => boolean>;
+    updateBlade: (data: import('../composables/blade.ts').UpdateBladeData<GetOptions<T, TReturn>>) => void;
+    variant: import('vue').Ref<BladeVariant, BladeVariant>;
+    asyncItem: import('vue').Ref<TReturn | TReturn[] | undefined, TReturn | TReturn[] | undefined>;
+    isChangingMode: import('vue').Ref<boolean, boolean>;
+    deleteItem: (dItem: any) => Promise<void>;
+    errorMsg: import('vue').ComputedRef<string | undefined>;
+    id: import('vue').ComputedRef<string | undefined>;
+    isChanged: import('vue').Ref<boolean, boolean>;
+    isDeletable: import('vue').ComputedRef<boolean>;
+    isEditing: import('vue').ComputedRef<boolean>;
+    isEditable: import('vue').ComputedRef<boolean>;
+    isLoading: import('vue').ComputedRef<boolean>;
+    isNew: import('vue').ComputedRef<boolean>;
+    isRestorable: import('vue').ComputedRef<boolean>;
+    isSaveable: import('vue').ComputedRef<boolean>;
+    loadingMsg: import('vue').ComputedRef<string | undefined>;
+    mode: import('vue').Ref<BladeMode, BladeMode>;
+    proxyID: import('vue').ComputedRef<string | undefined>;
+    refresh: (refreshOptions?: ItemRefreshOptions) => Promise<void>;
+    restoreItem: (dItem: any) => Promise<TReturn | undefined>;
+    runRefresh: (refreshOptions?: ItemRefreshOptions) => Promise<void>;
+    saveItem: (dItem: any, options?: SaveItemOptions) => Promise<TReturn | undefined>;
+    showError: import('vue').ShallowRef<boolean, boolean>;
+    toggleMode: () => Promise<void>;
+};

package/dist/composables/item.mjs

@@ -0,0 +1,263 @@
+import { ref as E, computed as f, shallowRef as se, toValue as P, watch as I, onMounted as ye } from "vue";
+import { useStoreDefinition as me } from "./stores.mjs";
+import { useTracker as oe } from "./track.mjs";
+import { useRoute as we, useRouter as ge } from "vue-router";
+import { useActions as Ae } from "./actions.mjs";
+import { useBlade as Ie } from "./blade.mjs";
+import { useNavBack as De, useNavigation as Se } from "./navigation.mjs";
+import { useDialogConfirm as Ne } from "./dialog-items.mjs";
+import { isLengthyArray as Ge } from "./helpers.mjs";
+function ke(e, G, c) {
+  var K;
+  const j = Se(), R = (c == null ? void 0 : c.useBladeSrc) ?? e.useBladeSrc ?? !!e.bladeName, k = (c == null ? void 0 : c.useRouteSrc) ?? e.useRouteSrc ?? e.variant == "page", T = e.proxyKey ?? "proxyID", v = e.nav ?? e.bladeName, z = e.storeMode ?? (c == null ? void 0 : c.storeMode), H = e.storageMode ?? (c == null ? void 0 : c.storageMode), J = (K = j.findItem(v)) == null ? void 0 : K.deleteStrat, D = E(!1), { navBack: U } = De(), t = we(), Q = ge(), i = Ie({
+    bladeGroup: e.bladeGroup,
+    bladeName: e.bladeName,
+    onUpdate: (a) => {
+      var l;
+      w({
+        bladeData: a,
+        deepRefresh: !!e.refreshOnChange || !!((l = a == null ? void 0 : a.data) != null && l.refresh),
+        resetMode: !0
+      });
+    },
+    bladeStartShowing: e.bladeStartShowing
+  }), o = f(() => {
+    var l, n;
+    let a = e.proxyID;
+    return a == null && R && ((l = i == null ? void 0 : i.bladeData) == null ? void 0 : l.data) != null && (a = i.bladeData.data[T]), a == null && k && (a = (n = t == null ? void 0 : t.query) == null ? void 0 : n[T]), a;
+  }), u = E(), { actionErrorMsg: X, actionLoadingMsg: Y, deleteItem: Z, getItem: _, getAllItems: $, restoreItem: O, saveItem: p } = Ae({
+    nav: v,
+    onError: e.onError ?? (c == null ? void 0 : c.onError),
+    proxyID: o.value,
+    store: v != null ? me({
+      storeMode: z,
+      storageMode: H,
+      nav: v,
+      proxyID: o.value
+    }) : void 0
+  }), V = f(() => e.errorMsg ?? X.value), L = f(() => e.loadingMsg ?? Y.value), ee = f(() => L.value != null), g = f(() => {
+    var l, n, s;
+    let a = e.itemID;
+    return a == null && R && ((l = i == null ? void 0 : i.bladeData) == null ? void 0 : l.data) != null && (a = i.bladeData.data.id), a == null && k && (a = ((n = t == null ? void 0 : t.query) == null ? void 0 : n.id) ?? ((s = t == null ? void 0 : t.params) == null ? void 0 : s.id)), a;
+  }), d = E(g.value == "new" ? "new" : e.startEditing || e.alwaysEditing ? "edit" : "view"), h = se(!1), q = f(() => {
+    var l;
+    let a = e.params != null ? { ...e.params } : {};
+    return Ge(e.queryParams) && (t == null ? void 0 : t.query) != null && ((l = e.queryParams) == null || l.forEach((n) => {
+      typeof n == "string" ? (t == null ? void 0 : t.query[n]) != null && (a[n] = t == null ? void 0 : t.query[n]) : (t == null ? void 0 : t.query[n.key]) != null && (a[n.value] = t == null ? void 0 : t.query[n.key]);
+    })), a;
+  }), ae = f(() => {
+    if (d.value == "new")
+      return !1;
+    const a = P(u);
+    return a != null && e.onCanDelete != null ? e.onCanDelete(a) : (a == null ? void 0 : a.isInactive) !== !0;
+  }), le = f(() => {
+    if (d.value == "new")
+      return !1;
+    const a = P(u);
+    return e.onCanEdit != null ? e.onCanEdit(a) : !0;
+  }), te = f(() => {
+    if (d.value == "new")
+      return !1;
+    const a = P(u);
+    return e.onCanRestore != null ? e.onCanRestore(a) : (a == null ? void 0 : a.isInactive) === !0;
+  }), ne = f(() => {
+    const a = P(u);
+    return e.onCanSave != null ? e.onCanSave(a) : !0;
+  }), C = e.onUpdateAsyncItem ?? ((a, l) => {
+    l.hasOwnProperty("rowVersion") && (a.rowVersion = l.rowVersion), l.hasOwnProperty("version") && (a.version = l.version), l.hasOwnProperty("isDeleted") && (a.isDeleted = l.isDeleted), l.hasOwnProperty("isInactive") && (a.isInactive = l.isInactive), l.hasOwnProperty("id") && (a.id = l.id);
+  }), { isChanged: ue, restartTracker: S } = oe(u, {
+    useTracker: e.trackChanges,
+    propsToIgnore: e.trackIgnoreProps,
+    propsToTrack: e.trackProps
+  });
+  async function ce(a) {
+    if (e.confirmOnDelete) {
+      var l = await Ne({ text: "Are you sure you want to delete?" });
+      if (!l.isConfirmed)
+        return;
+    }
+    const {
+      additionalUrl: n,
+      onDeleteAsync: s,
+      onDeleteSuccessAsync: m = (A) => (J == "soft" ? (C(u.value, A), S()) : e.bladeName ? (i.closeBlade({ bladeName: e.bladeName }), e.closeBladeNames != null && i.closeBlade({ bladeName: e.closeBladeNames })) : U(!0), Promise.resolve(void 0))
+    } = { ...e };
+    await Z({
+      additionalUrl: n,
+      data: a,
+      nav: v,
+      onDeleteAsync: s,
+      onDeleteSuccessAsync: m,
+      proxyID: o.value
+      // ...params.getOptions(),
+      //...(useBladeSrc ? bladeData.value : {}),
+      //requireConfirmation: true
+    });
+  }
+  function ie(a) {
+    const {
+      additionalUrl: l,
+      onRestoreAsync: n,
+      onRestoreSuccessAsync: s = (m) => (C(u.value, m), S(), m)
+    } = { ...e };
+    return O({
+      additionalUrl: l,
+      data: a,
+      nav: v,
+      onRestoreAsync: n,
+      onRestoreSuccessAsync: s,
+      proxyID: o.value
+      // ...params.getOptions(),
+      // ...(useBladeSrc ? bladeData.value : {}),
+    });
+  }
+  async function de(a) {
+    e.onRefreshAsync != null ? await e.onRefreshAsync(a) : await w(a);
+  }
+  async function w(a) {
+    var s, m, A, b, B, N, M, W;
+    h.value = !1;
+    var l = e.item ?? ((m = (s = i.bladeData) == null ? void 0 : s.data) == null ? void 0 : m.data) ?? ((b = (A = a == null ? void 0 : a.bladeData) == null ? void 0 : A.data) == null ? void 0 : b.data);
+    if (a != null && a.resetMode) {
+      var n = g.value == "new" ? "new" : e.startEditing || e.alwaysEditing ? "edit" : "view";
+      n == "view" ? await x() : n == "edit" ? await F() : await fe();
+    }
+    if (l != null) {
+      let y = { data: l }, r = e.onGetSuccessAsync != null ? await e.onGetSuccessAsync(y, { refresh: (a == null ? void 0 : a.deepRefresh) ?? !1 }) : y;
+      u.value = (r == null ? void 0 : r.data) ?? void 0;
+    } else {
+      if (e.additionalUrl == null && e.nav == null) {
+        u.value = void 0;
+        return;
+      }
+      if (e.isSingle) {
+        const y = {
+          additionalUrl: e.additionalUrl,
+          id: g.value,
+          localPredicate: e.localPredicate,
+          nav: v,
+          proxyID: o.value,
+          params: {
+            ...q.value,
+            ...R ? (N = (B = i.bladeData) == null ? void 0 : B.data) == null ? void 0 : N.params : {}
+          },
+          refresh: (a == null ? void 0 : a.deepRefresh) ?? !1,
+          onGetAsync: e.onGetAsync,
+          onGetSuccessAsync: e.onGetSuccessAsync
+        };
+        if (y.id === "new")
+          e.onGetNew != null ? u.value = e.onGetNew(y) : e.onGetNewAsync != null ? u.value = await e.onGetNewAsync(y) : u.value = {};
+        else if (v != null) {
+          const r = await _(y);
+          r != null && (u.value = r.data), u.value == null && e.onGetNotFound != null && (u.value = e.onGetNotFound(y));
+        }
+      } else if (v != null) {
+        const y = {
+          additionalUrl: e.additionalUrl,
+          id: g.value,
+          localPredicate: e.localPredicate,
+          nav: v,
+          proxyID: o.value,
+          params: {
+            ...q.value,
+            ...R ? (W = (M = i.bladeData) == null ? void 0 : M.data) == null ? void 0 : W.params : {}
+          },
+          refresh: (a == null ? void 0 : a.deepRefresh) ?? !1,
+          onGetAsync: e.onGetListAsync,
+          onGetSuccessAsync: e.onGetListSuccessAsync
+        }, r = await $(y);
+        e.findItem != null ? u.value = e.findItem(r == null ? void 0 : r.data) : u.value = (r == null ? void 0 : r.data) ?? void 0;
+      }
+    }
+    S(), (c == null ? void 0 : c.onGetItem) != null && c.onGetItem(u.value), G && G("fetched", u.value);
+  }
+  function re(a, l) {
+    const n = a.id == null, {
+      additionalUrl: s,
+      onCanSaveAsync: m,
+      onGetSaveAsync: A,
+      onSaveAsync: b,
+      onSaveSuccessAsync: B = (N) => {
+        if (C(u.value, N), (l == null ? void 0 : l.navBack) === !0)
+          e.bladeName ? (i.closeBlade({ bladeName: e.bladeName }), e.closeBladeNames != null && i.closeBlade({ bladeName: e.closeBladeNames })) : U(n);
+        else if (S(), !(l != null && l.stayEditing) && !e.alwaysEditing && x(), l != null && l.updateUrl && n) {
+          const M = {
+            ...t,
+            params: {
+              ...t.params,
+              id: N.id
+            },
+            query: {},
+            replace: !0
+          };
+          Q.replace(M);
+        }
+        return G && G("saved", a, n), Promise.resolve(void 0);
+      }
+    } = { ...e };
+    return p({
+      additionalUrl: s,
+      data: a,
+      nav: v,
+      onCanSaveAsync: m,
+      onGetSaveAsync: A,
+      onSaveAsync: b,
+      onSaveSuccessAsync: B,
+      proxyID: o.value
+    });
+  }
+  async function fe() {
+    d.value = "new";
+  }
+  async function F() {
+    D.value = !0, d.value != "edit" && e.onBeforeEditAsync != null && await e.onBeforeEditAsync(u.value), d.value = "edit", D.value = !1;
+  }
+  async function x() {
+    D.value = !0, d.value != "view" && e.onBeforeViewAsync != null && await e.onBeforeViewAsync(u.value), d.value = "view", D.value = !1;
+  }
+  async function ve() {
+    d.value == "view" ? await F() : await x();
+  }
+  return I(V, (a) => {
+    h.value = a != null;
+  }), I(() => e.refreshToggle, () => {
+    w({ deepRefresh: !0 });
+  }), I(() => e.refreshLiteToggle, () => {
+    w();
+  }), I(() => e.resetTrackerToggle, () => {
+    S();
+  }), I(() => e.itemID, () => {
+    w({ deepRefresh: !!e.refreshOnChange });
+  }), I(() => e.proxyID, () => {
+    w({ deepRefresh: !!e.refreshOnChange });
+  }), ye(async () => {
+    var a;
+    (e.eager == !0 || e.eagerWithID == !0 && (g.value != null || e.localPredicate != null)) && await w({ deepRefresh: ((a = t == null ? void 0 : t.params) == null ? void 0 : a.refresh) == "true" });
+  }), {
+    asyncItem: u,
+    isChangingMode: D,
+    deleteItem: ce,
+    errorMsg: V,
+    id: g,
+    isChanged: ue,
+    isDeletable: ae,
+    isEditing: f(() => d.value == "new" || d.value == "edit"),
+    isEditable: le,
+    isLoading: ee,
+    isNew: f(() => d.value == "new"),
+    isRestorable: te,
+    isSaveable: ne,
+    loadingMsg: L,
+    mode: d,
+    proxyID: o,
+    refresh: w,
+    restoreItem: ie,
+    runRefresh: de,
+    saveItem: re,
+    showError: h,
+    toggleMode: ve,
+    ...i
+  };
+}
+export {
+  ke as useItem
+};

package/dist/composables/iterating.d.ts

@@ -0,0 +1 @@
+export {};