@indielayer/ui 1.5.2 → 1.6.1

package/lib/components/qrCode/QrCode.vue.d.ts

@@ -0,0 +1,68 @@
+import { type ExtractPublicPropTypes } from 'vue';
+import { type ThemeComponent } from '../../composables/useTheme';
+declare const qrCodeProps: {
+    value: StringConstructor;
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    backgroundColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    errorCorrectionLevel: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export type QrCodeProps = ExtractPublicPropTypes<typeof qrCodeProps>;
+type InternalClasses = 'wrapper';
+export interface QrCodeTheme extends ThemeComponent<QrCodeProps, InternalClasses> {
+}
+declare const _default: import("vue").DefineComponent<{
+    value: StringConstructor;
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    backgroundColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    errorCorrectionLevel: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: StringConstructor;
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    backgroundColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    errorCorrectionLevel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    color: string;
+    size: string | number;
+    backgroundColor: string;
+    errorCorrectionLevel: string;
+}, {}>;
+export default _default;

package/lib/components/qrCode/QrCode.vue.js

@@ -0,0 +1,93 @@
+import { defineComponent as k, ref as S, computed as b, onMounted as _, watchEffect as x, openBlock as I, createElementBlock as N, normalizeStyle as h, unref as i, normalizeClass as H, createElementVNode as O } from "vue";
+import { useTheme as T } from "../../composables/useTheme.js";
+import r from "./qrcodegen.js";
+const $ = {
+  value: String,
+  color: {
+    type: String,
+    default: "#000"
+  },
+  backgroundColor: {
+    type: String,
+    default: "#fff"
+  },
+  size: {
+    type: [String, Number],
+    default: 100
+  },
+  errorCorrectionLevel: {
+    type: String,
+    default: "M"
+  }
+}, U = {
+  name: "XQrCode",
+  validators: {
+    errorCorrectionLevel: ["L", "M", "Q", "H"]
+  }
+}, V = /* @__PURE__ */ k({
+  ...U,
+  props: $,
+  setup(m) {
+    const o = m, C = {
+      L: r.QrCode.Ecc.LOW,
+      M: r.QrCode.Ecc.MEDIUM,
+      Q: r.QrCode.Ecc.QUARTILE,
+      H: r.QrCode.Ecc.HIGH
+    }, d = S(), g = b(() => r.QrCode.encodeText(
+      o.value ?? "-",
+      C[o.errorCorrectionLevel] || r.QrCode.Ecc.MEDIUM
+    ));
+    _(() => {
+      x(() => {
+        E(
+          g.value,
+          Number(o.size),
+          o.color,
+          o.backgroundColor
+        );
+      });
+    });
+    function E(e, f, y, z) {
+      const t = d.value;
+      if (!t)
+        return;
+      const l = f * 2, R = e.size, s = l / R;
+      t.width = l, t.height = l;
+      const a = t.getContext("2d");
+      if (a) {
+        a.clearRect(0, 0, t.width, t.height);
+        for (let c = 0; c < e.size; c++)
+          for (let n = 0; n < e.size; n++) {
+            a.fillStyle = e.getModule(n, c) ? y : z;
+            const u = Math.floor(n * s), L = Math.ceil((n + 1) * s), p = Math.floor(c * s), w = Math.ceil((c + 1) * s);
+            a.fillRect(u, p, L - u, w - p);
+          }
+      }
+    }
+    const { styles: v, classes: M, className: Q } = T("QrCode", {}, o);
+    return (e, f) => (I(), N("div", {
+      style: h([i(v), {
+        width: `calc(1rem + ${e.size}px)`,
+        height: `calc(1rem + ${e.size}px)`,
+        backgroundColor: e.backgroundColor,
+        padding: "0.5rem"
+      }]),
+      class: H([
+        i(Q),
+        i(M).wrapper
+      ])
+    }, [
+      O("canvas", {
+        ref_key: "canvasRef",
+        ref: d,
+        style: h({
+          width: `${e.size}px`,
+          height: `${e.size}px`
+        })
+      }, null, 4)
+    ], 6));
+  }
+});
+export {
+  V as default
+};

package/lib/components/qrCode/QrCode.vue2.js

@@ -0,0 +1,4 @@
+import f from "./QrCode.vue.js";
+export {
+  f as default
+};

package/lib/components/qrCode/__tests__/QrCode.spec.d.ts

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

package/lib/components/qrCode/index.d.ts

@@ -0,0 +1,2 @@
+export { default as XQrCode } from './QrCode.vue';
+export type { QrCodeProps, QrCodeTheme } from './QrCode.vue';

package/lib/components/qrCode/qrcodegen.d.ts

@@ -0,0 +1,94 @@
+declare namespace qrcodegen {
+    type bit = number;
+    type byte = number;
+    type int = number;
+    export class QrCode {
+        readonly version: int;
+        readonly errorCorrectionLevel: QrCode.Ecc;
+        static encodeText(text: string, ecl: QrCode.Ecc): QrCode;
+        static encodeBinary(data: Readonly<Array<byte>>, ecl: QrCode.Ecc): QrCode;
+        static encodeSegments(segs: Readonly<Array<QrSegment>>, ecl: QrCode.Ecc, minVersion?: int, maxVersion?: int, mask?: int, boostEcl?: boolean): QrCode;
+        readonly size: int;
+        readonly mask: int;
+        private readonly modules;
+        private readonly isFunction;
+        constructor(version: int, errorCorrectionLevel: QrCode.Ecc, dataCodewords: Readonly<Array<byte>>, msk: int);
+        getModule(x: int, y: int): boolean;
+        private drawFunctionPatterns;
+        private drawFormatBits;
+        private drawVersion;
+        private drawFinderPattern;
+        private drawAlignmentPattern;
+        private setFunctionModule;
+        private addEccAndInterleave;
+        private drawCodewords;
+        private applyMask;
+        private getPenaltyScore;
+        private getAlignmentPatternPositions;
+        private static getNumRawDataModules;
+        private static getNumDataCodewords;
+        private static reedSolomonComputeDivisor;
+        private static reedSolomonComputeRemainder;
+        private static reedSolomonMultiply;
+        private finderPenaltyCountPatterns;
+        private finderPenaltyTerminateAndCount;
+        private finderPenaltyAddHistory;
+        static readonly MIN_VERSION: int;
+        static readonly MAX_VERSION: int;
+        private static readonly PENALTY_N1;
+        private static readonly PENALTY_N2;
+        private static readonly PENALTY_N3;
+        private static readonly PENALTY_N4;
+        private static readonly ECC_CODEWORDS_PER_BLOCK;
+        private static readonly NUM_ERROR_CORRECTION_BLOCKS;
+    }
+    export class QrSegment {
+        readonly mode: QrSegment.Mode;
+        readonly numChars: int;
+        private readonly bitData;
+        static makeBytes(data: Readonly<Array<byte>>): QrSegment;
+        static makeNumeric(digits: string): QrSegment;
+        static makeAlphanumeric(text: string): QrSegment;
+        static makeSegments(text: string): Array<QrSegment>;
+        static makeEci(assignVal: int): QrSegment;
+        static isNumeric(text: string): boolean;
+        static isAlphanumeric(text: string): boolean;
+        constructor(mode: QrSegment.Mode, numChars: int, bitData: Array<bit>);
+        getData(): Array<bit>;
+        static getTotalBits(segs: Readonly<Array<QrSegment>>, version: int): number;
+        private static toUtf8ByteArray;
+        private static readonly NUMERIC_REGEX;
+        private static readonly ALPHANUMERIC_REGEX;
+        private static readonly ALPHANUMERIC_CHARSET;
+    }
+    export {};
+}
+declare namespace qrcodegen.QrCode {
+    type int = number;
+    export class Ecc {
+        readonly ordinal: int;
+        readonly formatBits: int;
+        static readonly LOW: Ecc;
+        static readonly MEDIUM: Ecc;
+        static readonly QUARTILE: Ecc;
+        static readonly HIGH: Ecc;
+        private constructor();
+    }
+    export {};
+}
+declare namespace qrcodegen.QrSegment {
+    type int = number;
+    export class Mode {
+        readonly modeBits: int;
+        private readonly numBitsCharCount;
+        static readonly NUMERIC: Mode;
+        static readonly ALPHANUMERIC: Mode;
+        static readonly BYTE: Mode;
+        static readonly KANJI: Mode;
+        static readonly ECI: Mode;
+        private constructor();
+        numCharCountBits(ver: int): int;
+    }
+    export {};
+}
+export default qrcodegen;