@nmorph/nmorph-ui-kit 2.2.34 → 2.2.36

package/dist/components/data/nmorph-qr-code/qr-code.js

@@ -0,0 +1,568 @@
+const z = {
+  low: [
+    -1,
+    7,
+    10,
+    15,
+    20,
+    26,
+    18,
+    20,
+    24,
+    30,
+    18,
+    20,
+    24,
+    26,
+    30,
+    22,
+    24,
+    28,
+    30,
+    28,
+    28,
+    28,
+    28,
+    30,
+    30,
+    26,
+    28,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30
+  ],
+  medium: [
+    -1,
+    10,
+    16,
+    26,
+    18,
+    24,
+    16,
+    18,
+    22,
+    22,
+    26,
+    30,
+    22,
+    22,
+    24,
+    24,
+    28,
+    28,
+    26,
+    26,
+    26,
+    26,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28,
+    28
+  ],
+  quartile: [
+    -1,
+    13,
+    22,
+    18,
+    26,
+    18,
+    24,
+    18,
+    22,
+    20,
+    24,
+    28,
+    26,
+    24,
+    20,
+    30,
+    24,
+    28,
+    28,
+    26,
+    30,
+    28,
+    30,
+    30,
+    30,
+    30,
+    28,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30
+  ],
+  high: [
+    -1,
+    17,
+    28,
+    22,
+    16,
+    22,
+    28,
+    26,
+    26,
+    24,
+    28,
+    24,
+    28,
+    22,
+    24,
+    24,
+    30,
+    28,
+    28,
+    26,
+    28,
+    30,
+    24,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30,
+    30
+  ]
+}, y = {
+  low: [
+    -1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    2,
+    2,
+    4,
+    4,
+    4,
+    4,
+    4,
+    6,
+    6,
+    6,
+    6,
+    7,
+    8,
+    8,
+    9,
+    9,
+    10,
+    12,
+    12,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    19,
+    20,
+    21,
+    22,
+    24,
+    25
+  ],
+  medium: [
+    -1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    4,
+    4,
+    4,
+    5,
+    5,
+    5,
+    8,
+    9,
+    9,
+    10,
+    10,
+    11,
+    13,
+    14,
+    16,
+    17,
+    17,
+    18,
+    20,
+    21,
+    23,
+    25,
+    26,
+    28,
+    29,
+    31,
+    33,
+    35,
+    37,
+    38,
+    40,
+    43,
+    45,
+    47,
+    49
+  ],
+  quartile: [
+    -1,
+    1,
+    1,
+    2,
+    2,
+    4,
+    4,
+    6,
+    6,
+    8,
+    8,
+    8,
+    10,
+    12,
+    16,
+    12,
+    17,
+    16,
+    18,
+    21,
+    20,
+    23,
+    23,
+    25,
+    27,
+    29,
+    34,
+    34,
+    35,
+    38,
+    40,
+    43,
+    45,
+    48,
+    51,
+    53,
+    56,
+    59,
+    62,
+    65,
+    68
+  ],
+  high: [
+    -1,
+    1,
+    1,
+    2,
+    4,
+    4,
+    4,
+    5,
+    6,
+    8,
+    8,
+    11,
+    11,
+    16,
+    16,
+    18,
+    16,
+    19,
+    21,
+    25,
+    25,
+    25,
+    34,
+    30,
+    32,
+    35,
+    37,
+    40,
+    42,
+    45,
+    48,
+    51,
+    54,
+    57,
+    60,
+    63,
+    66,
+    70,
+    74,
+    77,
+    81
+  ]
+}, x = {
+  low: 1,
+  medium: 0,
+  quartile: 3,
+  high: 2
+}, p = (i) => Math.min(Math.max(Math.trunc(i), 1), 40), u = (i, t) => (i >>> t & 1) !== 0, M = (i, t, e) => {
+  for (let s = e - 1; s >= 0; s--) i.push(u(t, s));
+}, P = (i) => {
+  let t = (16 * i + 128) * i + 64;
+  if (i >= 2) {
+    const e = Math.floor(i / 7) + 2;
+    t -= (25 * e - 10) * e - 55, i >= 7 && (t -= 36);
+  }
+  return t;
+}, B = (i, t) => Math.floor(P(i) / 8) - z[t][i] * y[t][i], w = (i) => i <= 9 ? 8 : 16, k = (i, t) => 4 + w(t) + i * 8, A = (i) => {
+  if (i === 1) return [];
+  const t = i * 4 + 17, e = Math.floor(i / 7) + 2, s = i === 32 ? 26 : Math.ceil((i * 4 + 4) / (e * 2 - 2)) * 2, n = [6];
+  for (let o = t - 7; n.length < e; o -= s) n.splice(1, 0, o);
+  return n;
+}, F = (i, t) => {
+  let e = 0;
+  for (let s = 7; s >= 0; s--)
+    e = e << 1 ^ (e >>> 7) * 285, e ^= (t >>> s & 1) * i;
+  return e;
+}, R = (i) => {
+  const t = Array(i).fill(0);
+  t[i - 1] = 1;
+  let e = 1;
+  for (let s = 0; s < i; s++) {
+    for (let n = 0; n < i; n++)
+      t[n] = F(t[n], e), n + 1 < i && (t[n] ^= t[n + 1]);
+    e = F(e, 2);
+  }
+  return t;
+}, b = (i, t) => {
+  const e = Array(t.length).fill(0);
+  return i.forEach((s) => {
+    const n = s ^ (e.shift() || 0);
+    e.push(0), t.forEach((o, r) => {
+      e[r] ^= F(o, n);
+    });
+  }), e;
+}, E = (i, t, e) => {
+  const s = y[e][t], n = z[e][t], o = Math.floor(P(t) / 8), r = s - o % s, a = Math.floor(o / s), c = R(n), h = [];
+  let f = 0;
+  for (let l = 0; l < s; l++) {
+    const d = a - n + (l < r ? 0 : 1), g = i.slice(f, f + d);
+    f += d;
+    const C = b(g, c);
+    l < r && g.push(0), h.push([...g, ...C]);
+  }
+  const m = [];
+  for (let l = 0; l < h[0].length; l++)
+    h.forEach((d, g) => {
+      (l !== a - n || g >= r) && m.push(d[l]);
+    });
+  return m;
+}, L = (i, t, e) => {
+  const s = B(t, e) * 8, n = [];
+  for (M(n, 4, 4), M(n, i.length, w(t)), i.forEach((r) => M(n, r, 8)), M(n, 0, Math.min(4, s - n.length)); n.length % 8 !== 0; ) n.push(!1);
+  const o = [];
+  for (let r = 0; r < n.length; r += 8) {
+    let a = 0;
+    for (let c = 0; c < 8; c++) a = a << 1 | (n[r + c] ? 1 : 0);
+    o.push(a);
+  }
+  for (let r = 236; o.length < s / 8; r ^= 253) o.push(r);
+  return o;
+}, S = (i, t, e) => {
+  switch (i) {
+    case 0:
+      return (t + e) % 2 === 0;
+    case 1:
+      return e % 2 === 0;
+    case 2:
+      return t % 3 === 0;
+    case 3:
+      return (t + e) % 3 === 0;
+    case 4:
+      return (Math.floor(t / 3) + Math.floor(e / 2)) % 2 === 0;
+    case 5:
+      return t * e % 2 + t * e % 3 === 0;
+    case 6:
+      return (t * e % 2 + t * e % 3) % 2 === 0;
+    default:
+      return ((t + e) % 2 + t * e % 3) % 2 === 0;
+  }
+};
+class O {
+  constructor(t, e) {
+    this.version = t, this.level = e, this.size = t * 4 + 17, this.modules = Array.from({ length: this.size }, () => Array(this.size).fill(!1)), this.isFunction = Array.from({ length: this.size }, () => Array(this.size).fill(!1));
+  }
+  size;
+  modules;
+  isFunction;
+  drawFunctionPatterns() {
+    for (let e = 0; e < this.size; e++)
+      this.setFunctionModule(6, e, e % 2 === 0), this.setFunctionModule(e, 6, e % 2 === 0);
+    this.drawFinderPattern(3, 3), this.drawFinderPattern(this.size - 4, 3), this.drawFinderPattern(3, this.size - 4);
+    const t = A(this.version);
+    t.forEach((e, s) => {
+      t.forEach((n, o) => {
+        s === 0 && o === 0 || s === 0 && o === t.length - 1 || s === t.length - 1 && o === 0 || this.drawAlignmentPattern(e, n);
+      });
+    }), this.drawFormatBits(0), this.drawVersion();
+  }
+  drawCodewords(t) {
+    let e = 0;
+    for (let s = this.size - 1; s >= 1; s -= 2) {
+      s === 6 && (s = 5);
+      for (let n = 0; n < this.size; n++)
+        for (let o = 0; o < 2; o++) {
+          const r = s - o, c = (s + 1 & 2) === 0 ? this.size - 1 - n : n;
+          !this.isFunction[c][r] && e < t.length * 8 && (this.modules[c][r] = u(t[e >>> 3], 7 - (e & 7)), e++);
+        }
+    }
+  }
+  applyMask(t) {
+    for (let e = 0; e < this.size; e++)
+      for (let s = 0; s < this.size; s++)
+        !this.isFunction[e][s] && S(t, s, e) && (this.modules[e][s] = !this.modules[e][s]);
+  }
+  drawFormatBits(t) {
+    const e = x[this.level] << 3 | t;
+    let s = e;
+    for (let o = 0; o < 10; o++) s = s << 1 ^ (s >>> 9) * 1335;
+    const n = (e << 10 | s) ^ 21522;
+    for (let o = 0; o <= 5; o++) this.setFunctionModule(8, o, u(n, o));
+    this.setFunctionModule(8, 7, u(n, 6)), this.setFunctionModule(8, 8, u(n, 7)), this.setFunctionModule(7, 8, u(n, 8));
+    for (let o = 9; o < 15; o++) this.setFunctionModule(14 - o, 8, u(n, o));
+    for (let o = 0; o < 8; o++) this.setFunctionModule(this.size - 1 - o, 8, u(n, o));
+    for (let o = 8; o < 15; o++) this.setFunctionModule(8, this.size - 15 + o, u(n, o));
+    this.setFunctionModule(8, this.size - 8, !0);
+  }
+  getPenaltyScore() {
+    let t = 0;
+    for (let o = 0; o < this.size; o++) t += this.getRunPenalty(this.modules[o]);
+    for (let o = 0; o < this.size; o++) t += this.getRunPenalty(this.modules.map((r) => r[o]));
+    for (let o = 0; o < this.size - 1; o++)
+      for (let r = 0; r < this.size - 1; r++) {
+        const a = this.modules[o][r];
+        a === this.modules[o][r + 1] && a === this.modules[o + 1][r] && a === this.modules[o + 1][r + 1] && (t += 3);
+      }
+    t += this.getFinderPenalty();
+    const e = this.modules.flat().filter(Boolean).length;
+    let s = 0;
+    const n = this.size * this.size;
+    for (; e * 20 < (9 - s) * n || e * 20 > (11 + s) * n; )
+      s++;
+    return t + s * 10;
+  }
+  drawFinderPattern(t, e) {
+    for (let s = -4; s <= 4; s++)
+      for (let n = -4; n <= 4; n++) {
+        const o = t + n, r = e + s;
+        if (o < 0 || o >= this.size || r < 0 || r >= this.size) continue;
+        const a = Math.max(Math.abs(n), Math.abs(s));
+        this.setFunctionModule(o, r, a !== 2 && a !== 4);
+      }
+  }
+  drawAlignmentPattern(t, e) {
+    for (let s = -2; s <= 2; s++)
+      for (let n = -2; n <= 2; n++)
+        this.setFunctionModule(t + n, e + s, Math.max(Math.abs(n), Math.abs(s)) !== 1);
+  }
+  drawVersion() {
+    if (this.version < 7) return;
+    let t = this.version;
+    for (let s = 0; s < 12; s++) t = t << 1 ^ (t >>> 11) * 7973;
+    const e = this.version << 12 | t;
+    for (let s = 0; s < 18; s++) {
+      const n = u(e, s), o = this.size - 11 + s % 3, r = Math.floor(s / 3);
+      this.setFunctionModule(o, r, n), this.setFunctionModule(r, o, n);
+    }
+  }
+  setFunctionModule(t, e, s) {
+    this.modules[e][t] = s, this.isFunction[e][t] = !0;
+  }
+  getRunPenalty(t) {
+    let e = 0, s = t[0], n = 1;
+    for (let o = 1; o < t.length; o++)
+      t[o] === s ? n++ : (n >= 5 && (e += 3 + n - 5), s = t[o], n = 1);
+    return n >= 5 && (e += 3 + n - 5), e;
+  }
+  getFinderPenalty() {
+    let t = 0;
+    for (let e = 0; e < this.size; e++) t += this.getFinderPenaltyForLine(this.modules[e]);
+    for (let e = 0; e < this.size; e++) t += this.getFinderPenaltyForLine(this.modules.map((s) => s[e]));
+    return t;
+  }
+  getFinderPenaltyForLine(t) {
+    let e = 0;
+    for (let s = 0; s <= t.length - 7; s++) {
+      if (!(t[s] && !t[s + 1] && t[s + 2] && t[s + 3] && t[s + 4] && !t[s + 5] && t[s + 6])) continue;
+      const o = s >= 4 && t.slice(s - 4, s).every((a) => !a), r = s + 11 <= t.length && t.slice(s + 7, s + 11).every((a) => !a);
+      (o || r) && (e += 40);
+    }
+    return e;
+  }
+}
+const _ = (i) => Array.from(new TextEncoder().encode(i)), D = (i, t = {}) => {
+  const e = t.errorCorrectionLevel ?? "medium", s = p(t.minVersion ?? 1), n = p(t.maxVersion ?? 40), o = _(i), r = Array.from({ length: n - s + 1 }, (l, d) => s + d).find(
+    (l) => o.length < 1 << w(l) && k(o.length, l) <= B(l, e) * 8
+  );
+  if (!r) throw new Error("The QR code value is too large for the selected version range.");
+  const a = L(o, r, e), c = E(a, r, e), h = new O(r, e);
+  h.drawFunctionPatterns(), h.drawCodewords(c);
+  let f = 0, m = 1 / 0;
+  for (let l = 0; l < 8; l++) {
+    h.applyMask(l), h.drawFormatBits(l);
+    const d = h.getPenaltyScore();
+    d < m && (f = l, m = d), h.applyMask(l);
+  }
+  return h.applyMask(f), h.drawFormatBits(f), {
+    modules: h.modules.map((l) => [...l]),
+    size: h.size,
+    version: r
+  };
+};
+export {
+  D as createNmorphQRCode
+};

package/dist/components/data/nmorph-virtual-list/NmorphVirtualList.css

@@ -0,0 +1 @@
+.nmorph-virtual-list{position:relative;box-sizing:border-box;min-width:0;height:var(--nmorph-virtual-list-height);max-height:var(--nmorph-virtual-list-max-height);overflow:auto;color:var(--nmorph-text-color);background:var(--nmorph-main-color);border-radius:var(--default-border-radius);box-shadow:var(--nmorph-shadow-inset)}.nmorph-virtual-list--disabled{height:auto;overflow:visible}.nmorph-virtual-list .nmorph-virtual-list__spacer{position:relative;min-height:100%}.nmorph-virtual-list .nmorph-virtual-list__content{position:absolute;top:0;right:0;left:0}.nmorph-virtual-list--disabled .nmorph-virtual-list__content{position:static;transform:none}.nmorph-virtual-list .nmorph-virtual-list__item{box-sizing:border-box;min-height:var(--nmorph-virtual-list-item-height)}.nmorph-virtual-list .nmorph-virtual-list__empty{display:flex;justify-content:center;align-items:center;min-height:100%;padding:var(--indentation-04);color:var(--nmorph-semi-contrast-text-color)}

package/dist/components/data/nmorph-virtual-list/NmorphVirtualList.vue.js

@@ -0,0 +1,86 @@
+import './NmorphVirtualList.css';
+import a from "./NmorphVirtualList.vue2.js";
+import { openBlock as t, createElementBlock as o, normalizeStyle as l, normalizeClass as m, createElementVNode as c, Fragment as d, renderList as p, createBlock as _, resolveDynamicComponent as f, withCtx as y, renderSlot as n, createTextVNode as h, toDisplayString as k } from "vue";
+/* empty css                       */
+import x from "../../../_virtual/_plugin-vue_export-helper.js";
+const v = {
+  key: 1,
+  class: "nmorph-virtual-list__empty"
+};
+function S(i, g, u, e, N, V) {
+  return t(), o(
+    "div",
+    {
+      ref: "containerRef",
+      class: m(e.modifiers),
+      style: l(e.styles),
+      onScroll: e.scrollHandler
+    },
+    [
+      e.props.items.length ? (t(), o(
+        "div",
+        {
+          key: 0,
+          class: "nmorph-virtual-list__spacer",
+          style: l(e.spacerStyle)
+        },
+        [
+          c(
+            "div",
+            {
+              class: "nmorph-virtual-list__content",
+              style: l(e.contentStyle)
+            },
+            [
+              (t(!0), o(
+                d,
+                null,
+                p(e.renderedItems, (r) => (t(), _(
+                  f(e.props.itemTag),
+                  {
+                    key: e.getItemKey(r.item, r.index),
+                    ref_for: !0,
+                    ref: (s) => e.setItemRef(s, r.index),
+                    class: "nmorph-virtual-list__item"
+                  },
+                  {
+                    default: y(() => [
+                      n(i.$slots, "default", {
+                        item: r.item,
+                        index: r.index
+                      }, () => [
+                        h(
+                          k(r.item),
+                          1
+                          /* TEXT */
+                        )
+                      ])
+                    ]),
+                    _: 2
+                    /* DYNAMIC */
+                  },
+                  1024
+                  /* DYNAMIC_SLOTS */
+                ))),
+                128
+                /* KEYED_FRAGMENT */
+              ))
+            ],
+            4
+            /* STYLE */
+          )
+        ],
+        4
+        /* STYLE */
+      )) : (t(), o("div", v, [
+        n(i.$slots, "empty")
+      ]))
+    ],
+    38
+    /* CLASS, STYLE, NEED_HYDRATION */
+  );
+}
+const z = /* @__PURE__ */ x(a, [["render", S], ["__file", "/builds/ketjo/nmorph/library/src/components/data/nmorph-virtual-list/NmorphVirtualList.vue"]]);
+export {
+  z as default
+};

package/dist/components/data/nmorph-virtual-list/NmorphVirtualList.vue2.js

@@ -0,0 +1,60 @@
+import './NmorphVirtualList.css';
+import { defineComponent as K, computed as r } from "vue";
+import { useModifiers as $ } from "../../../utils/create-modifiers.js";
+import { useVirtualList as N } from "../../../hooks/use-virtual-list.js";
+const j = /* @__PURE__ */ K({
+  __name: "NmorphVirtualList",
+  props: {
+    items: { type: Array, required: !1, default: () => [] },
+    height: { type: [Number, String], required: !1, default: "320px" },
+    maxHeight: { type: [Number, String], required: !1, default: "none" },
+    itemHeight: { type: Number, required: !1, default: 40 },
+    overscan: { type: Number, required: !1, default: 5 },
+    dynamic: { type: Boolean, required: !1, default: !1 },
+    disabled: { type: Boolean, required: !1, default: !1 },
+    itemKey: { type: [String, Function], required: !1, default: void 0 },
+    itemTag: { type: String, required: !1, default: "div" }
+  },
+  emits: ["on-scroll"],
+  setup(y, { expose: h, emit: g }) {
+    const e = y, a = g, l = r(() => e.items), o = r(() => !e.disabled), u = r(() => e.itemHeight), m = r(() => e.overscan), d = r(() => e.dynamic), i = N(l, {
+      enabled: o,
+      itemHeight: u,
+      overscan: m,
+      dynamic: d
+    }), c = i.containerRef, v = r(
+      () => $({
+        "nmorph-virtual-list": [`${e.disabled && "disabled"}`, `${e.dynamic && "dynamic"}`]
+      })
+    ), n = (t) => typeof t == "number" ? `${t}px` : t, b = r(() => ({
+      "--nmorph-virtual-list-height": n(e.height),
+      "--nmorph-virtual-list-max-height": n(e.maxHeight),
+      "--nmorph-virtual-list-item-height": `${e.itemHeight}px`
+    })), x = r(() => ({
+      transform: o.value ? `translateY(${i.offsetTop.value}px)` : void 0
+    })), S = r(() => ({
+      height: o.value ? `${i.totalHeight.value}px` : void 0
+    })), _ = r(() => i.virtualItems.value), q = (t, s) => {
+      if (typeof e.itemKey == "function") return e.itemKey(t, s);
+      if (typeof e.itemKey == "string" && t && typeof t == "object") {
+        const p = t[e.itemKey];
+        return p === void 0 ? s : String(p);
+      }
+      return s;
+    }, H = (t) => {
+      i.scrollHandler(), a("on-scroll", t);
+    }, I = (t, s) => {
+      i.measureElement(s, t);
+    };
+    h({
+      containerRef: c,
+      refresh: i.refresh,
+      scrollToIndex: i.scrollToIndex
+    });
+    const f = { props: e, emit: a, items: l, enabled: o, itemHeight: u, overscan: m, dynamic: d, virtualList: i, containerRef: c, modifiers: v, getCssSize: n, styles: b, contentStyle: x, spacerStyle: S, renderedItems: _, getItemKey: q, scrollHandler: H, setItemRef: I };
+    return Object.defineProperty(f, "__isScriptSetup", { enumerable: !1, value: !0 }), f;
+  }
+});
+export {
+  j as default
+};

package/dist/components/feedback/nmorph-drawer/NmorphDrawer.css

@@ -0,0 +1 @@
+.nmorph-drawer{position:fixed;display:flex;flex-direction:column;box-sizing:border-box;overflow:hidden;color:var(--nmorph-text-color);background:var(--nmorph-main-color);box-shadow:var(--nmorph-shadow-outset);transition:transform var(--transition-02) ease}.nmorph-drawer--left,.nmorph-drawer--right{top:0;width:min(var(--nmorph-drawer-size),100vw);height:100vh}.nmorph-drawer--top,.nmorph-drawer--bottom{left:0;width:100vw;height:min(var(--nmorph-drawer-size),100vh)}.nmorph-drawer--left{left:0;transform:translate(-110%)}.nmorph-drawer--right{right:0;transform:translate(110%)}.nmorph-drawer--top{top:0;transform:translateY(-110%)}.nmorph-drawer--bottom{bottom:0;transform:translateY(110%)}.nmorph-drawer--open{transform:translate(0)}.nmorph-drawer .nmorph-drawer__header,.nmorph-drawer .nmorph-drawer__footer{flex:0 0 auto;box-sizing:border-box;padding:var(--indentation-04)}.nmorph-drawer .nmorph-drawer__header{display:flex;gap:var(--indentation-03);justify-content:space-between;align-items:center;font-weight:600;font-size:var(--font-size-large);line-height:var(--line-height-loose)}.nmorph-drawer .nmorph-drawer__title{min-width:0;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.nmorph-drawer .nmorph-drawer__close{display:inline-flex;flex:0 0 auto;justify-content:center;align-items:center;width:32px;height:32px;padding:0;color:inherit;background:transparent;border:0;cursor:pointer}.nmorph-drawer .nmorph-drawer__content{flex:1 1 auto;box-sizing:border-box;min-width:0;min-height:0;padding:0 var(--indentation-04) var(--indentation-04);overflow:hidden auto}