vue-data-ui 3.17.2 → 3.17.4

package/dist/patternUtils-BINhU4Ky.js

@@ -0,0 +1,615 @@
+function A(n) {
+  const a = String(n ?? "");
+  let t = 2166136261;
+  for (let s = 0; s < a.length; s += 1)
+    t ^= a.charCodeAt(s), t = Math.imul(t, 16777619);
+  return t >>> 0;
+}
+function D(n) {
+  let a = (Number.isFinite(n) ? n : 0) >>> 0;
+  return function() {
+    a += 1831565813;
+    let s = a;
+    return s = Math.imul(
+      s ^ s >>> 15,
+      s | 1
+    ), s ^= s + Math.imul(
+      s ^ s >>> 7,
+      s | 61
+    ), ((s ^ s >>> 14) >>> 0) / 4294967296;
+  };
+}
+function e(n, a, t) {
+  if (!Array.isArray(n) || n.length === 0)
+    return console.error(
+      "VueUiPatternSeed - pickValue requires a non-empty array"
+    ), t;
+  const s = typeof a == "function" ? a() : 0, c = Math.floor(s * n.length), r = n[c];
+  return r === void 0 ? (console.error("VueUiPatternSeed - pickValue selected an invalid index"), t ?? n[0]) : r;
+}
+function d(n) {
+  return String(n ?? "").replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function h(n, a, t, s, c, r, u) {
+  const $ = d(c);
+  return `<line x1="${n}" y1="${a}" x2="${t}" y2="${s}" stroke="${$}" stroke-width="${r}" opacity="${u}" shape-rendering="crispEdges" stroke-linecap="round" stroke-linejoin="round" />`;
+}
+function m(n, a, t, s, c) {
+  const r = d(s);
+  return `<circle cx="${n}" cy="${a}" r="${t}" fill="${r}" opacity="${c}" />`;
+}
+function U(n, a, t, s, c) {
+  const r = d(a), u = d(t);
+  return `<path d="${n}" fill="${r}" stroke="${u}" stroke-width="${s}" opacity="${c}" stroke-linecap="round" stroke-linejoin="round" />`;
+}
+function k(n, a, t, s, c, r, u = 0, $ = n + t / 2, p = a + s / 2) {
+  const P = d(c), M = u ? ` transform="rotate(${u} ${$} ${p})"` : "";
+  return `<rect x="${n}" y="${a}" width="${t}" height="${s}" fill="${P}" opacity="${r}"${M} />`;
+}
+function f(n, a, t, s, c) {
+  const r = t / 2, u = [
+    `M ${n} ${a - r}`,
+    `L ${n + r} ${a}`,
+    `L ${n} ${a + r}`,
+    `L ${n - r} ${a}`,
+    "Z"
+  ].join(" ");
+  return U(u, s, "none", 0, c);
+}
+function w(n, a) {
+  return Number.isFinite(n) && n > 0 ? n : a;
+}
+function L(n, a) {
+  let t = w(n, 8), s = w(a, 20);
+  if (t > s) {
+    const c = t;
+    t = s, s = c;
+  }
+  return {
+    minimumSize: t,
+    maximumSize: s
+  };
+}
+function q(n, a, t, s) {
+  const c = e(
+    [n * 0.08, n * 0.1, n * 0.12],
+    s,
+    n * 0.1
+  );
+  switch (e(
+    ["grid", "offsetGrid", "corners", "centered"],
+    s,
+    "grid"
+  )) {
+    case "offsetGrid":
+      return [
+        m(
+          n * 0.25,
+          n * 0.25,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.75,
+          n * 0.25,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.5,
+          n * 0.5,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.25,
+          n * 0.75,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.75,
+          n * 0.75,
+          c,
+          a,
+          t
+        )
+      ].join("");
+    case "corners":
+      return [
+        m(
+          n * 0.2,
+          n * 0.2,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.8,
+          n * 0.2,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.2,
+          n * 0.8,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.8,
+          n * 0.8,
+          c,
+          a,
+          t
+        )
+      ].join("");
+    case "centered":
+      return [
+        m(
+          n * 0.5,
+          n * 0.2,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.2,
+          n * 0.5,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.5,
+          n * 0.5,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.8,
+          n * 0.5,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.5,
+          n * 0.8,
+          c,
+          a,
+          t
+        )
+      ].join("");
+    default:
+      return [
+        m(
+          n * 0.25,
+          n * 0.25,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.75,
+          n * 0.25,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.25,
+          n * 0.75,
+          c,
+          a,
+          t
+        ),
+        m(
+          n * 0.75,
+          n * 0.75,
+          c,
+          a,
+          t
+        )
+      ].join("");
+  }
+}
+function E(n, a, t, s, c) {
+  const r = e(
+    ["diagonal", "vertical", "horizontal", "crosshatch", "grid"],
+    c,
+    "diagonal"
+  ), u = e(
+    [n * 0.28, n * 0.33, n * 0.4, n * 0.5],
+    c,
+    n * 0.33
+  );
+  switch (r) {
+    case "vertical":
+      return [0, u, u * 2].map(
+        (p) => h(
+          p,
+          0,
+          p,
+          n,
+          a,
+          t,
+          s
+        )
+      ).join("");
+    case "horizontal":
+      return [0, u, u * 2].map(
+        (p) => h(
+          0,
+          p,
+          n,
+          p,
+          a,
+          t,
+          s
+        )
+      ).join("");
+    case "crosshatch":
+      return [
+        h(
+          -n,
+          n,
+          n,
+          -n,
+          a,
+          t,
+          s
+        ),
+        h(
+          0,
+          n,
+          n,
+          0,
+          a,
+          t,
+          s
+        ),
+        h(
+          0,
+          0,
+          n,
+          n,
+          a,
+          t,
+          s * 0.8
+        ),
+        h(
+          n,
+          0,
+          0,
+          n,
+          a,
+          t * 0.8,
+          s * 0.8
+        )
+      ].join("");
+    case "grid":
+      return [
+        h(
+          n * 0.5,
+          0,
+          n * 0.5,
+          n,
+          a,
+          t,
+          s
+        ),
+        h(
+          0,
+          n * 0.5,
+          n,
+          n * 0.5,
+          a,
+          t,
+          s
+        )
+      ].join("");
+    default:
+      return [
+        h(
+          -n,
+          n,
+          n,
+          -n,
+          a,
+          t,
+          s
+        ),
+        h(
+          0,
+          n,
+          n,
+          0,
+          a,
+          t,
+          s
+        ),
+        h(
+          0,
+          n * 2,
+          n * 2,
+          0,
+          a,
+          t,
+          s
+        )
+      ].join("");
+  }
+}
+function G(n, a, t, s) {
+  const c = e(
+    ["diamonds", "squares", "mixed"],
+    s,
+    "diamonds"
+  ), r = e(
+    [n * 0.16, n * 0.2, n * 0.24],
+    s,
+    n * 0.2
+  );
+  switch (c) {
+    case "squares":
+      return [
+        k(
+          n * 0.2,
+          n * 0.2,
+          r,
+          r,
+          a,
+          t
+        ),
+        k(
+          n * 0.65,
+          n * 0.2,
+          r,
+          r,
+          a,
+          t
+        ),
+        k(
+          n * 0.2,
+          n * 0.65,
+          r,
+          r,
+          a,
+          t
+        ),
+        k(
+          n * 0.65,
+          n * 0.65,
+          r,
+          r,
+          a,
+          t
+        )
+      ].join("");
+    case "mixed":
+      return [
+        f(
+          n * 0.3,
+          n * 0.3,
+          r,
+          a,
+          t
+        ),
+        k(
+          n * 0.6,
+          n * 0.2,
+          r,
+          r,
+          a,
+          t
+        ),
+        f(
+          n * 0.7,
+          n * 0.7,
+          r,
+          a,
+          t
+        )
+      ].join("");
+    default:
+      return [
+        f(
+          n * 0.25,
+          n * 0.25,
+          r,
+          a,
+          t
+        ),
+        f(
+          n * 0.75,
+          n * 0.25,
+          r,
+          a,
+          t
+        ),
+        f(
+          n * 0.25,
+          n * 0.75,
+          r,
+          a,
+          t
+        ),
+        f(
+          n * 0.75,
+          n * 0.75,
+          r,
+          a,
+          t
+        )
+      ].join("");
+  }
+}
+function O(n, a, t) {
+  if (!e(
+    [!0, !1, !1],
+    t,
+    !1
+  ))
+    return "";
+  const c = e(
+    ["singleDot", "cornerDiamond", "softBand"],
+    t,
+    "singleDot"
+  ), r = e(
+    [0.12, 0.16, 0.2],
+    t,
+    0.16
+  );
+  switch (c) {
+    case "cornerDiamond":
+      return f(
+        n * 0.5,
+        n * 0.5,
+        n * 0.3,
+        a,
+        r
+      );
+    case "softBand":
+      return k(
+        0,
+        n * 0.4,
+        n,
+        n * 0.2,
+        a,
+        r
+      );
+    default:
+      return m(
+        n * 0.5,
+        n * 0.5,
+        n * 0.12,
+        a,
+        r
+      );
+  }
+}
+function T(n, a, t) {
+  const s = e(
+    [1, 1.25, 1.5, 1.75],
+    t,
+    1.25
+  ), c = e(
+    [0.4, 0.5, 0.6, 0.7],
+    t,
+    0.5
+  ), r = e(
+    ["lines", "dots", "shapes"],
+    t,
+    "lines"
+  );
+  let u = "";
+  r === "lines" ? u = E(
+    n,
+    a,
+    s,
+    c,
+    t
+  ) : r === "dots" ? u = q(
+    n,
+    a,
+    c,
+    t
+  ) : u = G(
+    n,
+    a,
+    c,
+    t
+  );
+  const $ = O(
+    n,
+    a,
+    t
+  );
+  return `${u}${$}`;
+}
+function B(n, a = {}) {
+  try {
+    const t = a?.disambiguator ?? "", s = `${String(n ?? "")}::${String(t)}`, c = a?.foregroundColor ?? "#111111", r = a?.backgroundColor ?? "transparent", { minimumSize: u, maximumSize: $ } = L(
+      a?.minimumSize,
+      a?.maximumSize
+    ), p = A(s), P = D(p), M = [];
+    for (let x = u; x <= $; x += 2)
+      M.push(x);
+    const j = e(
+      M.length > 0 ? M : [8],
+      P,
+      8
+    ), F = e(
+      [0, 0, 0, 15, 30, 45, 60, 90],
+      P,
+      0
+    ), V = [];
+    if (r !== "transparent") {
+      const x = d(r);
+      V.push(
+        `<rect x="0" y="0" width="${j}" height="${j}" fill="${x}" />`
+      );
+    }
+    return V.push(
+      T(
+        j,
+        c,
+        P
+      )
+    ), {
+      width: j,
+      height: j,
+      rotation: F,
+      patternType: "prettyUniquePattern",
+      contentMarkup: V.join("")
+    };
+  } catch (t) {
+    return console.error(
+      "VueUiPatternSeed - Failed to create seeded SVG pattern",
+      t
+    ), {
+      width: 8,
+      height: 8,
+      rotation: 0,
+      patternType: "prettyUniquePattern",
+      contentMarkup: ""
+    };
+  }
+}
+function b({
+  id: n,
+  seed: a,
+  foregroundColor: t,
+  backgroundColor: s,
+  maxSize: c,
+  minSize: r,
+  disambiguator: u
+}) {
+  try {
+    const $ = B(a, {
+      foregroundColor: t ?? "#1A1A1A",
+      backgroundColor: s ?? "transparent",
+      minimumSize: r,
+      maximumSize: c,
+      disambiguator: u
+    });
+    return `<defs><pattern id="${d(n)}" patternUnits="userSpaceOnUse" width="${$.width}" height="${$.height}" patternTransform="rotate(${$.rotation})">${$.contentMarkup}</pattern></defs>`;
+  } catch ($) {
+    return console.error(
+      "VueUiPatternSeed - Failed to create chart pattern slot markup",
+      $
+    ), `<defs><pattern id="${d(n)}" patternUnits="userSpaceOnUse" width="8" height="8" patternTransform="rotate(0)"></pattern></defs>`;
+  }
+}
+export {
+  B as a,
+  b as c
+};

package/dist/{pdf-B4tTdfvl.js → pdf-C4H4o1Cj.js}

@@ -1,4 +1,4 @@
-import { d as g } from "./dom-to-png-CtxhhdWb.js";
+import { d as g } from "./dom-to-png-DGvx6i5V.js";
 async function E({
   domElement: a,
   fileName: D,
@@ -54,7 +54,16 @@ async function E({
       });
       if (H === "single") {
         const P = (n.height - m) / 2;
-        l.addImage(u, "PNG", R, P, p, m, "", "FAST");
+        l.addImage(
+          u,
+          "PNG",
+          R,
+          P,
+          p,
+          m,
+          "",
+          "FAST"
+        );
       } else {
         const P = n.height / h;
         let A = c, _ = 0;