@ozdao/martyrs 0.2.602 → 0.2.604

package/dist/martyrs.es31.js

@@ -0,0 +1,83 @@
+import { ref as l, onMounted as p, createElementBlock as o, openBlock as t, createBlock as n, createVNode as c, normalizeClass as h, unref as y, withCtx as u, Fragment as v, renderList as b, Transition as g, renderSlot as k } from "vue";
+import { useI18n as w } from "vue-i18n";
+import { useGlobalMixins as _ } from "./martyrs.es61.js";
+import x from "./martyrs.es35.js";
+import j from "./martyrs.es37.js";
+import C from "./martyrs.es29.js";
+/* empty css             */
+import O from "./martyrs.es46.js";
+const B = { class: "pos-relative" }, D = {
+  key: 0,
+  class: "h-20r radius-semi pos-relative w-100 bg-light"
+}, L = {
+  __name: "Carousel",
+  props: {
+    showDots: Boolean,
+    store: Object,
+    states: {
+      type: Object,
+      default: () => ({
+        empty: {
+          title: "Nothing found",
+          description: "Sorry, nothing found"
+        }
+      })
+    },
+    options: Object,
+    text: Object,
+    user: Object
+  },
+  setup(e) {
+    const { replaceClasses: d } = _(), r = e, s = l([]), a = l(!0), { t: $ } = w({
+      messages: r.text
+    });
+    return p(async () => {
+      try {
+        s.value = await r.store.read(r.options), a.value = !1;
+      } catch (i) {
+        console.error("Error loading entities:", i), s.value = [], a.value = !1;
+      } finally {
+        a.value = !1;
+      }
+    }), (i, E) => (t(), o("div", B, [
+      a.value ? (t(), o("div", D, [
+        c(x, { centered: !0 })
+      ])) : s.value.length < 1 ? (t(), n(C, {
+        key: 1,
+        title: e.states.empty.title,
+        description: e.states.empty.description,
+        action: e.states.empty.action,
+        callback: e.states.empty.callback,
+        class: h(y(d)("pd-medium bg-light radius-medium", e.states.empty.class))
+      }, null, 8, ["title", "description", "action", "callback", "class"])) : (t(), n(j, {
+        key: 2,
+        showDots: e.showDots
+      }, {
+        default: u(() => [
+          (t(!0), o(v, null, b(s.value, (m, f) => (t(), o("div", {
+            key: f,
+            class: "carousel__slide pd-nano"
+          }, [
+            c(g, {
+              name: "fade",
+              mode: "out-in",
+              appear: ""
+            }, {
+              default: u(() => [
+                k(i.$slots, "default", {
+                  item: m,
+                  user: e.user
+                }, void 0, !0)
+              ]),
+              _: 2
+            }, 1024)
+          ]))), 128))
+        ]),
+        _: 3
+      }, 8, ["showDots"]))
+    ]));
+  }
+}, V = /* @__PURE__ */ O(L, [["__scopeId", "data-v-5db0aea4"]]);
+export {
+  V as default
+};

package/dist/martyrs.es32.js

@@ -0,0 +1,148 @@
+import { ref as i, onMounted as N, watchEffect as C, createBlock as V, openBlock as w, unref as s, isRef as $, withCtx as k, renderSlot as j, createVNode as I, createElementBlock as E, createCommentVNode as H, toDisplayString as M } from "vue";
+import O from "./martyrs.es8.js";
+import P from "./martyrs.es3.js";
+import q from "./martyrs.es81.js";
+import { useI18n as A } from "vue-i18n";
+const R = {
+  key: 0,
+  class: "desktop-only mn-r-thin"
+}, W = {
+  __name: "FieldBig",
+  props: {
+    input: String,
+    placeholder: {
+      type: String
+    },
+    action: {
+      type: String
+    },
+    placeholderTexts: {
+      type: Object,
+      default: () => ({
+        en: [
+          "Lowest THC, please!",
+          "Something with banana flavors?",
+          "I'm in the mood for trippy vibes."
+        ],
+        ru: [
+          "Я хочу самый низкий THC",
+          "Я хочу чего-нибудь бананового",
+          "Я хочу курнуть хейза"
+        ]
+      })
+    },
+    typingSpeed: {
+      type: Number,
+      default: 200
+    },
+    loopTyping: {
+      type: Boolean,
+      default: !1
+    },
+    enableTyping: {
+      type: Boolean,
+      default: !1
+    },
+    showLoader: {
+      type: Boolean,
+      default: !0
+    },
+    showSuccess: {
+      type: Boolean,
+      default: !0
+    },
+    callback: {
+      type: Function,
+      default: null
+    },
+    callbackDelay: {
+      type: Number,
+      default: 750
+    },
+    name: {
+      type: String,
+      default: null
+    },
+    id: {
+      type: String,
+      default: null
+    },
+    validation: {
+      type: [Object, Boolean],
+      default: !1
+    }
+  },
+  emits: ["update:input", "action"],
+  setup(n, { emit: T }) {
+    const m = Math.random().toString(36).substr(2, 9), l = n, S = l.name || `field-big-${m}`, x = l.id || `field-big-${m}`, { t: U, locale: d } = A();
+    let r = i(0), a = i(l.input), v = i(l.placeholder), o = i(l.enableTyping), f = i(null), p = i(""), c = i(!0), h = null;
+    const y = T;
+    async function B() {
+      const e = y("action");
+      return e && typeof e.then == "function" ? e : Promise.resolve(e);
+    }
+    function F(e) {
+      y("update:input", e), p.value = e;
+    }
+    function g() {
+      r.value = (r.value + 1) % l.placeholderTexts[d.value].length;
+    }
+    function D() {
+      o.value = !1, clearInterval(f.value), v.value = l.placeholder, p.value || (a.value = "");
+    }
+    function L() {
+      !p.value && l.enableTyping && (o.value = !0, v.value = "", b());
+    }
+    function b() {
+      let e = l.placeholderTexts[d.value][r.value], t = 0, u = !1;
+      h = setInterval(() => {
+        c.value = !c.value;
+      }, 200), f.value = setInterval(() => {
+        o.value && (u ? (a.value = a.value.slice(0, -1), a.value = e.substring(0, t) + (c.value && t % 2 ? "|" : ""), t--) : (a.value = e.substring(0, t) + (c.value && t % 2 ? "|" : ""), t++), t > e.length && l.loopTyping && setTimeout(() => {
+          u = !0, a.value = e.substring(0, t);
+        }, 333), t === 0 && u && (u = !1, g(), e = l.placeholderTexts[d.value][r.value]));
+      }, l.typingSpeed);
+    }
+    return N(() => {
+      l.enableTyping && b();
+    }), C(() => {
+      o.value || (clearInterval(f.value), clearInterval(h));
+    }), (e, t) => (w(), V(O, {
+      field: s(a),
+      "onUpdate:field": [
+        t[0] || (t[0] = (u) => $(a) ? a.value = u : a = u),
+        F
+      ],
+      placeholder: s(o) ? "" : n.placeholder,
+      onInput: g,
+      onFocus: D,
+      onBlur: L,
+      name: s(S),
+      id: s(x),
+      validation: n.validation,
+      class: "radius-medium flex-nowrap flex w-100 p-regular fw-regular uppercase pd-thin"
+    }, {
+      default: k(() => [
+        j(e.$slots, "default"),
+        I(P, {
+          submit: B,
+          showSucces: n.showSuccess,
+          showLoader: n.showLoader,
+          callback: n.callback,
+          callbackDelay: n.callbackDelay,
+          class: "ws-nowrap fw-medium radius-small uppercase cursor-pointer flex flex-v-center pd-thin w-max hover:bg-fifth fw-semi ease-linear t-black bg-main"
+        }, {
+          default: k(() => [
+            n.action ? (w(), E("span", R, M(n.action), 1)) : H("", !0),
+            I(q, { class: "i-medium" })
+          ]),
+          _: 1
+        }, 8, ["showSucces", "showLoader", "callback", "callbackDelay"])
+      ]),
+      _: 3
+    }, 8, ["field", "placeholder", "name", "id", "validation"]));
+  }
+};
+export {
+  W as default
+};

package/dist/martyrs.es33.js

@@ -0,0 +1,175 @@
+import { ref as v, computed as y, watch as L, createElementBlock as c, openBlock as d, createElementVNode as x, createCommentVNode as M, withDirectives as N, Fragment as b, renderList as _, createTextVNode as $, toDisplayString as D, vModelText as E, normalizeClass as K } from "vue";
+/* empty css             */
+import O from "./martyrs.es46.js";
+const R = { class: "field-tags-new" }, S = { class: "tags-container" }, j = ["onClick"], P = ["placeholder", "maxlength", "disabled"], U = {
+  key: 0,
+  class: "autocomplete"
+}, z = ["onClick", "onMouseenter"], q = {
+  __name: "FieldTags",
+  props: {
+    modelValue: Array,
+    textField: {
+      type: String,
+      default: "text"
+    },
+    autocompleteItems: Array,
+    separators: {
+      type: Array,
+      default: () => [",", ";"]
+    },
+    addOnKey: {
+      type: Array,
+      default: () => [13]
+      // Enter key
+    },
+    maxTags: {
+      type: Number,
+      default: 20
+    },
+    maxlength: {
+      type: Number,
+      default: 50
+    },
+    placeholder: String,
+    disabled: Boolean,
+    addOnBlur: {
+      type: Boolean,
+      default: !0
+    },
+    autocompleteMinLength: {
+      type: Number,
+      default: 1
+    }
+  },
+  emits: ["update:modelValue", "tags-changed"],
+  setup(p, { emit: A }) {
+    const l = p, T = A, r = v(""), g = v(!1), o = v(-1), C = v(null), n = y({
+      get: () => l.modelValue || [],
+      set: (e) => {
+        T("update:modelValue", e), T("tags-changed", e);
+      }
+    }), w = y(() => g.value && l.autocompleteItems?.length > 0 && r.value.length >= l.autocompleteMinLength), f = y(() => {
+      if (!l.autocompleteItems) return [];
+      const e = r.value.toLowerCase();
+      return l.autocompleteItems.filter((t) => {
+        const a = u(t).toLowerCase();
+        return a.includes(e) ? !h(a) : !1;
+      });
+    });
+    function u(e) {
+      return e == null ? "" : typeof e == "string" ? e : e[l.textField] || "";
+    }
+    function B(e) {
+      return n.value.length > 0 && typeof n.value[0] == "string" ? e : { [l.textField]: e };
+    }
+    function h(e) {
+      const t = e.toLowerCase().trim();
+      return n.value.some(
+        (a) => u(a).toLowerCase().trim() === t
+      );
+    }
+    function m(e) {
+      let t = "";
+      if (typeof e == "string")
+        t = e.trim();
+      else if (typeof e == "object") {
+        if (l.autocompleteItems?.includes(e)) {
+          h(u(e)) || (n.value = [...n.value, e]), r.value = "", o.value = -1;
+          return;
+        }
+        t = u(e).trim();
+      }
+      if (!t || n.value.length >= l.maxTags || h(t)) return;
+      const a = B(t);
+      n.value = [...n.value, a], r.value = "", o.value = -1;
+    }
+    function k(e) {
+      if (l.disabled) return;
+      const t = [...n.value];
+      t.splice(e, 1), n.value = t;
+    }
+    function V(e) {
+      if (w.value) {
+        if (e.key === "ArrowDown") {
+          e.preventDefault(), o.value = Math.min(
+            o.value + 1,
+            f.value.length - 1
+          );
+          return;
+        }
+        if (e.key === "ArrowUp") {
+          e.preventDefault(), o.value = Math.max(o.value - 1, -1);
+          return;
+        }
+        if (e.key === "Enter" && o.value >= 0) {
+          e.preventDefault(), m(f.value[o.value]);
+          return;
+        }
+      }
+      if (l.addOnKey.some((a) => typeof a == "number" ? e.keyCode === a : e.key === a)) {
+        e.preventDefault(), m(r.value);
+        return;
+      }
+      e.key === "Backspace" && r.value === "" && n.value.length > 0 && k(n.value.length - 1);
+    }
+    function F(e) {
+      e.preventDefault();
+      const t = e.clipboardData.getData("text");
+      if (!t) return;
+      const a = new RegExp(
+        l.separators.map((i) => i.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")
+      );
+      t.split(a).forEach((i) => {
+        n.value.length >= l.maxTags || m(i);
+      });
+    }
+    function I() {
+      setTimeout(() => {
+        g.value = !1, o.value = -1, l.addOnBlur && r.value && m(r.value);
+      }, 200);
+    }
+    return L(f, () => {
+      o.value = -1;
+    }), (e, t) => (d(), c("div", R, [
+      x("div", S, [
+        (d(!0), c(b, null, _(n.value, (a, s) => (d(), c("span", {
+          key: s,
+          class: "tag"
+        }, [
+          $(D(u(a)) + " ", 1),
+          x("button", {
+            onClick: (i) => k(s),
+            class: "tag-remove",
+            type: "button"
+          }, " × ", 8, j)
+        ]))), 128)),
+        N(x("input", {
+          ref_key: "inputRef",
+          ref: C,
+          "onUpdate:modelValue": t[0] || (t[0] = (a) => r.value = a),
+          onKeydown: V,
+          onPaste: F,
+          onFocus: t[1] || (t[1] = (a) => g.value = !0),
+          onBlur: I,
+          placeholder: p.placeholder || "Add tags",
+          maxlength: p.maxlength,
+          disabled: p.disabled,
+          class: "tag-input"
+        }, null, 40, P), [
+          [E, r.value]
+        ])
+      ]),
+      w.value && f.value.length > 0 ? (d(), c("div", U, [
+        (d(!0), c(b, null, _(f.value, (a, s) => (d(), c("div", {
+          key: u(a),
+          onClick: (i) => m(a),
+          onMouseenter: (i) => o.value = s,
+          class: K(["autocomplete-item", { selected: o.value === s }])
+        }, D(u(a)), 43, z))), 128))
+      ])) : M("", !0)
+    ]));
+  }
+}, Q = /* @__PURE__ */ O(q, [["__scopeId", "data-v-1b76c0f9"]]);
+export {
+  Q as default
+};

package/dist/martyrs.es34.js

@@ -0,0 +1,66 @@
+import { computed as a, createElementBlock as c, openBlock as p, normalizeStyle as u, renderSlot as d } from "vue";
+const f = {
+  __name: "Gradient",
+  props: {
+    colors: {
+      type: Array,
+      default: () => ["#000", "#fff"]
+    },
+    type: {
+      type: String,
+      default: "linear",
+      validator: (o) => ["linear", "radial", "conic"].includes(o)
+    },
+    angle: {
+      type: [Number, String],
+      default: 180
+    },
+    position: {
+      type: String,
+      default: "center"
+    },
+    shape: {
+      type: String,
+      default: "circle"
+    },
+    size: {
+      type: String,
+      default: "farthest-corner"
+    },
+    repeating: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  setup(o) {
+    const e = o, l = a(() => e.colors.map((t, r) => {
+      if (typeof t == "string") {
+        const s = e.colors.length > 1 ? r / (e.colors.length - 1) * 100 : 0;
+        return { color: t, stop: s };
+      }
+      return {
+        color: t.color || "#000",
+        stop: t.stop ?? r / Math.max(e.colors.length - 1, 1) * 100
+      };
+    })), n = a(() => l.value.map(({ color: t, stop: r }) => `${t} ${r}%`).join(", ")), i = a(() => {
+      const t = e.repeating ? "repeating-" : "";
+      switch (e.type) {
+        case "linear":
+          const r = typeof e.angle == "string" ? e.angle : `${e.angle}deg`;
+          return `${t}linear-gradient(${r}, ${n.value})`;
+        case "radial":
+          return `${t}radial-gradient(${e.shape} ${e.size} at ${e.position}, ${n.value})`;
+        case "conic":
+          return `${t}conic-gradient(from ${e.angle}deg at ${e.position}, ${n.value})`;
+      }
+    });
+    return (t, r) => (p(), c("div", {
+      style: u({ background: i.value })
+    }, [
+      d(t.$slots, "default")
+    ], 4));
+  }
+};
+export {
+  f as default
+};

package/dist/martyrs.es35.js

@@ -0,0 +1,57 @@
+import { createElementBlock as t, openBlock as r, normalizeClass as a, createElementVNode as s, createCommentVNode as c, toDisplayString as o } from "vue";
+/* empty css             */
+import i from "./martyrs.es46.js";
+const n = {
+  props: {
+    progress: {
+      type: Number,
+      default: null
+    },
+    status: {
+      type: String,
+      default: null
+    },
+    centered: {
+      type: Boolean,
+      default: !1
+    }
+  }
+}, d = {
+  key: 0,
+  class: "progress-text"
+}, u = {
+  key: 1,
+  class: "uppercase fw-semi w-m-10r status-text"
+};
+function m(f, l, e, p, x, _) {
+  return r(), t("div", {
+    class: a(["circular-loader z-index-1 w-100 h-100 w-max-2r h-max-2r", { "circular-loader-centered": e.centered }])
+  }, [
+    l[0] || (l[0] = s("svg", { viewBox: "25 25 50 50" }, [
+      s("circle", {
+        class: "circular-loader-fill",
+        cx: "50",
+        cy: "50",
+        r: "20",
+        fill: "none",
+        "stroke-width": "4",
+        "stroke-miterlimit": "10"
+      }),
+      s("circle", {
+        class: "circular-loader-circle",
+        cx: "50",
+        cy: "50",
+        r: "20",
+        fill: "none",
+        "stroke-width": "4",
+        "stroke-miterlimit": "10"
+      })
+    ], -1)),
+    e.progress ? (r(), t("div", d, o(e.progress), 1)) : c("", !0),
+    e.status ? (r(), t("div", u, o(e.status), 1)) : c("", !0)
+  ], 2);
+}
+const w = /* @__PURE__ */ i(n, [["render", m]]);
+export {
+  w as default
+};

package/dist/martyrs.es36.js

@@ -0,0 +1,76 @@
+import { ref as P, watch as T, onMounted as R, createElementBlock as v, openBlock as w } from "vue";
+/* empty css             */
+import E from "./martyrs.es46.js";
+const L = {
+  __name: "Shader",
+  props: {
+    shader: {
+      type: String,
+      required: !0
+    },
+    theme: {
+      type: String,
+      default: "light"
+      // или любое другое значение по умолчанию
+    }
+  },
+  setup(d) {
+    const c = d, h = P(null);
+    let e = null, r = null, s = null;
+    const f = () => {
+      if (!e || !r) return;
+      s || (s = e.getUniformLocation(r, "iTheme"));
+      const a = c.theme === "light" ? 1 : 0;
+      e.uniform1f(s, a);
+    };
+    return T(() => c.theme, () => {
+      f();
+    }, { immediate: !0 }), R(() => {
+      const a = h.value;
+      e = a.getContext("webgl") || a.getContext("experimental-webgl");
+      const l = `
+    attribute vec4 aVertexPosition;
+    void main() {
+      gl_Position = aVertexPosition;
+    }
+  `, g = c.shader;
+      function m(t, n, i) {
+        const o = t.createShader(n);
+        return t.shaderSource(o, i), t.compileShader(o), t.getShaderParameter(o, t.COMPILE_STATUS) ? o : (alert("An error occurred compiling the shaders: " + t.getShaderInfoLog(o)), t.deleteShader(o), null);
+      }
+      const p = m(e, e.VERTEX_SHADER, l), S = m(e, e.FRAGMENT_SHADER, g);
+      r = e.createProgram(), e.attachShader(r, p), e.attachShader(r, S), e.linkProgram(r), e.getProgramParameter(r, e.LINK_STATUS) || alert("Unable to initialize the shader program: " + e.getProgramInfoLog(r));
+      function _(t) {
+        const n = t.clientWidth * window.devicePixelRatio, i = t.clientHeight * window.devicePixelRatio;
+        return t.width !== n || t.height !== i ? (t.width = n, t.height = i, !0) : !1;
+      }
+      function u() {
+        _(e.canvas) && e.viewport(0, 0, e.canvas.width, e.canvas.height), e.clearColor(0, 0, 0, 1), e.clearDepth(1), e.enable(e.DEPTH_TEST), e.depthFunc(e.LEQUAL), e.clear(e.COLOR_BUFFER_BIT | e.DEPTH_BUFFER_BIT), e.useProgram(r);
+        const t = e.createBuffer();
+        e.bindBuffer(e.ARRAY_BUFFER, t);
+        const n = [
+          -1,
+          1,
+          1,
+          1,
+          -1,
+          -1,
+          1,
+          -1
+        ];
+        e.bufferData(e.ARRAY_BUFFER, new Float32Array(n), e.STATIC_DRAW);
+        const i = e.getAttribLocation(r, "aVertexPosition");
+        e.vertexAttribPointer(i, 2, e.FLOAT, !1, 0, 0), e.enableVertexAttribArray(i);
+        const o = e.getUniformLocation(r, "iTime"), A = e.getUniformLocation(r, "iResolution");
+        e.uniform1f(o, performance.now() / 3e3), e.uniform2f(A, e.canvas.width, e.canvas.height), f(), e.drawArrays(e.TRIANGLE_STRIP, 0, 4), requestAnimationFrame(u);
+      }
+      requestAnimationFrame(u);
+    }), (a, l) => (w(), v("canvas", {
+      ref_key: "refCanvas",
+      ref: h
+    }, null, 512));
+  }
+}, b = /* @__PURE__ */ E(L, [["__scopeId", "data-v-ff83a5c4"]]);
+export {
+  b as default
+};