bt-core-app 2.1.37 → 2.2.0

package/dist/composables/confirm.mjs

@@ -0,0 +1,11 @@
+import { useDialogConfirm as r } from "./dialog-items.mjs";
+async function m(i, f) {
+  if (f) {
+    var o = await r({});
+    o.isConfirmed && i();
+  } else
+    i();
+}
+export {
+  m as useConfirm
+};

package/dist/composables/cosmetics.d.ts

@@ -0,0 +1,44 @@
+import { ComputedRef, Ref } from 'vue';
+import { ThemeInstance } from 'vuetify';
+
+export interface CosmeticData {
+    dark?: BaseCosmeticTheme;
+    drawer?: boolean;
+    drawerStick?: boolean;
+    light?: BaseCosmeticTheme;
+    theme?: string;
+}
+export interface BaseCosmeticTheme extends Record<string, string> {
+    primary: string;
+}
+export interface UseCosmeticsOptions<T extends BaseCosmeticTheme> {
+    defaultDarkTheme?: T;
+    defaultLightTheme?: T;
+    defaultDrawer?: boolean;
+    defaultDrawerStick?: boolean;
+    defaultTheme?: string;
+    storageName?: string;
+    vuetifyInstance?: ThemeInstance;
+}
+export interface BTCosmetics {
+    state: Ref<CosmeticData>;
+    currentSet: ComputedRef<BaseCosmeticTheme>;
+    resetCosmetics: (toDefault: boolean) => void;
+    saveState: () => void;
+    setTemporaryColor: (color: string) => void;
+    toggleDrawer: () => void;
+    toggleDrawerStick: () => void;
+    toggleLightDark: () => void;
+    updateDrawer: (isOpen: boolean) => void;
+    undoTemporaryColor: () => void;
+}
+export declare function useCosmetics(): BTCosmetics;
+export interface UseLocalCosmeticsOptions {
+    defaultTheme?: string;
+    dark?: any;
+    light?: any;
+    storageName?: string;
+}
+/**Returns a theme options object to pass into the create vuetify theme options */
+export declare function useLocalCosmetics(options?: UseLocalCosmeticsOptions): any;
+export declare function createCosmetics<T extends BaseCosmeticTheme>(options: UseCosmeticsOptions<T>): BTCosmetics;

package/dist/composables/cosmetics.mjs

@@ -0,0 +1,125 @@
+import { ref as w, watch as T, computed as C } from "vue";
+const m = {
+  primary: "#192233",
+  secondary: "#192233",
+  accent: "#2a76a2",
+  error: "#FF5252",
+  info: "#2196F3",
+  success: "#4CAF50",
+  warning: "#FB8C00"
+}, h = {
+  primary: "#1d5474",
+  secondary: "#192233",
+  accent: "#7fcbf7",
+  error: "#FF5252",
+  info: "#2196F3",
+  success: "#4CAF50",
+  warning: "#FB8C00"
+};
+let d;
+function D() {
+  return d;
+}
+function b(a) {
+  const t = localStorage.getItem((a == null ? void 0 : a.storageName) ?? "cosmetics");
+  let e;
+  return t != null && t.length > 0 && (e = JSON.parse(t)), e ?? (e = {}), e.dark ?? (e.dark = a == null ? void 0 : a.dark), e.light ?? (e.light = a == null ? void 0 : a.light), e.theme ?? (e.theme = a == null ? void 0 : a.defaultTheme), {
+    defaultTheme: e.theme ?? "dark",
+    themes: {
+      dark: {
+        colors: e.dark
+      },
+      light: {
+        colors: e.light
+      }
+    }
+  };
+}
+function A(a) {
+  const t = w({});
+  let e = a.vuetifyInstance, s = a.storageName ?? "cosmetics";
+  function n() {
+    const r = localStorage.getItem(s);
+    r != null && r.length > 0 ? t.value = JSON.parse(r) : t.value = {
+      theme: a.defaultTheme ?? "light",
+      light: { ...m, ...a.defaultLightTheme },
+      dark: { ...h, ...a.defaultDarkTheme },
+      drawer: a.defaultDrawer ?? !0,
+      drawerStick: a.defaultDrawerStick ?? !1
+    }, i(!1);
+  }
+  function c() {
+    localStorage.setItem(s, JSON.stringify(t.value));
+  }
+  function i(r) {
+    var l;
+    if (e != null) {
+      e.change(t.value.theme);
+      let u;
+      e.global.name.value == "dark" ? (r && (t.value.dark = { ...h, ...a.defaultDarkTheme }), e.themes.value.dark = {
+        ...e.themes.value.dark,
+        colors: {
+          ...e.themes.value.dark.colors,
+          ...t.value.dark
+        }
+      }, u = e.themes.value.dark.colors.primary) : (r && (t.value.light = { ...m, ...a.defaultLightTheme }), e.themes.value.light = {
+        ...e.themes.value.light,
+        colors: {
+          ...e.themes.value.light.colors,
+          ...t.value.light
+        }
+      }, u = e.themes.value.light.colors.primary), (l = document.querySelector('meta[name="theme-color"]')) == null || l.setAttribute("content", u), c();
+    }
+  }
+  function o(r) {
+    var l;
+    if (e != null) {
+      const u = e.themes.value.dark, S = e.themes.value.light;
+      u.colors.primary = r, S.colors.primary = r, (l = document.querySelector('meta[name="theme-color"]')) == null || l.setAttribute("content", r);
+    }
+  }
+  function g() {
+    t.value.drawer = !t.value.drawer, c();
+  }
+  function f(r) {
+    t.value.drawer = r, c();
+  }
+  function v() {
+    t.value.drawerStick = !t.value.drawerStick, c();
+  }
+  function k() {
+    var r;
+    if (t.value.theme = t.value.theme == "dark" ? "light" : "dark", e != null) {
+      e.change(t.value.theme);
+      let l = e == null ? void 0 : e.themes.value, u = e.global.name.value == "dark" ? l.dark.colors.primary : l.light.colors.primary;
+      (r = document.querySelector('meta[name="theme-color"]')) == null || r.setAttribute("content", u);
+    }
+    c();
+  }
+  function y() {
+    var r;
+    if (e != null) {
+      const l = e.themes.value.dark, u = e.themes.value.light;
+      l.colors.primary = (t.value.dark ?? { ...h, ...a.defaultDarkTheme }).primary, u.colors.primary = (t.value.light ?? { ...m, ...a.defaultLightTheme }).primary, (r = document.querySelector('meta[name="theme-color"]')) == null || r.setAttribute("content", "");
+    }
+  }
+  return n(), T(t, () => {
+    c();
+  }), d = {
+    state: t,
+    currentSet: C(() => t.value.theme == "dark" ? t.value.dark : t.value.light),
+    resetCosmetics: i,
+    saveState: c,
+    setTemporaryColor: o,
+    toggleDrawer: g,
+    toggleDrawerStick: v,
+    toggleLightDark: k,
+    updateDrawer: f,
+    undoTemporaryColor: y
+  }, d;
+}
+export {
+  A as createCosmetics,
+  D as useCosmetics,
+  b as useLocalCosmetics
+};

package/dist/composables/cron-adjustments.d.ts

@@ -0,0 +1,63 @@
+export interface Adjustment {
+    dateTrigger: string;
+    isAdjusting?: boolean;
+    leadTimeLeft: number;
+    leadTimeRight: number;
+    replacingDate?: string;
+    isInSchedule?: boolean;
+    leadLeftDate?: string;
+    leadRightDate?: string;
+}
+export interface UseCronAdjustmentsOptions {
+    adjustmentString?: string;
+    cronExpression?: string;
+    futureLimit?: number;
+    useLeadTimeInHours?: boolean;
+}
+export declare function useCronAdjustments(options: UseCronAdjustmentsOptions): {
+    adjustments: import('vue').Ref<{
+        dateTrigger: string;
+        isAdjusting?: boolean | undefined;
+        leadTimeLeft: number;
+        leadTimeRight: number;
+        replacingDate?: string | undefined;
+        isInSchedule?: boolean | undefined;
+        leadLeftDate?: string | undefined;
+        leadRightDate?: string | undefined;
+    }[], Adjustment[] | {
+        dateTrigger: string;
+        isAdjusting?: boolean | undefined;
+        leadTimeLeft: number;
+        leadTimeRight: number;
+        replacingDate?: string | undefined;
+        isInSchedule?: boolean | undefined;
+        leadLeftDate?: string | undefined;
+        leadRightDate?: string | undefined;
+    }[]>;
+    adjustmentsString: import('vue').Ref<string | undefined, string | undefined>;
+    applyAdjustment: (data: Adjustment) => void;
+    cancelAdjustment: (adj: Adjustment) => Adjustment;
+    filteredAdjustments: import('vue').ComputedRef<{
+        dateTrigger: string;
+        isAdjusting?: boolean | undefined;
+        leadTimeLeft: number;
+        leadTimeRight: number;
+        replacingDate?: string | undefined;
+        isInSchedule?: boolean | undefined;
+        leadLeftDate?: string | undefined;
+        leadRightDate?: string | undefined;
+    }[]>;
+    stringifyAdjustments: (adjustments: Adjustment[]) => string | undefined;
+    stringify: () => string | undefined;
+    undoAdjustment: (adj: Adjustment) => void;
+    unpack: (adjString?: string, cronExp?: string) => {
+        dateTrigger: string;
+        isAdjusting?: boolean | undefined;
+        leadTimeLeft: number;
+        leadTimeRight: number;
+        replacingDate?: string | undefined;
+        isInSchedule?: boolean | undefined;
+        leadLeftDate?: string | undefined;
+        leadRightDate?: string | undefined;
+    }[];
+};

package/dist/composables/cron-adjustments.mjs

@@ -0,0 +1,106 @@
+import { ref as o, computed as I } from "vue";
+import { isLengthyArray as c, isSameDownToHour as $, isNullOrEmpty as k } from "./helpers.mjs";
+import { useDates as z, BTDateFormat as B } from "./dates.mjs";
+import { useAuth as C } from "./auth.mjs";
+import "../bt-core/core/node_modules/@datasert/cronjs-matcher/dist/index.mjs";
+import { t as E } from "../bt-core/core/node_modules/thenby/thenBy.module.mjs";
+import { __exports as M } from "../_virtual/index.mjs";
+function O(a) {
+  const { tzDate: p, utcDate: f } = z(), { timeZone: h } = C(), u = o([]), s = o(), D = o();
+  function v(e) {
+    const t = u.value.find((i) => i.dateTrigger == e.dateTrigger);
+    if (t != null && e.replacingDate != null && e.leadLeftDate != null) {
+      const i = f(e.leadLeftDate).diff(f(e.replacingDate), "minutes");
+      if (i.minutes >= 0) {
+        t.replacingDate = e.replacingDate, t.isAdjusting = !0, t.leadTimeLeft = i.minutes, t.leadLeftDate = e.leadLeftDate;
+        const n = f(e.leadRightDate).diff(f(e.replacingDate), "minutes");
+        n.minutes >= 0 && (t.leadTimeRight = n.minutes, t.leadRightDate = e.leadRightDate);
+      }
+    }
+    t != null && e.leadLeftDate == null && (t.leadTimeLeft = 0, t.leadLeftDate = void 0, t.leadTimeRight = 0, t.leadRightDate = void 0), t != null && e.leadRightDate == null && (t.leadTimeRight = 0, t.leadRightDate = void 0);
+  }
+  function T(e) {
+    return e != null && (e.replacingDate = void 0, e.isAdjusting = !0), e;
+  }
+  function L(e) {
+    if (e == null)
+      return e;
+    const t = e.split(/\s+/).slice(0, 5);
+    return t[2] == "*" && (t[2] = "?"), t.join(" ");
+  }
+  function A(e) {
+    return `${e.dateTrigger}|${e.replacingDate ?? ""}|${e.leadTimeLeft.toString()}-${e.leadTimeRight.toString()}`;
+  }
+  function d(e) {
+    if (c(e))
+      return e.filter((t) => t.isAdjusting == !0).map((t) => A(t)).filter((t) => t != null && !t.includes("undefined")).toString();
+  }
+  function R(e) {
+    e.replacingDate = void 0, e.isAdjusting = !1;
+  }
+  function y(e) {
+    if (!k(e)) {
+      if (e != null && e.includes("undefined"))
+        return;
+      const t = e == null ? void 0 : e.split("|");
+      if (c(t, 2)) {
+        let i = 0, n = 0, l = t[2].split("-");
+        l.length > 0 && (i = Number.parseInt(l[0])), l.length > 1 && (n = Number.parseInt(l[1]));
+        let r = t[1].length > 1 ? t[1] : void 0;
+        return {
+          dateTrigger: t[0],
+          isAdjusting: !0,
+          leadTimeLeft: i,
+          leadTimeRight: n,
+          replacingDate: r,
+          //other props
+          isInSchedule: !1,
+          leadLeftDate: r != null ? p(r).plus({ minutes: i }).toFormat(B) : void 0
+          // replacingTime: replacingDate != null ? tzString(replacingDate, 'HH:mm') : '00:00',
+          // leadDateLeft: replacingDate != null ? utcDate(replacingDate).plus({ minutes: leftLead }) : undefined,
+          // leadDateRight: replacingDate != null ? utcDate(replacingDate).plus({ minutes: rightLead }) : undefined
+        };
+      }
+    }
+  }
+  function j(e) {
+    const t = [];
+    return e != null && e.split(",").forEach((n) => {
+      const l = y(n);
+      l != null && t.push(l);
+    }), t;
+  }
+  function g(e, t) {
+    let i = [];
+    s.value = e ?? "", i = j(s.value), D.value = t;
+    const n = L(t);
+    return n != null && M.getFutureMatches(n, { matchCount: a.futureLimit ?? 2, formatInTimezone: !1, timezone: h.value }).forEach((r) => {
+      let m = i.find((F) => $(F.dateTrigger, r));
+      m == null ? i.push({
+        dateTrigger: r,
+        //futureDate,
+        isAdjusting: !1,
+        leadTimeLeft: 0,
+        leadTimeRight: 0,
+        replacingDate: void 0,
+        //other props
+        isInSchedule: !0,
+        leadLeftDate: void 0
+      }) : m.isInSchedule = !0;
+    }), i.sort(E.firstBy((l) => l.dateTrigger)), u.value = i, u.value;
+  }
+  return g(a.adjustmentString, a.cronExpression), {
+    adjustments: u,
+    adjustmentsString: s,
+    applyAdjustment: v,
+    cancelAdjustment: T,
+    filteredAdjustments: I(() => u.value.filter((e) => e.isAdjusting)),
+    stringifyAdjustments: d,
+    stringify: () => (s.value = d(u.value), s.value),
+    undoAdjustment: R,
+    unpack: g
+  };
+}
+export {
+  O as useCronAdjustments
+};

package/dist/composables/cron.d.ts

@@ -0,0 +1,72 @@
+export declare const hourOptions: {
+    text: string;
+    value: string;
+}[];
+export declare const monthOptions: {
+    text: string;
+    value: string;
+}[];
+export declare const weekOptions: {
+    text: string;
+    value: string;
+}[];
+export declare const weekdayOptions: {
+    text: string;
+    value: string;
+}[];
+export type CronRegularity = 'Daily' | 'Weekly' | 'Monthly' | 'Custom';
+export declare const regularityOptions: {
+    text: string;
+    value: string;
+}[];
+export interface UseCronOptions {
+    defaultExpression?: string;
+    /**defaults to minutes */
+    useLeadTimeInHours?: boolean;
+    useLeadTimeLeft?: boolean;
+    useLeadTimeRight?: boolean;
+    value?: string;
+}
+export interface PredictOptions {
+    adjustments?: string;
+    futureCount: number;
+    cron?: string;
+}
+export interface StringCron {
+    regularity?: CronRegularity;
+    orderDays: string[];
+    deliveryDays: string[];
+}
+export declare function useCronPredictor(): {
+    predictFuture: (options: PredictOptions) => string[];
+};
+export declare function useCron(options: UseCronOptions): {
+    applyRawExpression: () => void;
+    applyRegularity: (v: any) => void;
+    cronExpression: import('vue').Ref<string | undefined, string | undefined>;
+    getRegularityAndOrderAndDeliveryDays: () => StringCron;
+    hour: import('vue').Ref<string | undefined, string | undefined>;
+    leadTimeLeft: import('vue').Ref<number, number>;
+    leadTimeRight: import('vue').Ref<number, number>;
+    months: import('vue').Ref<string[] | undefined, string[] | undefined>;
+    pack: () => string | undefined;
+    rawExpression: import('vue').WritableComputedRef<string | undefined, string | undefined>;
+    regularity: import('vue').WritableComputedRef<CronRegularity, CronRegularity>;
+    unpack: (exp?: string) => {
+        applyRawExpression: () => void;
+        applyRegularity: (v: any) => void;
+        cronExpression: import('vue').Ref<string | undefined, string | undefined>;
+        hour: import('vue').Ref<string | undefined, string | undefined>;
+        leadTimeLeft: import('vue').Ref<number, number>;
+        leadTimeRight: import('vue').Ref<number, number>;
+        months: import('vue').Ref<string[] | undefined, string[] | undefined>;
+        pack: () => string | undefined;
+        rawExpression: import('vue').WritableComputedRef<string | undefined, string | undefined>;
+        regularity: import('vue').WritableComputedRef<CronRegularity, CronRegularity>;
+        unpack: any;
+        weekdays: import('vue').Ref<string[] | undefined, string[] | undefined>;
+        weeks: import('vue').Ref<string[] | undefined, string[] | undefined>;
+    };
+    weekdays: import('vue').Ref<string[] | undefined, string[] | undefined>;
+    weeks: import('vue').Ref<string[] | undefined, string[] | undefined>;
+};