bt-core-app 2.1.37 → 2.2.0

package/dist/composables/geo.d.ts

@@ -0,0 +1,24 @@
+export interface GeoCoordinate {
+    lat?: number;
+    lng?: number;
+}
+export declare function useGeo(): {
+    areaContains: (polygon: GeoCoordinate[], point?: GeoCoordinate) => boolean;
+    getAreaAround: (location: GeoCoordinate, radius: number) => {
+        lat: number;
+        lng: number;
+    }[] | undefined;
+    getAreaToLeft: (location: GeoCoordinate, radius: number) => {
+        lat: number;
+        lng: number;
+    }[] | undefined;
+    getAreaToRight: (location: GeoCoordinate, radius: number) => {
+        lat: number;
+        lng: number;
+    }[] | undefined;
+    getBoundary: (mvcArray: any) => GeoCoordinate[];
+};
+export declare function useMyGeoLocation(): {
+    canGetGeoLocation: import('vue').ComputedRef<boolean>;
+    getGeoLocation: () => Promise<GeoCoordinate | undefined>;
+};

package/dist/composables/geo.mjs

@@ -0,0 +1,95 @@
+import { computed as L } from "vue";
+function N() {
+  function f(l, t) {
+    if (!(l.lat == null || l.lng == null))
+      return [
+        { lat: l.lat - t, lng: l.lng + t },
+        { lat: l.lat - t, lng: l.lng - t },
+        { lat: l.lat + t, lng: l.lng - t },
+        { lat: l.lat + t, lng: l.lng + t }
+      ];
+  }
+  function h(l, t) {
+    if (!(l.lat == null || l.lng == null))
+      return [
+        { lat: l.lat - t * 2, lng: l.lng + t },
+        { lat: l.lat - t * 2, lng: l.lng - t },
+        { lat: l.lat, lng: l.lng - t },
+        { lat: l.lat, lng: l.lng + t }
+      ];
+  }
+  function a(l, t) {
+    if (!(l.lat == null || l.lng == null))
+      return [
+        { lat: l.lat, lng: l.lng + t },
+        { lat: l.lat, lng: l.lng - t },
+        { lat: l.lat + t * 2, lng: l.lng - t },
+        { lat: l.lat + t * 2, lng: l.lng + t }
+      ];
+  }
+  function g(l) {
+    let t = [];
+    var n = l.getLength();
+    for (let r = 0; r < n; r++) {
+      let e = [], u = l.getAt(r), A = u.getLength();
+      for (let v = 0; v < A; v++) {
+        let m = u.getAt(v);
+        e.push({ lat: m.lat(), lng: m.lng() });
+      }
+      t.push(e);
+    }
+    return t[0];
+  }
+  function y(l, t) {
+    if (l == null || (t == null ? void 0 : t.lat) == null || (t == null ? void 0 : t.lng) == null)
+      return !1;
+    var n = l.map((e) => ({ x: e.lat, y: e.lng }));
+    let r = !1;
+    for (let e = 0, u = n.length - 1; e < n.length; e++)
+      n[e].y > t.lng != n[u].y > t.lng && t.lat < (n[u].x - n[e].x) * (t.lng - n[e].y) / (n[u].y - n[e].y) + n[e].x && (r = !r), u = e;
+    return r;
+  }
+  return {
+    areaContains: y,
+    getAreaAround: f,
+    getAreaToLeft: h,
+    getAreaToRight: a,
+    getBoundary: g
+  };
+}
+function x() {
+  const f = L(() => navigator && "geolocation" in navigator);
+  async function h() {
+    if (f.value)
+      return new Promise((a) => {
+        navigator.geolocation.getCurrentPosition(
+          (g) => {
+            if (Number.isNaN(g.coords.latitude) || Number.isNaN(g.coords.longitude)) {
+              a(void 0);
+              return;
+            }
+            a({
+              lat: g.coords.latitude,
+              lng: g.coords.longitude
+            });
+          },
+          (g) => {
+            console.log(g), a(void 0);
+          },
+          {
+            enableHighAccuracy: !0,
+            timeout: 5e3,
+            maximumAge: 0
+          }
+        );
+      });
+  }
+  return {
+    canGetGeoLocation: L(() => navigator && "geolocation" in navigator),
+    getGeoLocation: h
+  };
+}
+export {
+  N as useGeo,
+  x as useMyGeoLocation
+};

package/dist/composables/graph-pro.d.ts

@@ -0,0 +1,98 @@
+import { BTDates } from './dates.ts';
+import { BTColorizer } from './colorizer.ts';
+
+export interface CreateGraphsOptions {
+    dates: BTDates;
+}
+export interface GetDataSetOptions<T> {
+    backgroundColor?: string;
+    borderColor?: string;
+    data: T[];
+    getBackgroundColor?: (item: T, ind: number, colorizer: BTColorizer) => string;
+    getLabelValue: (item: T) => string;
+    getValue: (item: T) => number | undefined;
+    groupValues?: boolean;
+    lineLabel?: string;
+    noBackgroundColor?: boolean;
+    noBorderColor?: boolean;
+}
+export interface GetGraphDataOptions<T> {
+    chartType?: ChartType;
+    datasets: GetDataSetOptions<T>[];
+    fillGaps?: boolean;
+    labelFormat?: 'day' | 'week' | 'month' | 'year';
+    labelFormatFilter?: string;
+    labelFormatString?: string;
+}
+export interface GetRawXYOptions<T> {
+    list: T[];
+    getXAxis?: (item: T) => string | number;
+    getXLabel?: (item: string | number) => string;
+    xProp?: string;
+    getYValue?: (item: T) => number;
+    getYGroupValue?: (items: T[]) => number;
+    yProp?: string;
+}
+export interface GetXYOptions<T> extends GetRawXYOptions<T> {
+    fillGaps?: boolean;
+    label?: string;
+    list: T[];
+    /**can be a filter or a time format */
+    xLabelFilter?: string;
+    xSpan: 'hour' | 'day' | 'week' | 'month' | 'year';
+    xSpanProp: string | ((item: T) => string);
+}
+export interface GetBarChartOptions<T> {
+    getBottomLabel: (item: T) => string;
+    getXYSets: GetXYSet<T>[];
+    list: T[];
+}
+export interface GetXYSet<T> {
+    getLabel: () => string;
+    getValue: (item: T) => number;
+}
+export interface GraphedData {
+    xValue: string | number;
+    xLabel?: string | number;
+    yValue: number;
+}
+export interface ChartJSDataPoint {
+    x: string | number;
+    y: string | number;
+}
+export interface ChartJSParsing {
+    yAxisKey?: string;
+    xAxisKey?: string;
+}
+export interface ChartJSDataSet {
+    backgroundColor?: string | string[];
+    borderColor?: string | string[];
+    data: number[] | any[][] | ChartJSDataPoint[] | any[];
+    label?: string;
+    parsing?: ChartJSParsing;
+}
+export interface ChartJSData {
+    datasets: ChartJSDataSet[];
+    labels?: string[];
+}
+export interface ChartJSOptions {
+    responsive?: boolean;
+    parsing?: ChartJSParsing;
+}
+export type ChartType = 'line' | 'bar' | 'pie';
+export interface GetChartResult {
+    chartType: ChartType;
+    data: ChartJSData;
+    options?: ChartJSOptions;
+}
+export interface BTGraphs {
+    getDataForChartJS: <T>(options: GetXYOptions<T>[], chartType?: ChartType, chartOptions?: any) => GetChartResult;
+    getBarChartData: <T>(options: GetBarChartOptions<T>, chartOptions?: any) => GetChartResult;
+    getGraphData: <T>(options: GetGraphDataOptions<T>, chartOptions?: any) => GetChartResult;
+    getPieData: (labels: string[], values: number[], chartOptions?: any) => GetChartResult;
+    getPieChartData: <T>(options: GetBarChartOptions<T>, chartOptions?: any) => GetChartResult;
+    getXY: <T>(options: GetXYOptions<T>) => GraphedData[];
+    getRawXY: <T>(options: GetRawXYOptions<T>) => GraphedData[];
+}
+export declare function useGraphs(): BTGraphs;
+export declare function createGraphs(opt: CreateGraphsOptions): BTGraphs;

package/dist/composables/graph-pro.mjs

@@ -0,0 +1,205 @@
+import { BTDateFormat as x } from "../node_modules/bt-core-app/dist/bt-core-app.mjs";
+import { useColorizer as v } from "./colorizer.mjs";
+import { useDates as O } from "./dates.mjs";
+import { useFilters as K } from "./filters.mjs";
+import { nestedValue as $, group as I } from "./helpers.mjs";
+import { t as J } from "../bt-core/core/node_modules/thenby/thenBy.module.mjs";
+let D;
+function Q() {
+  return D;
+}
+function U(z) {
+  const S = K();
+  function G(e, a, u) {
+    const r = v();
+    return {
+      chartType: a ?? "line",
+      data: {
+        datasets: e.map((l) => {
+          var o = k(l);
+          let n = r.getColor();
+          return {
+            backgroundColor: n,
+            borderColor: n,
+            data: o,
+            label: l.label
+          };
+        })
+      },
+      options: {
+        responsive: !0,
+        parsing: {
+          xAxisKey: "xValue",
+          yAxisKey: "yValue"
+        },
+        ...u
+      }
+    };
+  }
+  function T(e, a) {
+    const u = v();
+    return {
+      chartType: "bar",
+      data: {
+        datasets: e.getXYSets.map((r) => {
+          let l = u.getColor();
+          return {
+            backgroundColor: l,
+            borderColor: l,
+            data: e.list.map((o) => r.getValue(o)),
+            label: r.getLabel()
+          };
+        }),
+        labels: e.list.map((r) => e.getBottomLabel(r))
+      },
+      options: {
+        responsive: !0,
+        ...a
+      }
+    };
+  }
+  function Y(e, a, u) {
+    const r = v();
+    var l = {
+      chartType: "pie",
+      data: {
+        labels: e,
+        datasets: [
+          {
+            backgroundColor: a.map(() => r.getColor()),
+            data: a
+          }
+        ]
+      },
+      options: {
+        responsive: !0,
+        ...u
+      }
+    };
+    return l;
+  }
+  function p(e, a) {
+    const u = v();
+    return {
+      chartType: "pie",
+      data: {
+        datasets: e.getXYSets.map((r) => {
+          var l = e.list.map(() => u.getColor());
+          return {
+            backgroundColor: l,
+            borderColor: l,
+            data: e.list.map((o) => r.getValue(o)),
+            label: r.getLabel()
+          };
+        }),
+        labels: e.list.map((r) => e.getBottomLabel(r))
+      },
+      options: {
+        responsive: !0,
+        ...a
+      }
+    };
+  }
+  function A(e, a) {
+    var u = {
+      chartType: e.chartType ?? "line",
+      data: {
+        datasets: []
+      },
+      options: {
+        responsive: !0,
+        ...a
+      }
+    }, r = O(), l = e.labelFormatFilter != null ? S.findFilter(e.labelFormatFilter) : void 0, o = v();
+    if (e.fillGaps && e.labelFormat != null) {
+      var n, h, g = {}, c = e.labelFormat, L = [];
+      c == "day" ? g = { days: 1 } : c == "week" ? g = { weeks: 1 } : c == "month" ? g = { months: 1 } : c == "year" && (g = { years: 1 }), e.datasets.forEach((t) => {
+        t.data.forEach((C) => {
+          var s = t.getLabelValue(C);
+          n ?? (n = s), h ?? (h = s), s < n && (n = s), s > h && (h = s);
+        });
+      });
+      var b = r.tzDate(n).startOf(c), i = b.toFormat(x), E = r.tzDate(h).endOf(c), X = E.toFormat(x);
+      if (i < X)
+        for (; i < X; )
+          l != null ? L.push(l(i)) : e.labelFormatString != null ? L.push(b.toFormat(e.labelFormatString)) : L.push(i), b = b.plus(g), i = b.toFormat(x);
+    }
+    return u.data.datasets = e.datasets.map((t) => {
+      let C = t.noBackgroundColor == !0 && t.noBorderColor == !0 ? void 0 : o.getColor();
+      var s = {
+        backgroundColor: t.noBackgroundColor == !0 ? void 0 : t.backgroundColor ?? C,
+        borderColor: t.noBorderColor == !0 ? void 0 : t.borderColor ?? C,
+        data: t.data.reduce((f, F) => {
+          var d = t.getLabelValue(F), y = r.tzDate(d), m = d;
+          e.labelFormat != null && (y = y.startOf(e.labelFormat)), l != null ? m = l(y.toFormat(x)) : e.labelFormatString != null && (m = y.toFormat(e.labelFormatString));
+          var V = t.getValue(F);
+          if (V != null)
+            if (t.groupValues == !0) {
+              var B = f.find((w) => w.x == m);
+              B != null ? (console.log(`merging: ${B.x}`), B.y += V) : (console.log(`adding: ${d}`), f.push({
+                x: m,
+                y: V,
+                z: d
+              }));
+            } else
+              f.push({
+                x: m,
+                y: V,
+                z: d
+              });
+          return f;
+        }, []).sort(J.firstBy((f) => f.z)),
+        label: t.lineLabel
+      };
+      return t.getBackgroundColor != null && (s.backgroundColor = t.data.map((f, F) => t.getBackgroundColor(f, F, o))), s;
+    }), u;
+  }
+  function k(e) {
+    let a = [];
+    const u = S.findFilter(e.xLabelFilter);
+    return e.getXAxis ?? (e.getXAxis = (r) => {
+      const l = typeof e.xSpanProp == "string" ? $(r, e.xSpanProp) : e.xSpanProp(r), o = u(l);
+      return o ?? z.dates.tzDate(l).startOf(e.xSpan).toFormat(e.xLabelFilter ?? "");
+    }), a = P(e), e.fillGaps && (a = a), a;
+  }
+  function P(e) {
+    if (e.getXAxis == null && e.xProp == null)
+      return [];
+    if (e.getYGroupValue == null && e.getYValue == null && e.yProp == null)
+      return [];
+    const a = I(e.list, e.getXAxis ?? e.xProp), u = [];
+    return a.forEach((r, l) => {
+      if (e.getYGroupValue != null)
+        u.push({
+          xValue: l,
+          xLabel: e.getXLabel != null ? e.getXLabel(l) : void 0,
+          yValue: e.getYGroupValue(r)
+        });
+      else {
+        const o = {
+          xValue: l,
+          xLabel: e.getXLabel != null ? e.getXLabel(l) : void 0,
+          yValue: 0
+        };
+        u.push(o), e.getYValue != null ? r.forEach((n) => {
+          o.yValue += e.getYValue(n);
+        }) : e.yProp != null && r.forEach((n) => {
+          o.yValue += n[e.yProp];
+        });
+      }
+    }), u;
+  }
+  return D ?? (D = {
+    getBarChartData: T,
+    getDataForChartJS: G,
+    getGraphData: A,
+    getPieChartData: p,
+    getPieData: Y,
+    getXY: k,
+    getRawXY: P
+  }), D;
+}
+export {
+  U as createGraphs,
+  Q as useGraphs
+};

package/dist/composables/graphing.d.ts

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

package/dist/composables/heights.d.ts

@@ -0,0 +1,24 @@
+import { MaybeRefOrGetter } from 'vue';
+import { BTNavigation } from './navigation.ts';
+import { DisplayInstance } from 'vuetify';
+
+export interface HeightOptions {
+    getStyle: (actualUsedHeight?: number) => string;
+    getUsedHeight: (inAdditionTo?: number) => number;
+}
+export interface CreateHeightOptions {
+    display?: DisplayInstance;
+    navigation?: BTNavigation;
+    getUsedHeight?: (display?: DisplayInstance, navigation?: BTNavigation) => number;
+}
+export declare function useHeights(options?: CreateHeightOptions): HeightOptions;
+export interface ResponsiveStyleOptions {
+    getUsedHeight: (display?: DisplayInstance, navigation?: BTNavigation) => number;
+    overflow?: boolean;
+}
+export declare function useResponsiveStyle(options: ResponsiveStyleOptions): {
+    style: import('vue').ComputedRef<string>;
+};
+export declare function useStyle(actualUsedHeight?: MaybeRefOrGetter<number>, ignoreCore?: boolean): {
+    style: import('vue').ComputedRef<string>;
+};

package/dist/composables/heights.mjs

@@ -0,0 +1,41 @@
+import { computed as f, toValue as r } from "vue";
+let u, l;
+function c(e) {
+  if (u != null)
+    return u;
+  const g = (e == null ? void 0 : e.getUsedHeight) ?? (() => 0);
+  function h(v) {
+    return g(e == null ? void 0 : e.display, e == null ? void 0 : e.navigation) + (v ?? 0);
+  }
+  function a(v) {
+    return `height: calc(100vh - ${h(v)}px);`;
+  }
+  return l = e, u = {
+    getStyle: a,
+    getUsedHeight: h
+  }, u;
+}
+function d(e) {
+  return {
+    style: f(() => {
+      var g = !!e.overflow;
+      return u == null ? "" : g ? `height: calc(100vh - ${e.getUsedHeight(l == null ? void 0 : l.display, l == null ? void 0 : l.navigation)}px); overflow-y: auto;` : `height: calc(100vh - ${e.getUsedHeight(l == null ? void 0 : l.display, l == null ? void 0 : l.navigation)}px);`;
+    })
+  };
+}
+function y(e, g) {
+  return {
+    style: f(() => {
+      if (u == null)
+        return "";
+      var h = r(e);
+      return `height: calc(100vh - ${g == !0 ? h : u.getUsedHeight(h)}px); overflow-y: auto;`;
+    })
+    // usedHeight: aHeight
+  };
+}
+export {
+  c as useHeights,
+  d as useResponsiveStyle,
+  y as useStyle
+};

package/dist/composables/helpers.d.ts

@@ -0,0 +1,114 @@
+import { StoreGetReturn, StoreGetAllReturn } from './stores.ts';
+
+export declare const externalUses: string[];
+export declare function getColors(): string[];
+export declare function getOtherColors(): string[];
+export declare function personName(firstName?: string, lastName?: string, userName?: string): string | undefined;
+/**Pulls only props that obj2 contains and applies to obj1 */
+export declare function pullPropsFrom(obj1: any, obj2: any, propsToIgnore?: string[], strat?: 'only-obj1-props' | 'all-obj2-props'): any;
+export declare function toggle(obj: any, prop: string, values: any[]): void;
+export declare function log(obj: any): void;
+export declare function moveInArray(arr: any[], fromInd: number, toInd: number): void;
+/**decrypts jwt token */
+export declare function jwtDecrypt(token: string): any;
+export declare function jwtEncrypt(payload?: any): string;
+export declare function expectSingleReturn<T>(res: StoreGetReturn<T | T[]> | undefined): StoreGetReturn<T> | undefined;
+export declare function expectArrayReturn<T>(res: StoreGetReturn<T | T[]> | undefined): StoreGetReturn<T[]> | undefined;
+export declare function expectSingle<T>(res: StoreGetReturn<T | T[]> | StoreGetAllReturn<T> | undefined): T | undefined;
+export declare function expectArray<T>(res: StoreGetReturn<T | T[]> | StoreGetAllReturn<T> | undefined): T[] | undefined;
+export declare function sum(array: number[]): number;
+export declare function orderBy<T>(arr: T[], prop?: keyof T | ((item: T) => boolean | number | string), asc?: true | false): T[];
+export declare function appendUrl(originalVal?: string, additionalVal?: string, splittingChar?: string): string;
+export declare function checkImage(url: string, onGood: (this: GlobalEventHandlers, ev: Event) => void, onBad: OnErrorEventHandler): void;
+export declare function distinct<T>(list: T[], compareFunc?: string | ((item: T) => any)): T[];
+export declare function groupBy<T>(array: T[], keyGetter: (item: T) => string | undefined, defaultKey: string): Map<string, T[]>;
+export interface GroupedArray<T> {
+    key: string;
+    values: T[];
+}
+export declare function groupArrays<T>(array: T[], keyGetter: (item: T) => string | undefined, defaultKey: string): T[][];
+export declare function group<T>(list: T[], keyGetter: string | ((item: T) => string | number)): Map<any, any>;
+export declare function extensionExists(elementId?: string): boolean;
+/**
+ *
+ * @param value converts location to a single string and standardizes state and road names, etc.
+ * @returns
+ */
+export declare function getGoogleMapsLocationLine(value: any): string;
+export declare function getLocationLine(value: any, forGoogle?: boolean): string;
+export declare function getLocationLineOne(value: any): string;
+export declare function getLocationLineTwo(value: any): string;
+export declare function dropFromList<T>(arr?: T[], pred?: (item: T) => boolean): number;
+/**remove all items with a certain predicate and add item to the first predicate or at the end of the list */
+export declare function dropAndAddToList<T>(arr?: T[], itemToAdd?: T, pred?: (item: T) => boolean): number;
+export declare function getImageData(url?: string, throwErrorOnFail?: boolean): Promise<unknown>;
+/**
+ *
+ * @param val Converts string from camel case to every word being capitalized and spaces between
+ * @returns
+ */
+export declare function fromCamelCase(val?: string): string | undefined;
+/**
+ * Converts props to camel casing
+ * @param value
+ * @returns
+ */
+export declare function toCamelCase(value: any): any;
+export declare function capitalizeWords(val?: string): string | undefined;
+export declare const weekdayPairs: {
+    value: number;
+    short: string;
+    values: (string | null | undefined)[];
+}[];
+/**returns the sort value of the weekday csv string
+ * returns minimum if csv list
+ */
+export declare function weekdayValue(wkDay?: string): number;
+/**returns the sort value of the weekday csv string
+ * returns minimum if csv list
+ */
+export declare function weekdayShortName(wkDay?: string): string | undefined;
+/**whether the csv string contains the weekday
+ * returns true if either prop is undefined
+ */
+export declare function containsWeekday(weekdays?: string, wkDay?: string): boolean;
+/**adds and sorts the weekday string */
+export declare function addWeekday(weekdays?: string, day?: string): string | undefined;
+export declare function removeWeekday(weekdays?: string, day?: string): string | undefined;
+export declare function isArrayOfLength(val: any, l: number): boolean;
+export declare function isLengthyArray(val: any, greaterThan?: number): boolean;
+export declare function isNullOrEmpty(val: string | undefined): boolean;
+export declare function isMinDate(d?: string): boolean;
+export declare function getMinDate(): number;
+export declare function getMinDateString(): string;
+export declare function isSameDownToHour(firstDate?: string, secondDate?: string): boolean;
+/**
+ * rounds the given value to a certain number of decimal places
+ * @param v
+ * @param dPlaces
+ * @returns
+ */
+export declare function roundTo(val: number, dPlaces: number): number;
+export declare function toggleCSV(value?: string | string[], tag?: string): string | undefined;
+export declare function csvContains(value?: string, tag?: string): boolean;
+/**copies object and all descendant properties */
+export declare function copyDeep<T>(aObject: T): T;
+/**copies object and returns copied object with descendant properties placed in alphabetical order */
+export declare function copyItemByAlphabet(aObject: any): any;
+/**whether string is contained somewhere in this value */
+export declare function containsSearch(value?: string | number, str?: string): boolean;
+/**must be an object.  Returns a flat map of all items in the prop selector */
+export declare function deepSelect(obj: any, propSelector?: Function): any[];
+export declare function DataURIToBlob(dataURI: any): Blob;
+export declare function extractErrorDescription(error: any): string;
+export declare function getRandomColor(): string;
+/**tests for whether string is contains in any of the given props of the given value */
+export declare function hasSearch(value: any, str?: string, props?: string[]): boolean;
+export declare function toCompareString(str?: string): string | null;
+export declare function twiddleThumbs(mSec?: number): Promise<void>;
+export declare function nestedValue(obj: any, path?: string): any;
+export declare function spread<T>(arr: T[], chunkSize: number): (T)[][];
+export declare function splitArray<T>(arr: T[], chunkSize: number, fill?: boolean): (T | null)[][];
+export declare function validEmail(email?: string): boolean;
+export declare function singularize(str: string): string;
+export declare function compareString(str?: string): string | undefined;