@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/pull-to-refresh/index.d.ts

@@ -0,0 +1,106 @@
+export type * from './interface';
+declare const PullToRefresh: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").PullToRefreshProps> & Readonly<{
+        onChange?: ((info: {
+            status: import("./interface").PullToRefreshStatus;
+            distance: number;
+        }) => any) | undefined;
+        "onUpdate:refreshing"?: ((refreshing: boolean) => any) | undefined;
+        onRefresh?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        change: (info: {
+            status: import("./interface").PullToRefreshStatus;
+            distance: number;
+        }) => any;
+        "update:refreshing": (refreshing: boolean) => any;
+        refresh: () => any;
+    }, import("vue").PublicProps, {
+        disabled: boolean;
+        duration: number;
+        refreshing: boolean;
+        pullingText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+        canReleaseText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+        refreshingText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+        completeText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+        completeDelay: number;
+        headHeight: import("../_util/type.ts").Numeric;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").PullToRefreshProps> & Readonly<{
+        onChange?: ((info: {
+            status: import("./interface").PullToRefreshStatus;
+            distance: number;
+        }) => any) | undefined;
+        "onUpdate:refreshing"?: ((refreshing: boolean) => any) | undefined;
+        onRefresh?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+        duration: number;
+        refreshing: boolean;
+        pullingText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+        canReleaseText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+        refreshingText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+        completeText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+        completeDelay: number;
+        headHeight: import("../_util/type.ts").Numeric;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").PullToRefreshProps> & Readonly<{
+    onChange?: ((info: {
+        status: import("./interface").PullToRefreshStatus;
+        distance: number;
+    }) => any) | undefined;
+    "onUpdate:refreshing"?: ((refreshing: boolean) => any) | undefined;
+    onRefresh?: (() => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (info: {
+        status: import("./interface").PullToRefreshStatus;
+        distance: number;
+    }) => any;
+    "update:refreshing": (refreshing: boolean) => any;
+    refresh: () => any;
+}, string, {
+    disabled: boolean;
+    duration: number;
+    refreshing: boolean;
+    pullingText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+    canReleaseText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+    refreshingText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+    completeText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PullToRefreshRenderInfo) => import("vue").VNodeChild) | null;
+    completeDelay: number;
+    headHeight: import("../_util/type.ts").Numeric;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").PullToRefreshSlots;
+}), object>;
+export default PullToRefresh;

package/dist/pull-to-refresh/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import PullToRefresh_default from "./PullToRefresh.js";
+// src/pull-to-refresh/index.ts
+var PullToRefresh = withInstall(PullToRefresh_default, "AmPullToRefresh");
+export { PullToRefresh as default };

package/dist/pull-to-refresh/interface.d.ts

@@ -0,0 +1,57 @@
+import type { CSSProperties } from 'vue';
+import type { Numeric, RenderNodeFn } from '../_util/type';
+export type PullToRefreshStatus = 'normal' | 'pulling' | 'canRelease' | 'refreshing' | 'complete';
+export interface PullToRefreshRenderInfo {
+    /** current pull distance in px */
+    distance: number;
+}
+export interface PullToRefreshSemanticClassNames {
+    root?: string;
+    head?: string;
+    content?: string;
+}
+export interface PullToRefreshSemanticStyles {
+    root?: CSSProperties;
+    head?: CSSProperties;
+    content?: CSSProperties;
+}
+export interface PullToRefreshProps {
+    /** Whether it is refreshing. Supports `v-model:refreshing`; set it back to `false` when the data arrived. */
+    refreshing?: boolean;
+    /** Text while pulling. The `pulling` slot wins. */
+    pullingText?: RenderNodeFn<PullToRefreshRenderInfo>;
+    /** Text when releasing triggers the refresh. The `canRelease` slot wins. */
+    canReleaseText?: RenderNodeFn<PullToRefreshRenderInfo>;
+    /** Text while refreshing. The `refreshing` slot wins. */
+    refreshingText?: RenderNodeFn<PullToRefreshRenderInfo>;
+    /** Text after the refresh finished. The `complete` slot wins. */
+    completeText?: RenderNodeFn<PullToRefreshRenderInfo>;
+    /** How long the complete text stays in ms, `0` skips it */
+    completeDelay?: number;
+    /** Height of the head area */
+    headHeight?: Numeric;
+    /** Pull distance that triggers the refresh, defaults to `headHeight` */
+    threshold?: Numeric;
+    /** Duration of the rebound animation in ms */
+    duration?: number;
+    disabled?: boolean;
+    rootClass?: string;
+    classes?: PullToRefreshSemanticClassNames;
+    styles?: PullToRefreshSemanticStyles;
+}
+export interface PullToRefreshEmits {
+    'update:refreshing': [refreshing: boolean];
+    /** The user released past the threshold */
+    'refresh': [];
+    'change': [info: {
+        status: PullToRefreshStatus;
+        distance: number;
+    }];
+}
+export interface PullToRefreshSlots {
+    default?: () => any;
+    pulling?: (info: PullToRefreshRenderInfo) => any;
+    canRelease?: (info: PullToRefreshRenderInfo) => any;
+    refreshing?: (info: PullToRefreshRenderInfo) => any;
+    complete?: (info: PullToRefreshRenderInfo) => any;
+}

package/dist/pull-to-refresh/style/index.css

@@ -0,0 +1,52 @@
+.am-pull-to-refresh {
+  --am-pull-to-refresh-head-color: var(--am-color-text-description);
+  --am-pull-to-refresh-head-font-size: var(--am-font-size);
+  --am-pull-to-refresh-icon-size: 16px;
+
+  position: relative;
+  box-sizing: border-box;
+  overflow: hidden;
+  color: var(--am-color-text);
+  font-size: var(--am-font-size);
+  font-family: var(--am-font-family);
+  line-height: var(--am-line-height);
+  user-select: none;
+  /* the page keeps scrolling vertically, the browser pull-to-refresh is replaced */
+  overscroll-behavior-y: contain;
+}
+
+.am-pull-to-refresh-track {
+  position: relative;
+  height: 100%;
+  transition-timing-function: var(--am-motion-ease-out);
+  transition-property: transform;
+}
+
+.am-pull-to-refresh-head {
+  position: absolute;
+  left: 0;
+  display: flex;
+  gap: var(--am-margin-xs);
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  width: 100%;
+  overflow: hidden;
+  color: var(--am-pull-to-refresh-head-color);
+  font-size: var(--am-pull-to-refresh-head-font-size);
+  transform: translateY(-100%);
+}
+
+.am-pull-to-refresh-icon {
+  font-size: var(--am-pull-to-refresh-icon-size);
+}
+
+.am-pull-to-refresh-content {
+  box-sizing: border-box;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .am-pull-to-refresh-track {
+    transition-duration: 0.01s !important;
+  }
+}

package/dist/qrcode/QRCode.js

@@ -0,0 +1,4 @@
+import QRCode_vue_vue_type_script_setup_true_lang_default from "./QRCode.vue_vue_type_script_setup_true_lang.js";
+// src/qrcode/QRCode.vue
+var QRCode_default = QRCode_vue_vue_type_script_setup_true_lang_default;
+export { QRCode_default as default };

package/dist/qrcode/QRCode.vue.d.ts

@@ -0,0 +1,31 @@
+import type { QRCodeProps, QRCodeSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = QRCodeSlots;
+declare function toDataURL(type?: string, quality?: number): string | undefined;
+declare const __VLS_base: import("vue").DefineComponent<QRCodeProps, {
+    /** The root element */
+    nativeElement: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    toDataURL: typeof toDataURL;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    refresh: () => any;
+}, string, import("vue").PublicProps, Readonly<QRCodeProps> & Readonly<{
+    onRefresh?: (() => any) | undefined;
+}>, {
+    type: import("./interface").QRCodeType;
+    bordered: boolean;
+    size: string | number;
+    status: import("./interface").QRCodeStatus;
+    iconSize: number | import("./interface").QRCodeIconSize;
+    boostLevel: boolean;
+    marginSize: number;
+    errorLevel: import("./interface").QRCodeErrorLevelType;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/qrcode/QRCode.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,351 @@
+import Spinner_default from "../_base/Spinner.js";
+import { addUnit, isNumeric } from "../_util/index.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { mergeAttrsStyle } from "../_util/vnode.js";
+import Button from "../button/index.js";
+import { useConfig } from "../config-provider/context.js";
+import { useLocale } from "../locale/index.js";
+import { encodeQRCode, excavateModules, generatePath } from "./encoder.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, getCurrentInstance, guardReactiveProps, mergeProps, nextTick, normalizeClass, normalizeProps, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderSlot, shallowRef, toDisplayString, unref, watch, withCtx } from "vue";
+import { ReloadOutlined } from "@antdv-next/icons";
+// src/qrcode/QRCode.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "am-qrcode-expired" };
+var _hoisted_2 = {
+	key: 3,
+	class: "am-qrcode-scanned"
+};
+var _hoisted_3 = ["title", "aria-label"];
+var _hoisted_4 = ["src"];
+var _hoisted_5 = ["viewBox", "aria-label"];
+var _hoisted_6 = { key: 0 };
+var _hoisted_7 = ["fill", "d"];
+var _hoisted_8 = ["fill", "d"];
+var _hoisted_9 = [
+	"href",
+	"x",
+	"y",
+	"width",
+	"height"
+];
+var DEFAULT_SIZE = 160;
+/** Icon position in module units, centered, with the modules below it removed */
+var QRCode_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmQrcode",
+	inheritAttrs: false,
+	__name: "QRCode",
+	props: {
+		value: {},
+		type: { default: "canvas" },
+		icon: {},
+		iconSize: { default: 40 },
+		size: { default: 160 },
+		color: {},
+		bgColor: {},
+		marginSize: { default: 0 },
+		bordered: {
+			type: Boolean,
+			default: true
+		},
+		errorLevel: { default: "M" },
+		boostLevel: {
+			type: Boolean,
+			default: true
+		},
+		status: { default: "active" },
+		statusRender: {},
+		title: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["refresh"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const TRANSPARENT_REGEX = /^(?:transparent|rgba\(\s*0,\s*0,\s*0,\s*0\s*\))$/;
+		const instance = getCurrentInstance();
+		const config = useConfig();
+		const locale = useLocale("QRCode");
+		const rootRef = ref();
+		const canvasRef = ref();
+		const svgRef = ref();
+		const imageRef = ref();
+		/** Rendered width of the QR code (css px), measured after mount */
+		const measuredSize = ref(0);
+		const loadedIcon = shallowRef();
+		const hasValue = computed(() => Array.isArray(props.value) ? props.value.some(Boolean) : !!props.value);
+		const matrix = computed(() => {
+			if (!hasValue.value) return null;
+			try {
+				return encodeQRCode(props.value, {
+					errorLevel: props.errorLevel,
+					boostLevel: props.boostLevel
+				});
+			} catch (error) {
+				console.error(error);
+				return null;
+			}
+		});
+		const margin = computed(() => Math.max(Math.floor(Number(props.marginSize)) || 0, 0));
+		const numCells = computed(() => matrix.value ? matrix.value.size + margin.value * 2 : 0);
+		/** Width the icon size (px) refers to */
+		const contentSize = computed(() => {
+			if (measuredSize.value > 0) return measuredSize.value;
+			return isNumeric(props.size) && Number(props.size) > 0 ? Number(props.size) : DEFAULT_SIZE;
+		});
+		const iconBox = computed(() => {
+			const code = matrix.value;
+			if (!code || !props.icon) return null;
+			const { iconSize } = props;
+			const width = typeof iconSize === "number" ? iconSize : iconSize?.width ?? 40;
+			const height = typeof iconSize === "number" ? iconSize : iconSize?.height ?? 40;
+			const scale = numCells.value / contentSize.value;
+			const w = width * scale;
+			const h = height * scale;
+			const x = code.size / 2 - w / 2;
+			const y = code.size / 2 - h / 2;
+			const floorX = Math.floor(x);
+			const floorY = Math.floor(y);
+			return {
+				x,
+				y,
+				w,
+				h,
+				excavation: {
+					x: floorX,
+					y: floorY,
+					w: Math.ceil(w + x - floorX),
+					h: Math.ceil(h + y - floorY)
+				}
+			};
+		});
+		const iconReady = computed(() => !!props.icon && loadedIcon.value === props.icon);
+		const cells = computed(() => {
+			const code = matrix.value;
+			if (!code) return [];
+			return iconBox.value && (props.type === "svg" || iconReady.value) ? excavateModules(code.modules, iconBox.value.excavation) : code.modules;
+		});
+		const svgPath = computed(() => props.type === "svg" ? generatePath(cells.value, margin.value) : "");
+		function resolveColors() {
+			const root = rootRef.value;
+			const computedStyle = root && typeof getComputedStyle === "function" ? getComputedStyle(root) : void 0;
+			const background = props.bgColor || computedStyle?.backgroundColor || "";
+			return {
+				color: props.color || computedStyle?.color || "#000",
+				background: TRANSPARENT_REGEX.test(background) ? "" : background
+			};
+		}
+		function measure() {
+			const width = (props.type === "canvas" ? canvasRef.value : svgRef.value)?.clientWidth ?? 0;
+			if (width > 0) measuredSize.value = width;
+		}
+		function draw() {
+			const canvas = canvasRef.value;
+			const count = numCells.value;
+			if (!canvas || !count || props.type !== "canvas") return;
+			const ctx = canvas.getContext("2d");
+			if (!ctx) return;
+			const ratio = window.devicePixelRatio || 1;
+			const pixels = Math.max(Math.round(contentSize.value * ratio), count);
+			canvas.width = canvas.height = pixels;
+			const { color, background } = resolveColors();
+			ctx.clearRect(0, 0, pixels, pixels);
+			if (background) {
+				ctx.fillStyle = background;
+				ctx.fillRect(0, 0, pixels, pixels);
+			}
+			const scale = pixels / count;
+			const edge = (index) => Math.round(index * scale);
+			const offset = margin.value;
+			ctx.fillStyle = color;
+			cells.value.forEach((row, y) => {
+				const top = edge(y + offset);
+				const height = edge(y + offset + 1) - top;
+				let start = -1;
+				for (let x = 0; x <= row.length; x++) {
+					const dark = x < row.length && row[x];
+					if (dark && start < 0) start = x;
+					else if (!dark && start >= 0) {
+						const left = edge(start + offset);
+						ctx.fillRect(left, top, edge(x + offset) - left, height);
+						start = -1;
+					}
+				}
+			});
+			const image = imageRef.value;
+			const box = iconBox.value;
+			if (box && image && iconReady.value && image.naturalWidth !== 0 && image.naturalHeight !== 0) ctx.drawImage(image, (box.x + offset) * scale, (box.y + offset) * scale, box.w * scale, box.h * scale);
+		}
+		async function render() {
+			await nextTick();
+			measure();
+			draw();
+		}
+		function handleIconLoad() {
+			loadedIcon.value = props.icon;
+		}
+		let resizeObserver;
+		function observe() {
+			resizeObserver?.disconnect();
+			if (typeof ResizeObserver === "undefined" || !rootRef.value) return;
+			resizeObserver = new ResizeObserver(() => {
+				const before = measuredSize.value;
+				measure();
+				if (measuredSize.value !== before) draw();
+			});
+			resizeObserver.observe(rootRef.value);
+		}
+		onMounted(() => {
+			observe();
+			render();
+		});
+		onBeforeUnmount(() => {
+			resizeObserver?.disconnect();
+			resizeObserver = void 0;
+		});
+		watch(hasValue, () => nextTick(observe), { flush: "post" });
+		watch(() => [
+			cells.value,
+			numCells.value,
+			iconBox.value,
+			iconReady.value,
+			props.type,
+			props.size,
+			props.color,
+			props.bgColor,
+			props.bordered,
+			config.theme.value
+		], render, { flush: "post" });
+		function handleRefresh() {
+			emit("refresh");
+		}
+		function hasRefreshListener() {
+			return !!instance?.vnode.props?.onRefresh;
+		}
+		function getStatusInfo() {
+			return {
+				status: props.status,
+				locale: locale.value,
+				onRefresh: hasRefreshListener() ? handleRefresh : void 0
+			};
+		}
+		const classNames = computed(() => [
+			"am-qrcode",
+			{
+				"am-qrcode-borderless": !props.bordered,
+				[`am-qrcode-status-${props.status}`]: props.status !== "active"
+			},
+			props.rootClass,
+			props.classes?.root
+		]);
+		const rootStyle = computed(() => {
+			return {
+				width: addUnit(props.size),
+				backgroundColor: props.bgColor,
+				color: props.color,
+				...props.styles?.root
+			};
+		});
+		function toDataURL(type, quality) {
+			if (props.type === "canvas") return canvasRef.value?.toDataURL(type, quality);
+			const svg = svgRef.value;
+			if (!svg) return void 0;
+			const clone = svg.cloneNode(true);
+			const { color, background } = resolveColors();
+			const size = String(contentSize.value);
+			clone.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+			clone.setAttribute("width", size);
+			clone.setAttribute("height", size);
+			clone.querySelector(".am-qrcode-svg-bg")?.setAttribute("fill", background || "none");
+			clone.querySelector(".am-qrcode-svg-fg")?.setAttribute("fill", color);
+			const markup = new XMLSerializer().serializeToString(clone);
+			return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(markup)}`;
+		}
+		__expose({
+			/** The root element */
+			nativeElement: rootRef,
+			toDataURL
+		});
+		return (_ctx, _cache) => {
+			return matrix.value ? (openBlock(), createElementBlock("div", mergeProps({ key: 0 }, _ctx.$attrs, {
+				ref_key: "rootRef",
+				ref: rootRef,
+				class: classNames.value,
+				style: unref(mergeAttrsStyle)(rootStyle.value, _ctx.$attrs.style)
+			}), [__props.status !== "active" ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: normalizeClass(["am-qrcode-cover", __props.classes?.cover]),
+				style: normalizeStyle(__props.styles?.cover)
+			}, [renderSlot(_ctx.$slots, "statusRender", normalizeProps(guardReactiveProps(getStatusInfo())), () => [__props.statusRender ? (openBlock(), createBlock(unref(RenderNode_default), {
+				key: 0,
+				node: __props.statusRender,
+				params: getStatusInfo()
+			}, null, 8, ["node", "params"])) : __props.status === "loading" ? (openBlock(), createBlock(unref(Spinner_default), {
+				key: 1,
+				class: "am-qrcode-loading"
+			})) : __props.status === "expired" ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [createElementVNode("p", _hoisted_1, toDisplayString(unref(locale).expired), 1), hasRefreshListener() ? (openBlock(), createBlock(unref(Button), {
+				key: 0,
+				class: "am-qrcode-refresh",
+				type: "link",
+				size: "small",
+				onClick: handleRefresh
+			}, {
+				icon: withCtx(() => [createVNode(unref(ReloadOutlined))]),
+				default: withCtx(() => [createTextVNode(" " + toDisplayString(unref(locale).refresh), 1)]),
+				_: 1
+			})) : createCommentVNode("", true)], 64)) : (openBlock(), createElementBlock("p", _hoisted_2, toDisplayString(unref(locale).scanned), 1))])], 6)) : createCommentVNode("", true), __props.type === "canvas" ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [createElementVNode("canvas", {
+				ref_key: "canvasRef",
+				ref: canvasRef,
+				class: "am-qrcode-canvas",
+				role: "img",
+				title: __props.title,
+				"aria-label": __props.title
+			}, null, 8, _hoisted_3), __props.icon ? (openBlock(), createElementBlock("img", {
+				ref_key: "imageRef",
+				ref: imageRef,
+				key: __props.icon,
+				class: "am-qrcode-icon",
+				src: __props.icon,
+				crossorigin: "anonymous",
+				alt: "",
+				"aria-hidden": "true",
+				onLoad: handleIconLoad
+			}, null, 40, _hoisted_4)) : createCommentVNode("", true)], 64)) : (openBlock(), createElementBlock("svg", {
+				key: 2,
+				ref_key: "svgRef",
+				ref: svgRef,
+				class: "am-qrcode-svg",
+				viewBox: `0 0 ${numCells.value} ${numCells.value}`,
+				role: "img",
+				"aria-label": __props.title
+			}, [
+				__props.title ? (openBlock(), createElementBlock("title", _hoisted_6, toDisplayString(__props.title), 1)) : createCommentVNode("", true),
+				createElementVNode("path", {
+					class: "am-qrcode-svg-bg",
+					fill: __props.bgColor || "none",
+					d: `M0,0h${numCells.value}v${numCells.value}H0z`,
+					"shape-rendering": "crispEdges"
+				}, null, 8, _hoisted_7),
+				createElementVNode("path", {
+					class: "am-qrcode-svg-fg",
+					fill: __props.color || "currentColor",
+					d: svgPath.value,
+					"shape-rendering": "crispEdges"
+				}, null, 8, _hoisted_8),
+				__props.icon && iconBox.value ? (openBlock(), createElementBlock("image", {
+					key: 1,
+					href: __props.icon,
+					x: iconBox.value.x + margin.value,
+					y: iconBox.value.y + margin.value,
+					width: iconBox.value.w,
+					height: iconBox.value.h,
+					preserveAspectRatio: "none",
+					crossorigin: "anonymous"
+				}, null, 8, _hoisted_9)) : createCommentVNode("", true)
+			], 8, _hoisted_5))], 16)) : createCommentVNode("", true);
+		};
+	}
+});
+export { QRCode_vue_vue_type_script_setup_true_lang_default as default };

package/dist/qrcode/encoder.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Dependency-free QR Code (Model 2) encoder: versions 1-40, error correction levels L / M / Q / H,
+ * numeric / alphanumeric / byte (UTF-8) segments, Reed-Solomon error correction and
+ * automatic mask selection by penalty score (ISO/IEC 18004).
+ */
+export type QRCodeErrorLevel = 'L' | 'M' | 'Q' | 'H';
+export interface QRCodeEncodeOptions {
+    /** Minimum error correction level, default `M` */
+    errorLevel?: QRCodeErrorLevel;
+    /** Raise the error correction level when it does not increase the version, default `true` */
+    boostLevel?: boolean;
+    /** Smallest version to use (1-40), default `1` */
+    minVersion?: number;
+    /** Largest version to use (1-40), default `40` */
+    maxVersion?: number;
+    /** Force a mask pattern (0-7), by default the one with the lowest penalty is picked */
+    mask?: number;
+}
+export interface QRCodeMatrix {
+    /** 1-40 */
+    version: number;
+    /** Modules per side: `version * 4 + 17` */
+    size: number;
+    /** The level really used (may be higher than requested with `boostLevel`) */
+    errorLevel: QRCodeErrorLevel;
+    /** The applied mask pattern, 0-7 */
+    mask: number;
+    /** `modules[y][x]`, `true` is a dark module */
+    modules: boolean[][];
+}
+/** UTF-8 bytes of a string (lone surrogates become U+FFFD) */
+export declare function toUtf8Bytes(text: string): number[];
+/**
+ * Encodes a text (or several texts, each one as its own optimally typed segment) into a QR Code matrix.
+ * Throws a `RangeError` when the data does not fit in version 40 (or `maxVersion`) at the requested level.
+ */
+export declare function encodeQRCode(value: string | string[], options?: QRCodeEncodeOptions): QRCodeMatrix;
+export interface QRCodeExcavation {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Clears the modules covered by the icon */
+export declare function excavateModules(modules: boolean[][], excavation: QRCodeExcavation): boolean[][];
+/** One SVG path (horizontal runs merged) for all dark modules, in module units */
+export declare function generatePath(modules: boolean[][], margin?: number): string;