@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/hooks/request.d.ts

@@ -0,0 +1,79 @@
+import type { Ref, ShallowRef } from 'vue';
+export interface UseRequestOptions<T, P extends any[]> {
+    /** do not run on creation; call `run()` yourself */
+    manual?: boolean;
+    defaultParams?: P;
+    initialData?: T;
+    /** only show `loading` after this many ms, to avoid flicker on fast responses */
+    loadingDelay?: number;
+    onSuccess?: (data: T, params: P) => void;
+    onError?: (error: unknown, params: P) => void;
+    onFinally?: (params: P) => void;
+}
+export interface UseRequestReturn<T, P extends any[]> {
+    data: ShallowRef<T | undefined>;
+    error: ShallowRef<unknown>;
+    loading: Ref<boolean>;
+    params: ShallowRef<P | undefined>;
+    /** run and swallow errors (they land in `error` / `onError`) */
+    run: (...params: P) => void;
+    /** run and get the promise */
+    runAsync: (...params: P) => Promise<T>;
+    /** run again with the last params */
+    refresh: () => void;
+    /** set `data` without requesting */
+    mutate: (data: T | undefined | ((prev: T | undefined) => T | undefined)) => void;
+    /** ignore the response of the in-flight request */
+    cancel: () => void;
+}
+/**
+ * Async state for one request: `data`, `loading`, `error`, with race protection
+ * (only the latest call may update the state).
+ *
+ * ```ts
+ * const { data, loading, run } = useRequest(fetchUser, { defaultParams: [id] })
+ * ```
+ */
+export declare function useRequest<T, P extends any[] = []>(service: (...params: P) => Promise<T>, options?: UseRequestOptions<T, P>): UseRequestReturn<T, P>;
+export interface LoadMoreResult<T> {
+    list: T[];
+    /** total count, when the server knows it */
+    total?: number;
+    /** explicit flag; otherwise derived from `total` or an empty page */
+    hasMore?: boolean;
+}
+export interface UseLoadMoreOptions<T> {
+    /** first page number. Default `1`. */
+    initialPage?: number;
+    pageSize?: number;
+    manual?: boolean;
+    onSuccess?: (result: LoadMoreResult<T>, page: number) => void;
+    onError?: (error: unknown, page: number) => void;
+}
+/**
+ * Paged list state made for `<am-infinite-scroll>` + `<am-pull-to-refresh>`:
+ *
+ * ```vue
+ * <am-pull-to-refresh v-model:refreshing="refreshing" @refresh="refresh">
+ *   <am-infinite-scroll v-model:loading="loading" v-model:error="error" :finished="finished" @load="loadMore">
+ *     <am-list-item v-for="item in list" :key="item.id" :title="item.name" />
+ *   </am-infinite-scroll>
+ * </am-pull-to-refresh>
+ * ```
+ */
+export declare function useLoadMore<T>(service: (params: {
+    page: number;
+    pageSize: number;
+}) => Promise<LoadMoreResult<T>>, options?: UseLoadMoreOptions<T>): {
+    list: Ref<T[], T[]>;
+    page: Ref<number, number>;
+    total: Ref<number | undefined, number | undefined>;
+    loading: Ref<boolean, boolean>;
+    refreshing: Ref<boolean, boolean>;
+    error: Ref<boolean, boolean>;
+    finished: Ref<boolean, boolean>;
+    empty: import("vue").ComputedRef<boolean>;
+    loadMore: () => Promise<void>;
+    refresh: () => Promise<void>;
+    reset: () => void;
+};

package/dist/hooks/request.js

@@ -0,0 +1,166 @@
+import { tryOnScopeDispose } from "./shared.js";
+import { computed, ref, shallowRef } from "vue";
+// src/hooks/request.ts
+/**
+* Async state for one request: `data`, `loading`, `error`, with race protection
+* (only the latest call may update the state).
+*
+* ```ts
+* const { data, loading, run } = useRequest(fetchUser, { defaultParams: [id] })
+* ```
+*/
+function useRequest(service, options = {}) {
+	const data = shallowRef(options.initialData);
+	const error = shallowRef();
+	const loading = ref(false);
+	const params = shallowRef();
+	let count = 0;
+	let delayTimer;
+	const clearDelay = () => {
+		if (delayTimer !== void 0) clearTimeout(delayTimer);
+		delayTimer = void 0;
+	};
+	async function runAsync(...args) {
+		const current = ++count;
+		params.value = args;
+		clearDelay();
+		if (options.loadingDelay) delayTimer = setTimeout(() => loading.value = true, options.loadingDelay);
+		else loading.value = true;
+		try {
+			const result = await service(...args);
+			if (current === count) {
+				data.value = result;
+				error.value = void 0;
+				options.onSuccess?.(result, args);
+			}
+			return result;
+		} catch (err) {
+			if (current === count) {
+				error.value = err;
+				options.onError?.(err, args);
+			}
+			throw err;
+		} finally {
+			if (current === count) {
+				clearDelay();
+				loading.value = false;
+				options.onFinally?.(args);
+			}
+		}
+	}
+	const run = (...args) => {
+		runAsync(...args).catch(() => {});
+	};
+	const refresh = () => run(...params.value ?? options.defaultParams ?? []);
+	const cancel = () => {
+		count++;
+		clearDelay();
+		loading.value = false;
+	};
+	const mutate = (next) => {
+		data.value = typeof next === "function" ? next(data.value) : next;
+	};
+	if (!options.manual) run(...options.defaultParams ?? []);
+	tryOnScopeDispose(cancel);
+	return {
+		data,
+		error,
+		loading,
+		params,
+		run,
+		runAsync,
+		refresh,
+		mutate,
+		cancel
+	};
+}
+/**
+* Paged list state made for `<am-infinite-scroll>` + `<am-pull-to-refresh>`:
+*
+* ```vue
+* <am-pull-to-refresh v-model:refreshing="refreshing" @refresh="refresh">
+*   <am-infinite-scroll v-model:loading="loading" v-model:error="error" :finished="finished" @load="loadMore">
+*     <am-list-item v-for="item in list" :key="item.id" :title="item.name" />
+*   </am-infinite-scroll>
+* </am-pull-to-refresh>
+* ```
+*/
+function useLoadMore(service, options = {}) {
+	const { initialPage = 1, pageSize = 20 } = options;
+	const list = ref([]);
+	const page = ref(initialPage - 1);
+	const total = ref();
+	const loading = ref(false);
+	const refreshing = ref(false);
+	const error = ref(false);
+	const finished = ref(false);
+	const empty = computed(() => finished.value && list.value.length === 0);
+	let count = 0;
+	async function request(target, replace) {
+		const current = ++count;
+		error.value = false;
+		try {
+			const result = await service({
+				page: target,
+				pageSize
+			});
+			if (current !== count) return;
+			list.value = replace ? result.list : [...list.value, ...result.list];
+			page.value = target;
+			total.value = result.total;
+			if (result.hasMore !== void 0) finished.value = !result.hasMore;
+			else if (result.total !== void 0) finished.value = list.value.length >= result.total;
+			else finished.value = result.list.length < pageSize;
+			options.onSuccess?.(result, target);
+		} catch (err) {
+			if (current !== count) return;
+			error.value = true;
+			options.onError?.(err, target);
+		} finally {
+			if (current === count) {
+				loading.value = false;
+				refreshing.value = false;
+			}
+		}
+	}
+	/** load the next page (bind to InfiniteScroll `@load`) */
+	function loadMore() {
+		if (finished.value || refreshing.value) return Promise.resolve();
+		loading.value = true;
+		return request(page.value + 1, false);
+	}
+	/** reload from the first page (bind to PullToRefresh `@refresh`) */
+	function refresh() {
+		refreshing.value = true;
+		finished.value = false;
+		return request(initialPage, true);
+	}
+	function reset() {
+		count++;
+		list.value = [];
+		page.value = initialPage - 1;
+		total.value = void 0;
+		loading.value = false;
+		refreshing.value = false;
+		error.value = false;
+		finished.value = false;
+	}
+	if (!options.manual) loadMore();
+	tryOnScopeDispose(() => {
+		count++;
+	});
+	return {
+		list,
+		page,
+		total,
+		loading,
+		refreshing,
+		error,
+		finished,
+		empty,
+		loadMore,
+		refresh,
+		reset
+	};
+}
+export { useLoadMore, useRequest };

package/dist/hooks/shared.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentPublicInstance, MaybeRefOrGetter } from 'vue';
+export type MaybeElement = Element | ComponentPublicInstance | null | undefined;
+export type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRefOrGetter<T>;
+/** Resolves a template ref (element or component instance) to its DOM element. */
+export declare function unrefElement<T extends Element = HTMLElement>(target: MaybeElementRef): T | undefined;
+/** `onScopeDispose` that is a no-op outside an effect scope (plain function calls, tests). */
+export declare function tryOnScopeDispose(fn: () => void): boolean;

package/dist/hooks/shared.js

@@ -0,0 +1,16 @@
+import { getCurrentScope, onScopeDispose, toValue } from "vue";
+// src/hooks/shared.ts
+/** Resolves a template ref (element or component instance) to its DOM element. */
+function unrefElement(target) {
+	const value = toValue(target);
+	return (value?.$el ?? value) || void 0;
+}
+/** `onScopeDispose` that is a no-op outside an effect scope (plain function calls, tests). */
+function tryOnScopeDispose(fn) {
+	if (getCurrentScope()) {
+		onScopeDispose(fn);
+		return true;
+	}
+	return false;
+}
+export { tryOnScopeDispose, unrefElement };

package/dist/hooks/state.d.ts

@@ -0,0 +1,20 @@
+import type { Ref } from 'vue';
+export interface UseBooleanReturn {
+    state: Ref<boolean>;
+    setTrue: () => void;
+    setFalse: () => void;
+    toggle: () => void;
+    set: (value: boolean) => void;
+}
+/** Boolean state with named setters: popups, loading flags ... */
+export declare function useBoolean(defaultValue?: boolean): UseBooleanReturn;
+/**
+ * Toggles between two values (default `false` / `true`).
+ *
+ * ```ts
+ * const [open, toggle] = useToggle()
+ * const [mode, toggleMode] = useToggle('light', 'dark')
+ * ```
+ */
+export declare function useToggle(): [Ref<boolean>, (value?: boolean) => void];
+export declare function useToggle<T, U = T>(defaultValue: T, reverseValue: U): [Ref<T | U>, (value?: T | U) => void];

package/dist/hooks/state.js

@@ -0,0 +1,21 @@
+import { ref } from "vue";
+// src/hooks/state.ts
+/** Boolean state with named setters: popups, loading flags ... */
+function useBoolean(defaultValue = false) {
+	const state = ref(defaultValue);
+	return {
+		state,
+		setTrue: () => state.value = true,
+		setFalse: () => state.value = false,
+		toggle: () => state.value = !state.value,
+		set: (value) => state.value = value
+	};
+}
+function useToggle(defaultValue = false, reverseValue = true) {
+	const state = ref(defaultValue);
+	const toggle = (value) => {
+		state.value = value !== void 0 ? value : state.value === defaultValue ? reverseValue : defaultValue;
+	};
+	return [state, toggle];
+}
+export { useBoolean, useToggle };

package/dist/hooks/timer.d.ts

@@ -0,0 +1,79 @@
+import type { ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
+export interface UseTimerFnOptions {
+    /** start right away. Default `true`. */
+    immediate?: boolean;
+}
+export interface UseTimerFnReturn {
+    isActive: Ref<boolean>;
+    start: () => void;
+    stop: () => void;
+}
+/** `setTimeout` with start / stop controls, cleared on unmount. */
+export declare function useTimeoutFn(fn: () => void, delay: MaybeRefOrGetter<number>, options?: UseTimerFnOptions): UseTimerFnReturn;
+export interface UseIntervalFnOptions extends UseTimerFnOptions {
+    /** call `fn` once when started, before the first interval */
+    immediateCallback?: boolean;
+}
+/** `setInterval` with start / stop controls, cleared on unmount. */
+export declare function useIntervalFn(fn: () => void, interval?: MaybeRefOrGetter<number>, options?: UseIntervalFnOptions): UseTimerFnReturn;
+/** Calls `fn` on every animation frame while active. */
+export declare function useRafFn(fn: (delta: number) => void, options?: UseTimerFnOptions): UseTimerFnReturn;
+export interface CountDownTime {
+    total: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+}
+export interface UseCountDownOptions {
+    /** remaining time in ms */
+    time: number;
+    /** update every frame (millisecond precision) instead of every second */
+    millisecond?: boolean;
+    /** start right away */
+    autoStart?: boolean;
+    onChange?: (current: CountDownTime) => void;
+    onFinish?: () => void;
+}
+export interface UseCountDownReturn {
+    current: ComputedRef<CountDownTime>;
+    isActive: Ref<boolean>;
+    start: () => void;
+    pause: () => void;
+    /** stop and set the remaining time (default: the initial `time`) */
+    reset: (time?: number) => void;
+}
+export declare function parseCountDownTime(time: number): CountDownTime;
+/**
+ * Count-down driven by `requestAnimationFrame` and wall-clock time, so it stays exact
+ * when the tab was in the background (SMS code buttons, flash sales ...).
+ */
+export declare function useCountDown(options: UseCountDownOptions): UseCountDownReturn;
+export interface UseCountToOptions {
+    /** animation time in ms. Default `1000`. */
+    duration?: MaybeRefOrGetter<number | undefined>;
+    /** value the first run starts from. Default `0`. */
+    from?: number;
+    /** maps the progress (0 - 1) to the eased progress. Default: ease-out. */
+    easing?: (progress: number) => number;
+    /** animate towards the initial value on mount. Default `true`. */
+    immediate?: boolean;
+    /** follow the source without animating */
+    disabled?: MaybeRefOrGetter<boolean | undefined>;
+    onFinish?: () => void;
+}
+export interface UseCountToReturn {
+    /** the animated number */
+    current: Ref<number>;
+    isActive: Ref<boolean>;
+    /** replay from `from` (default: the `from` option) to the source value */
+    start: (from?: number) => void;
+    /** jump to the source value */
+    stop: () => void;
+}
+/**
+ * Animates a number towards `source` whenever it changes (statistics, prices, scores ...).
+ * Server-side and before mount `current` is the source value, so SSR output needs no hydration fix.
+ */
+export declare function useCountTo(source: MaybeRefOrGetter<number>, options?: UseCountToOptions): UseCountToReturn;

package/dist/hooks/timer.js

@@ -0,0 +1,215 @@
+import { cancelRaf, inBrowser, raf } from "../_util/index.js";
+import { tryOnScopeDispose } from "./shared.js";
+import { computed, getCurrentInstance, onMounted, ref, toValue, watch } from "vue";
+// src/hooks/timer.ts
+/** `setTimeout` with start / stop controls, cleared on unmount. */
+function useTimeoutFn(fn, delay, options = {}) {
+	const { immediate = true } = options;
+	const isActive = ref(false);
+	let timer;
+	const stop = () => {
+		isActive.value = false;
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+	};
+	const start = () => {
+		stop();
+		isActive.value = true;
+		timer = setTimeout(() => {
+			isActive.value = false;
+			timer = void 0;
+			fn();
+		}, toValue(delay));
+	};
+	if (immediate && inBrowser) start();
+	tryOnScopeDispose(stop);
+	return {
+		isActive,
+		start,
+		stop
+	};
+}
+/** `setInterval` with start / stop controls, cleared on unmount. */
+function useIntervalFn(fn, interval = 1e3, options = {}) {
+	const { immediate = true, immediateCallback = false } = options;
+	const isActive = ref(false);
+	let timer;
+	const stop = () => {
+		isActive.value = false;
+		if (timer !== void 0) clearInterval(timer);
+		timer = void 0;
+	};
+	const start = () => {
+		stop();
+		isActive.value = true;
+		if (immediateCallback) fn();
+		timer = setInterval(fn, toValue(interval));
+	};
+	if (immediate && inBrowser) start();
+	tryOnScopeDispose(stop);
+	return {
+		isActive,
+		start,
+		stop
+	};
+}
+/** Calls `fn` on every animation frame while active. */
+function useRafFn(fn, options = {}) {
+	const { immediate = true } = options;
+	const isActive = ref(false);
+	let id = -1;
+	let previous = 0;
+	const loop = (timestamp) => {
+		if (!isActive.value) return;
+		fn(previous ? timestamp - previous : 0);
+		previous = timestamp;
+		id = raf(loop);
+	};
+	const stop = () => {
+		isActive.value = false;
+		cancelRaf(id);
+		previous = 0;
+	};
+	const start = () => {
+		if (isActive.value || !inBrowser) return;
+		isActive.value = true;
+		id = raf(loop);
+	};
+	if (immediate) start();
+	tryOnScopeDispose(stop);
+	return {
+		isActive,
+		start,
+		stop
+	};
+}
+var SECOND = 1e3;
+var MINUTE = 60 * SECOND;
+var HOUR = 60 * MINUTE;
+var DAY = 24 * HOUR;
+function parseCountDownTime(time) {
+	const total = Math.max(time, 0);
+	return {
+		total,
+		days: Math.floor(total / DAY),
+		hours: Math.floor(total % DAY / HOUR),
+		minutes: Math.floor(total % HOUR / MINUTE),
+		seconds: Math.floor(total % MINUTE / SECOND),
+		milliseconds: Math.floor(total % SECOND)
+	};
+}
+/**
+* Count-down driven by `requestAnimationFrame` and wall-clock time, so it stays exact
+* when the tab was in the background (SMS code buttons, flash sales ...).
+*/
+function useCountDown(options) {
+	const remain = ref(options.time);
+	const isActive = ref(false);
+	const current = computed(() => parseCountDownTime(remain.value));
+	let endTime = 0;
+	let rafId = -1;
+	const setRemain = (value) => {
+		remain.value = Math.max(value, 0);
+		options.onChange?.(current.value);
+		if (remain.value === 0) {
+			pause();
+			options.onFinish?.();
+		}
+	};
+	const tick = () => {
+		rafId = raf(() => {
+			if (!isActive.value) return;
+			const next = Math.max(endTime - Date.now(), 0);
+			if (options.millisecond || Math.floor(next / SECOND) !== Math.floor(remain.value / SECOND) || next === 0) setRemain(next);
+			if (remain.value > 0) tick();
+		});
+	};
+	function pause() {
+		isActive.value = false;
+		cancelRaf(rafId);
+	}
+	const start = () => {
+		if (isActive.value || !inBrowser || remain.value <= 0) return;
+		endTime = Date.now() + remain.value;
+		isActive.value = true;
+		tick();
+	};
+	const reset = (time = options.time) => {
+		pause();
+		remain.value = time;
+	};
+	if (options.autoStart) start();
+	tryOnScopeDispose(pause);
+	return {
+		current,
+		isActive,
+		start,
+		pause,
+		reset
+	};
+}
+var easeOutCubic = (progress) => 1 - (1 - progress) ** 3;
+function prefersReducedMotion() {
+	return inBrowser && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+/**
+* Animates a number towards `source` whenever it changes (statistics, prices, scores ...).
+* Server-side and before mount `current` is the source value, so SSR output needs no hydration fix.
+*/
+function useCountTo(source, options = {}) {
+	const { from: initialFrom = 0, easing = easeOutCubic, immediate = true } = options;
+	const current = ref(toValue(source));
+	const isActive = ref(false);
+	let rafId = -1;
+	const cancel = () => {
+		isActive.value = false;
+		cancelRaf(rafId);
+	};
+	const run = (from, to) => {
+		cancel();
+		if (toValue(options.disabled) || !inBrowser) {
+			current.value = to;
+			return;
+		}
+		const duration = toValue(options.duration) ?? 1e3;
+		if (from === to || duration <= 0 || prefersReducedMotion()) {
+			current.value = to;
+			if (from !== to) options.onFinish?.();
+			return;
+		}
+		const startTime = Date.now();
+		current.value = from;
+		isActive.value = true;
+		const step = () => {
+			if (!isActive.value) return;
+			const progress = Math.min((Date.now() - startTime) / duration, 1);
+			if (progress < 1) {
+				current.value = from + (to - from) * easing(progress);
+				rafId = raf(step);
+				return;
+			}
+			current.value = to;
+			isActive.value = false;
+			options.onFinish?.();
+		};
+		rafId = raf(step);
+	};
+	watch(() => toValue(source), (to) => run(current.value, to));
+	const start = (from = initialFrom) => run(from, toValue(source));
+	const stop = () => {
+		cancel();
+		current.value = toValue(source);
+	};
+	if (immediate) {
+		if (getCurrentInstance()) onMounted(() => start());
+		else start();
+	}
+	tryOnScopeDispose(cancel);
+	return {
+		current,
+		isActive,
+		start,
+		stop
+	};
+}
+export { parseCountDownTime, useCountDown, useCountTo, useIntervalFn, useRafFn, useTimeoutFn };

package/dist/image/Image.js

@@ -0,0 +1,4 @@
+import Image_vue_vue_type_script_setup_true_lang_default from "./Image.vue_vue_type_script_setup_true_lang.js";
+// src/image/Image.vue
+var Image_default = Image_vue_vue_type_script_setup_true_lang_default;
+export { Image_default as default };

package/dist/image/Image.vue.d.ts

@@ -0,0 +1,31 @@
+import type { ImagePreviewConfig, ImageProps, ImageSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = ImageSlots;
+declare const __VLS_base: import("vue").DefineComponent<ImageProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: (event: Event) => any;
+    click: (event: MouseEvent) => any;
+    load: (event: Event) => any;
+    openChange: (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<ImageProps> & Readonly<{
+    onError?: ((event: Event) => any) | undefined;
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onLoad?: ((event: Event) => any) | undefined;
+    onOpenChange?: ((open: boolean) => any) | undefined;
+}>, {
+    round: boolean;
+    placeholder: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    fit: import("./interface").ImageFit;
+    preview: boolean | ImagePreviewConfig;
+    lazy: boolean;
+}, {}, {}, {}, 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;
+    };
+};