bt-core-app 2.2.10 → 2.2.12

package/dist/bt-core/core/node_modules/vuetify/lib/components/VColorPicker/VColorPicker.mjs

@@ -0,0 +1,161 @@
+import { ref as C, computed as P, watch as V, onBeforeMount as S, createVNode as a, mergeProps as b, createElementVNode as s, Fragment as w } from "vue";
+import "../../../../../../../_virtual/VColorPicker.sass.mjs";
+import { VColorPickerCanvas as g } from "./VColorPickerCanvas.mjs";
+import { VColorPickerEdit as p } from "./VColorPickerEdit.mjs";
+import { makeVColorPickerPreviewProps as B, VColorPickerPreview as H } from "./VColorPickerPreview.mjs";
+import { VColorPickerSwatches as x } from "./VColorPickerSwatches.mjs";
+import { makeVPickerProps as D, VPicker as h } from "../../labs/VPicker/VPicker.mjs";
+import { provideDefaults as I } from "../../composables/defaults.mjs";
+import { useProxiedModel as y } from "../../composables/proxiedModel.mjs";
+import { modes as m, nullColor as A, extractColor as E } from "./util/index.mjs";
+import { useRtl as N } from "../../composables/locale.mjs";
+import { propsFactory as U } from "../../util/propsFactory.mjs";
+import { pick as j } from "../../util/helpers.mjs";
+import { defineComponent as M } from "../../util/defineComponent.mjs";
+import { useRender as O } from "../../util/useRender.mjs";
+import { HSVtoCSS as z, RGBtoHSV as F, parseColor as R } from "../../util/colorUtils.mjs";
+import { consoleWarn as W } from "../../util/console.mjs";
+const _ = U({
+  canvasHeight: {
+    type: [String, Number],
+    default: 150
+  },
+  disabled: Boolean,
+  dotSize: {
+    type: [Number, String],
+    default: 10
+  },
+  hideCanvas: Boolean,
+  hideSliders: Boolean,
+  hideInputs: Boolean,
+  mode: {
+    type: String,
+    default: "rgba",
+    validator: (e) => Object.keys(m).includes(e)
+  },
+  modes: {
+    type: Array,
+    default: () => Object.keys(m),
+    validator: (e) => Array.isArray(e) && e.every((n) => Object.keys(m).includes(n))
+  },
+  showSwatches: Boolean,
+  readonly: Boolean,
+  swatches: Array,
+  swatchesMaxHeight: {
+    type: [Number, String],
+    default: 150
+  },
+  modelValue: {
+    type: [Object, String]
+  },
+  ...D({
+    hideHeader: !0
+  }),
+  ...j(B(), ["hideEyeDropper", "eyeDropperIcon"])
+}, "VColorPicker"), de = M({
+  name: "VColorPicker",
+  props: _(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    "update:mode": (e) => !0
+  },
+  setup(e, n) {
+    let {
+      slots: f
+    } = n;
+    const r = y(e, "mode"), u = C(null), l = y(e, "modelValue", void 0, (o) => {
+      if (o == null || o === "")
+        return null;
+      let i;
+      try {
+        i = F(R(o));
+      } catch (k) {
+        return W(k), null;
+      }
+      return i;
+    }, (o) => o ? E(o, e.modelValue) : null), t = P(() => l.value ? {
+      ...l.value,
+      h: u.value ?? l.value.h
+    } : null), {
+      rtlClasses: v
+    } = N();
+    let c = !0;
+    V(l, (o) => {
+      if (!c) {
+        c = !0;
+        return;
+      }
+      o && (u.value = o.h);
+    }, {
+      immediate: !0
+    });
+    const d = (o) => {
+      c = !1, u.value = o.h, l.value = o;
+    };
+    return S(() => {
+      e.modes.includes(r.value) || (r.value = e.modes[0]);
+    }), I({
+      VSlider: {
+        color: void 0,
+        trackColor: void 0,
+        trackFillColor: void 0
+      }
+    }), O(() => {
+      const o = h.filterProps(e);
+      return a(h, b(o, {
+        class: ["v-color-picker", v.value, e.class],
+        style: [{
+          "--v-color-picker-color-hsv": z({
+            ...t.value ?? A,
+            a: 1
+          })
+        }, e.style]
+      }), {
+        ...f,
+        default: () => s(w, null, [!e.hideCanvas && a(g, {
+          key: "canvas",
+          color: t.value,
+          "onUpdate:color": d,
+          disabled: e.disabled,
+          readonly: e.readonly,
+          dotSize: e.dotSize,
+          width: e.width,
+          height: e.canvasHeight
+        }, null), (!e.hideSliders || !e.hideInputs) && s("div", {
+          key: "controls",
+          class: "v-color-picker__controls"
+        }, [!e.hideSliders && a(H, {
+          key: "preview",
+          color: t.value,
+          "onUpdate:color": d,
+          hideAlpha: !r.value.endsWith("a"),
+          disabled: e.disabled,
+          readonly: e.readonly,
+          hideEyeDropper: e.hideEyeDropper,
+          eyeDropperIcon: e.eyeDropperIcon
+        }, null), !e.hideInputs && a(p, {
+          key: "edit",
+          modes: e.modes,
+          mode: r.value,
+          "onUpdate:mode": (i) => r.value = i,
+          color: t.value,
+          "onUpdate:color": d,
+          disabled: e.disabled,
+          readonly: e.readonly
+        }, null)]), e.showSwatches && a(x, {
+          key: "swatches",
+          color: t.value,
+          "onUpdate:color": d,
+          maxHeight: e.swatchesMaxHeight,
+          swatches: e.swatches,
+          disabled: e.disabled,
+          readonly: e.readonly
+        }, null)])
+      });
+    }), {};
+  }
+});
+export {
+  de as VColorPicker,
+  _ as makeVColorPickerProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VColorPicker/VColorPickerCanvas.mjs

@@ -0,0 +1,166 @@
+import { shallowRef as y, ref as P, toRef as N, computed as E, watch as g, onMounted as B, createElementVNode as C, normalizeClass as L, normalizeStyle as R } from "vue";
+import "../../../../../../../_virtual/VColorPickerCanvas.sass.mjs";
+import { makeComponentProps as D } from "../../composables/component.mjs";
+import { useResizeObserver as F } from "../../composables/resizeObserver.mjs";
+import { clamp as h, convertToUnit as m, getEventCoordinates as I } from "../../util/helpers.mjs";
+import { propsFactory as V } from "../../util/propsFactory.mjs";
+import { defineComponent as $ } from "../../util/defineComponent.mjs";
+import { useRender as O } from "../../util/useRender.mjs";
+const T = V({
+  color: {
+    type: Object
+  },
+  disabled: Boolean,
+  readonly: Boolean,
+  dotSize: {
+    type: [Number, String],
+    default: 10
+  },
+  height: {
+    type: [Number, String],
+    default: 150
+  },
+  width: {
+    type: [Number, String],
+    default: 300
+  },
+  ...D()
+}, "VColorPickerCanvas"), J = $({
+  name: "VColorPickerCanvas",
+  props: T(),
+  emits: {
+    "update:color": (t) => !0,
+    "update:position": (t) => !0
+  },
+  setup(t, b) {
+    let {
+      emit: k
+    } = b;
+    const f = y(!1), r = P(), l = y(parseFloat(t.width)), u = y(parseFloat(t.height)), d = P({
+      x: 0,
+      y: 0
+    }), S = N(() => !t.disabled && !t.readonly), c = E({
+      get: () => d.value,
+      set(e) {
+        var a, i;
+        if (!r.value)
+          return;
+        const {
+          x: o,
+          y: n
+        } = e;
+        d.value = e, k("update:color", {
+          h: ((a = t.color) == null ? void 0 : a.h) ?? 0,
+          s: h(o, 0, l.value) / l.value,
+          v: 1 - h(n, 0, u.value) / u.value,
+          a: ((i = t.color) == null ? void 0 : i.a) ?? 1
+        });
+      }
+    }), z = E(() => {
+      const {
+        x: e,
+        y: o
+      } = c.value, n = parseInt(t.dotSize, 10) / 2;
+      return {
+        width: m(t.dotSize),
+        height: m(t.dotSize),
+        transform: `translate(${m(e - n)}, ${m(o - n)})`
+      };
+    }), {
+      resizeRef: p
+    } = F((e) => {
+      var a;
+      if (!((a = p.el) != null && a.offsetParent))
+        return;
+      const {
+        width: o,
+        height: n
+      } = e[0].contentRect;
+      l.value = Math.round(o), u.value = Math.round(n);
+    });
+    function M(e, o, n) {
+      const {
+        left: a,
+        top: i,
+        width: _,
+        height: G
+      } = n;
+      c.value = {
+        x: h(e - a, 0, _),
+        y: h(o - i, 0, G)
+      };
+    }
+    function x(e) {
+      e.type === "mousedown" && e.preventDefault(), S.value && (s(e), window.addEventListener("mousemove", s), window.addEventListener("mouseup", v), window.addEventListener("touchmove", s), window.addEventListener("touchend", v));
+    }
+    function s(e) {
+      if (!S.value || !r.value)
+        return;
+      f.value = !0;
+      const o = I(e);
+      M(o.clientX, o.clientY, r.value.getBoundingClientRect());
+    }
+    function v() {
+      window.removeEventListener("mousemove", s), window.removeEventListener("mouseup", v), window.removeEventListener("touchmove", s), window.removeEventListener("touchend", v);
+    }
+    function w() {
+      var i;
+      if (!r.value)
+        return;
+      const e = r.value, o = e.getContext("2d");
+      if (!o)
+        return;
+      const n = o.createLinearGradient(0, 0, e.width, 0);
+      n.addColorStop(0, "hsla(0, 0%, 100%, 1)"), n.addColorStop(1, `hsla(${((i = t.color) == null ? void 0 : i.h) ?? 0}, 100%, 50%, 1)`), o.fillStyle = n, o.fillRect(0, 0, e.width, e.height);
+      const a = o.createLinearGradient(0, 0, 0, e.height);
+      a.addColorStop(0, "hsla(0, 0%, 0%, 0)"), a.addColorStop(1, "hsla(0, 0%, 0%, 1)"), o.fillStyle = a, o.fillRect(0, 0, e.width, e.height);
+    }
+    return g(() => {
+      var e;
+      return (e = t.color) == null ? void 0 : e.h;
+    }, w, {
+      immediate: !0
+    }), g(() => [l.value, u.value], (e, o) => {
+      w(), d.value = {
+        x: c.value.x * e[0] / o[0],
+        y: c.value.y * e[1] / o[1]
+      };
+    }, {
+      flush: "post"
+    }), g(() => t.color, () => {
+      if (f.value) {
+        f.value = !1;
+        return;
+      }
+      d.value = t.color ? {
+        x: t.color.s * l.value,
+        y: (1 - t.color.v) * u.value
+      } : {
+        x: 0,
+        y: 0
+      };
+    }, {
+      deep: !0,
+      immediate: !0
+    }), B(() => w()), O(() => C("div", {
+      ref: p,
+      class: L(["v-color-picker-canvas", t.class]),
+      style: R(t.style),
+      onMousedown: x,
+      onTouchstartPassive: x
+    }, [C("canvas", {
+      ref: r,
+      width: l.value,
+      height: u.value
+    }, null), t.color && C("div", {
+      class: L(["v-color-picker-canvas__dot", {
+        "v-color-picker-canvas__dot--disabled": t.disabled
+      }]),
+      style: R(z.value)
+    }, null)])), {};
+  }
+});
+export {
+  J as VColorPickerCanvas,
+  T as makeVColorPickerCanvasProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VColorPicker/VColorPickerEdit.mjs

@@ -0,0 +1,97 @@
+import { computed as s, createElementVNode as i, normalizeClass as C, normalizeStyle as g, createVNode as p, normalizeProps as V, guardReactiveProps as E } from "vue";
+import "../../../../../../../_virtual/VColorPickerEdit.sass.mjs";
+import { makeComponentProps as h } from "../../composables/component.mjs";
+import { useLocale as j } from "../../composables/locale.mjs";
+import { modes as m, nullColor as z } from "./util/index.mjs";
+import { VBtn as L } from "../VBtn/VBtn.mjs";
+import { propsFactory as O } from "../../util/propsFactory.mjs";
+import { defineComponent as $ } from "../../util/defineComponent.mjs";
+import { useRender as x } from "../../util/useRender.mjs";
+const A = (e) => {
+  let {
+    label: t,
+    ...a
+  } = e;
+  return i("div", {
+    class: "v-color-picker-edit__input"
+  }, [i("input", V(E(a)), null), i("span", null, [t])]);
+}, B = O({
+  color: Object,
+  disabled: Boolean,
+  readonly: Boolean,
+  mode: {
+    type: String,
+    default: "rgba",
+    validator: (e) => Object.keys(m).includes(e)
+  },
+  modes: {
+    type: Array,
+    default: () => Object.keys(m),
+    validator: (e) => Array.isArray(e) && e.every((t) => Object.keys(m).includes(t))
+  },
+  ...h()
+}, "VColorPickerEdit"), w = $({
+  name: "VColorPickerEdit",
+  props: B(),
+  emits: {
+    "update:color": (e) => !0,
+    "update:mode": (e) => !0
+  },
+  setup(e, t) {
+    let {
+      emit: a
+    } = t;
+    const {
+      t: d
+    } = j(), l = s(() => e.modes.map((o) => ({
+      ...m[o],
+      name: o
+    }))), f = s(() => {
+      var n;
+      const o = l.value.find((c) => c.name === e.mode);
+      if (!o)
+        return [];
+      const r = e.color ? o.to(e.color) : null;
+      return (n = o.inputs) == null ? void 0 : n.map((c) => {
+        let {
+          getValue: v,
+          getColor: y,
+          localeKey: b,
+          ...k
+        } = c;
+        return {
+          ...o.inputProps,
+          ...k,
+          ariaLabel: d(`$vuetify.colorPicker.ariaLabel.${b}`),
+          disabled: e.disabled,
+          readonly: e.readonly,
+          value: r && v(r),
+          onChange: (P) => {
+            const u = P.target;
+            u && a("update:color", o.from(y(r ?? o.to(z), u.value)));
+          }
+        };
+      });
+    });
+    return x(() => {
+      var o;
+      return i("div", {
+        class: C(["v-color-picker-edit", e.class]),
+        style: g(e.style)
+      }, [(o = f.value) == null ? void 0 : o.map((r) => p(A, r, null)), l.value.length > 1 && p(L, {
+        icon: "$unfold",
+        size: "x-small",
+        variant: "plain",
+        "aria-label": d("$vuetify.colorPicker.ariaLabel.changeFormat"),
+        onClick: () => {
+          const r = l.value.findIndex((n) => n.name === e.mode);
+          a("update:mode", l.value[(r + 1) % l.value.length].name);
+        }
+      }, null)]);
+    }), {};
+  }
+});
+export {
+  w as VColorPickerEdit,
+  B as makeVColorPickerEditProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VColorPicker/VColorPickerPreview.mjs

@@ -0,0 +1,123 @@
+import { toRef as y, onUnmounted as k, createElementVNode as l, normalizeClass as b, normalizeStyle as h, createVNode as n } from "vue";
+import "../../../../../../../_virtual/VColorPickerPreview.sass.mjs";
+import { makeComponentProps as f } from "../../composables/component.mjs";
+import { IconValue as w } from "../../composables/icons.mjs";
+import { useLocale as P } from "../../composables/locale.mjs";
+import { nullColor as a } from "./util/index.mjs";
+import { SUPPORTS_EYE_DROPPER as m } from "../../util/globals.mjs";
+import { VBtn as V } from "../VBtn/VBtn.mjs";
+import { HSVtoCSS as _, RGBtoHSV as C, parseColor as S } from "../../util/colorUtils.mjs";
+import { VSlider as p } from "../VSlider/VSlider.mjs";
+import { propsFactory as D } from "../../util/propsFactory.mjs";
+import { defineComponent as E } from "../../util/defineComponent.mjs";
+import { useRender as B } from "../../util/useRender.mjs";
+const R = D({
+  color: {
+    type: Object
+  },
+  disabled: Boolean,
+  readonly: Boolean,
+  hideAlpha: Boolean,
+  hideEyeDropper: Boolean,
+  eyeDropperIcon: {
+    type: w,
+    default: "$eyeDropper"
+  },
+  ...f()
+}, "VColorPickerPreview"), j = E({
+  name: "VColorPickerPreview",
+  props: R(),
+  emits: {
+    "update:color": (e) => !0
+  },
+  setup(e, s) {
+    let {
+      emit: t
+    } = s;
+    const {
+      t: c
+    } = P(), d = new AbortController(), u = y(() => !e.disabled && !e.readonly);
+    k(() => d.abort());
+    async function v() {
+      if (!m || !u.value)
+        return;
+      const i = new window.EyeDropper();
+      try {
+        const o = await i.open({
+          signal: d.signal
+        }), r = C(S(o.sRGBHex));
+        t("update:color", {
+          ...e.color ?? a,
+          ...r
+        });
+      } catch {
+      }
+    }
+    return B(() => {
+      var i, o;
+      return l("div", {
+        class: b(["v-color-picker-preview", {
+          "v-color-picker-preview--hide-alpha": e.hideAlpha
+        }, e.class]),
+        style: h(e.style)
+      }, [m && !e.hideEyeDropper && l("div", {
+        class: "v-color-picker-preview__eye-dropper",
+        key: "eyeDropper"
+      }, [n(V, {
+        "aria-label": c("$vuetify.colorPicker.ariaLabel.eyedropper"),
+        density: "comfortable",
+        disabled: e.disabled,
+        readonly: e.readonly,
+        icon: e.eyeDropperIcon,
+        variant: "plain",
+        onClick: v
+      }, null)]), l("div", {
+        class: "v-color-picker-preview__dot"
+      }, [l("div", {
+        style: {
+          background: _(e.color ?? a)
+        }
+      }, null)]), l("div", {
+        class: "v-color-picker-preview__sliders"
+      }, [n(p, {
+        class: "v-color-picker-preview__track v-color-picker-preview__hue",
+        "aria-label": c("$vuetify.colorPicker.ariaLabel.hueSlider"),
+        modelValue: (i = e.color) == null ? void 0 : i.h,
+        "onUpdate:modelValue": (r) => t("update:color", {
+          ...e.color ?? a,
+          h: r
+        }),
+        step: 1,
+        min: 0,
+        max: 360,
+        disabled: e.disabled,
+        readonly: e.readonly,
+        thumbSize: 14,
+        trackSize: 8,
+        trackFillColor: "white",
+        hideDetails: !0
+      }, null), !e.hideAlpha && n(p, {
+        class: "v-color-picker-preview__track v-color-picker-preview__alpha",
+        "aria-label": c("$vuetify.colorPicker.ariaLabel.alphaSlider"),
+        modelValue: ((o = e.color) == null ? void 0 : o.a) ?? 1,
+        "onUpdate:modelValue": (r) => t("update:color", {
+          ...e.color ?? a,
+          a: r
+        }),
+        step: 0.01,
+        min: 0,
+        max: 1,
+        disabled: e.disabled,
+        readonly: e.readonly,
+        thumbSize: 14,
+        trackSize: 8,
+        trackFillColor: "white",
+        hideDetails: !0
+      }, null)])]);
+    }), {};
+  }
+});
+export {
+  j as VColorPickerPreview,
+  R as makeVColorPickerPreviewProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VColorPicker/VColorPickerSwatches.mjs

@@ -0,0 +1,72 @@
+import { toRef as h, createElementVNode as t, normalizeClass as n, normalizeStyle as u, createVNode as k } from "vue";
+import "../../../../../../../_virtual/VColorPickerSwatches.sass.mjs";
+import { makeComponentProps as p } from "../../composables/component.mjs";
+import f from "../../util/colors.mjs";
+import { VIcon as w } from "../VIcon/VIcon.mjs";
+import { parseColor as b, RGBtoHSV as C, getContrast as g, RGBtoCSS as v } from "../../util/colorUtils.mjs";
+import { propsFactory as y } from "../../util/propsFactory.mjs";
+import { defineComponent as S } from "../../util/defineComponent.mjs";
+import { useRender as V } from "../../util/useRender.mjs";
+import { convertToUnit as F } from "../../util/helpers.mjs";
+import { deepEqual as P } from "../../util/deepEqual.mjs";
+const _ = y({
+  swatches: {
+    type: Array,
+    default: () => x(f)
+  },
+  disabled: Boolean,
+  readonly: Boolean,
+  color: Object,
+  maxHeight: [Number, String],
+  ...p()
+}, "VColorPickerSwatches");
+function x(o) {
+  return Object.keys(o).map((a) => {
+    const e = o[a];
+    return e.base ? [e.base, e.darken4, e.darken3, e.darken2, e.darken1, e.lighten1, e.lighten2, e.lighten3, e.lighten4, e.lighten5] : [e.black, e.white, e.transparent];
+  });
+}
+const A = S({
+  name: "VColorPickerSwatches",
+  props: _(),
+  emits: {
+    "update:color": (o) => !0
+  },
+  setup(o, a) {
+    let {
+      emit: e
+    } = a;
+    const s = h(() => !o.disabled && !o.readonly);
+    function m(r) {
+      !s.value || !r || e("update:color", r);
+    }
+    return V(() => t("div", {
+      class: n(["v-color-picker-swatches", o.class]),
+      style: u([{
+        maxHeight: F(o.maxHeight)
+      }, o.style])
+    }, [t("div", null, [o.swatches.map((r) => t("div", {
+      class: "v-color-picker-swatches__swatch"
+    }, [r.map((c) => {
+      const l = b(c), i = C(l), d = v(l);
+      return t("div", {
+        class: n(["v-color-picker-swatches__color", {
+          "v-color-picker-swatches__color--disabled": o.disabled
+        }]),
+        onClick: () => m(i)
+      }, [t("div", {
+        style: {
+          background: d
+        }
+      }, [o.color && P(o.color, i) ? k(w, {
+        size: "x-small",
+        icon: "$success",
+        color: g(c, "#FFFFFF") > 2 ? "white" : "black"
+      }, null) : void 0])]);
+    })]))])])), {};
+  }
+});
+export {
+  A as VColorPickerSwatches,
+  _ as makeVColorPickerSwatchesProps
+};