@indielayer/ui 1.5.1 → 1.6.0

package/lib/components/popover/Popover.vue.d.ts

@@ -33,16 +33,10 @@ declare const popoverProps: {
     popperShowTriggers: PropType<TriggerEvent[] | ((triggers: Array<PopoverTriggerEvent>) => Array<PopoverTriggerEvent>)>;
     popperHideTriggers: PropType<TriggerEvent[] | ((triggers: Array<PopoverTriggerEvent>) => Array<PopoverTriggerEvent>)>;
     container: {
-        type: (BooleanConstructor | ObjectConstructor | StringConstructor | {
-            new (): Element;
-            prototype: Element;
-        })[];
+        type: (BooleanConstructor | ObjectConstructor | StringConstructor)[];
         default: string;
     };
-    boundary: (StringConstructor | {
-        new (): Element;
-        prototype: Element;
-    })[];
+    boundary: (ObjectConstructor | StringConstructor)[];
     strategy: {
         type: PropType<"absolute" | "fixed">;
         default: string;
@@ -95,16 +89,10 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     popperShowTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
     popperHideTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
     container: {
-        type: (BooleanConstructor | ObjectConstructor | StringConstructor | {
-            new (): Element;
-            prototype: Element;
-        })[];
+        type: (BooleanConstructor | ObjectConstructor | StringConstructor)[];
         default: string;
     };
-    boundary: (StringConstructor | {
-        new (): Element;
-        prototype: Element;
-    })[];
+    boundary: (ObjectConstructor | StringConstructor)[];
     strategy: {
         type: PropType<"absolute" | "fixed">;
         default: string;
@@ -157,16 +145,10 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     popperShowTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
     popperHideTriggers: PropType<TriggerEvent[] | ((triggers: TriggerEvent[]) => TriggerEvent[])>;
     container: {
-        type: (BooleanConstructor | ObjectConstructor | StringConstructor | {
-            new (): Element;
-            prototype: Element;
-        })[];
+        type: (BooleanConstructor | ObjectConstructor | StringConstructor)[];
         default: string;
     };
-    boundary: (StringConstructor | {
-        new (): Element;
-        prototype: Element;
-    })[];
+    boundary: (ObjectConstructor | StringConstructor)[];
     strategy: {
         type: PropType<"absolute" | "fixed">;
         default: string;
@@ -204,7 +186,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     placement: Placement;
     triggers: TriggerEvent[];
     hideArrow: boolean;
-    container: string | boolean | Element | Record<string, any>;
+    container: string | boolean | Record<string, any>;
     strategy: "absolute" | "fixed";
     autoHide: boolean | ((event: Event) => boolean);
     shown: boolean;

package/lib/components/popover/Popover.vue.js

@@ -1,9 +1,9 @@
-import { defineComponent as b, ref as a, openBlock as v, createBlock as S, unref as r, normalizeStyle as B, normalizeClass as T, withCtx as l, renderSlot as d } from "vue";
-import { useTheme as A } from "../../composables/useTheme.js";
-import { Dropdown as $ } from "../../node_modules/.pnpm/floating-vue@5.2.0_vue@3.3.9/node_modules/floating-vue/dist/floating-vue.js";
-const z = {
+import { defineComponent as b, ref as a, openBlock as v, createBlock as S, unref as r, normalizeStyle as T, normalizeClass as A, withCtx as l, renderSlot as d } from "vue";
+import { useTheme as B } from "../../composables/useTheme.js";
+import { Dropdown as $ } from "../../node_modules/.pnpm/floating-vue@5.2.2_vue@3.3.9/node_modules/floating-vue/dist/floating-vue.js";
+const k = {
   placement: ["top", "top-start", "top-end", "bottom", "bottom-start", "bottom-end", "left", "left-start", "left-end", "right", "right-start", "right-end"]
-}, k = {
+}, z = {
   disabled: Boolean,
   positioningDisabled: Boolean,
   placement: {
@@ -30,10 +30,10 @@ const z = {
   popperShowTriggers: [Array, Function],
   popperHideTriggers: [Array, Function],
   container: {
-    type: [String, Object, Element, Boolean],
+    type: [String, Object, Boolean],
     default: "body"
   },
-  boundary: [String, Element],
+  boundary: [String, Object],
   strategy: {
     type: String,
     default: "absolute"
@@ -53,10 +53,10 @@ const z = {
   computeTransformOrigin: Boolean
 }, C = {
   name: "XPopover",
-  validators: z
+  validators: k
 }, R = /* @__PURE__ */ b({
   ...C,
-  props: k,
+  props: z,
   emits: ["show", "hide", "update:shown", "apply-show", "apply-hide", "close-group", "close-directive", "auto-hide", "resize"],
   setup(g, { expose: u }) {
     const m = g, i = a(null);
@@ -73,12 +73,12 @@ const z = {
     }
     const t = a(!1);
     u({ show: s, hide: n, toggle: y, isOpen: t });
-    const { styles: f, classes: p, className: h } = A("Popover", {}, m);
+    const { styles: f, classes: p, className: h } = B("Popover", {}, m);
     return (e, o) => (v(), S(r($), {
       ref_key: "elRef",
       ref: i,
-      style: B(r(f)),
-      class: T([r(h), r(p).wrapper]),
+      style: T(r(f)),
+      class: A([r(h), r(p).wrapper]),
       "positioning-disabled": e.positioningDisabled,
       placement: e.placement,
       disabled: e.disabled,

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;