@qw-ui/core 0.3.0-next.4 → 0.3.0-next.42

package/dist/swipe-action/swipe-action.d.ts

@@ -0,0 +1,148 @@
+import { type Machine, type Service } from "@zag-js/core";
+import type { NormalizeProps, PropTypes } from "@zag-js/types";
+/** Logical sides: start actions sit at inline-start (left in LTR, right in RTL). */
+export declare const SWIPE_ACTION_SIDES: readonly ["start", "end"];
+export declare const SWIPE_ACTION_COLORS: readonly ["default", "primary", "warning", "danger"];
+/** Stable DOM parts shared by every adapter. */
+export declare const SWIPE_ACTION_PARTS: readonly ["root", "track", "actions", "action", "content", "status"];
+/** Share of an action group's width that commits opening/closing; flicks commit earlier. */
+export declare const SWIPE_ACTION_DISTANCE_RATIO = 0.4;
+export type SwipeActionSide = (typeof SWIPE_ACTION_SIDES)[number];
+export type SwipeActionColor = (typeof SWIPE_ACTION_COLORS)[number];
+/** Scalar action. Rich action content is intentionally not supported so all stacks render the same button. */
+export interface SwipeActionItem {
+    key: string;
+    text: string;
+    color?: SwipeActionColor;
+    disabled?: boolean;
+}
+export interface SwipeActionOpenChangeDetails {
+    open: SwipeActionSide | null;
+}
+export interface SwipeActionActionDetails {
+    key: string;
+    side: SwipeActionSide;
+}
+export interface QwSwipeActionProps {
+    /** Page-unique instance identity; adapters generate one when omitted. */
+    id?: string;
+    /** Actions revealed by swiping toward inline-end (antd-mobile leftActions in LTR). */
+    startActions?: readonly SwipeActionItem[];
+    /** Actions revealed by swiping toward inline-start (antd-mobile rightActions in LTR). */
+    endActions?: readonly SwipeActionItem[];
+    /** Controlled open side; null is controlled closed, undefined enables Core-owned state. */
+    open?: SwipeActionSide | null;
+    defaultOpen?: SwipeActionSide | null;
+    /** Close after an action is activated; defaults to true. */
+    closeOnAction?: boolean;
+    /** Close when the user presses outside the component; defaults to true. */
+    closeOnTouchOutside?: boolean;
+    /** Ignore gestures and disable actions; an open item closes. */
+    disabled?: boolean;
+    /** Visually hidden status while open, with {count}; defaults to 已展开 {count} 个操作. */
+    openedText?: string;
+    onOpenChange?: (details: SwipeActionOpenChangeDetails) => void;
+    onAction?: (details: SwipeActionActionDetails) => void;
+}
+export interface ResolvedSwipeActionItem {
+    key: string;
+    text: string;
+    color: SwipeActionColor;
+    disabled: boolean;
+    side: SwipeActionSide;
+}
+export interface ResolvedSwipeActionState {
+    start: ResolvedSwipeActionItem[];
+    end: ResolvedSwipeActionItem[];
+    closeOnAction: boolean;
+    closeOnTouchOutside: boolean;
+    disabled: boolean;
+    openedText: string;
+}
+/** Invalid/duplicate/empty actions are dropped; at most 8 per side. */
+export declare function resolveSwipeActionState(props?: QwSwipeActionProps): ResolvedSwipeActionState;
+/** A side can only be open when it has actions and the component is enabled. */
+export declare function resolveSwipeActionOpen(state: ResolvedSwipeActionState, open: SwipeActionSide | null | undefined): SwipeActionSide | null;
+/** Resting logical offset: positive reveals start actions. */
+export declare function getSwipeActionRestOffset(open: SwipeActionSide | null, widths: {
+    start: number;
+    end: number;
+}): number;
+/** Logical drag offset from the resting position, clamped to the measured action widths. */
+export declare function clampSwipeActionOffset(offset: number, widths: {
+    start: number;
+    end: number;
+}): number;
+/** Release decision. `delta` is the logical drag distance (positive = toward inline-end). */
+export declare function resolveSwipeActionRelease(input: {
+    open: SwipeActionSide | null;
+    delta: number;
+    velocity: number;
+    widths: {
+        start: number;
+        end: number;
+    };
+}): SwipeActionSide | null;
+export declare function createSwipeActionProps(props?: QwSwipeActionProps): QwSwipeActionProps;
+export interface QwSwipeActionSchema {
+    props: QwSwipeActionProps;
+    context: {
+        open: SwipeActionSide | null;
+        offset: number;
+        dragging: boolean;
+        startWidth: number;
+        endWidth: number;
+    };
+    state: "ready";
+    action: "setOpen" | "dragMove" | "dragEnd" | "measure" | "activate" | "close" | "closeIfDisabled";
+    effect: "trackGestures";
+    event: {
+        type: "OPEN.SET";
+        side: SwipeActionSide | null;
+    } | {
+        type: "CLOSE";
+        restoreFocus?: boolean;
+    } | {
+        type: "DRAG.MOVE";
+        offset: number;
+    } | {
+        type: "DRAG.END";
+        side: SwipeActionSide | null;
+    } | {
+        type: "MEASURE";
+        start: number;
+        end: number;
+    } | {
+        type: "ACTION";
+        key: string;
+        side: SwipeActionSide;
+    };
+}
+export type QwSwipeActionMachine = Machine<QwSwipeActionSchema>;
+export type QwSwipeActionService = Service<QwSwipeActionSchema>;
+/** Core owns gestures, axis locking, outside/close handling, focus-driven opening and cleanup. */
+export declare const swipeActionMachine: QwSwipeActionMachine;
+export interface QwSwipeActionApi<T extends PropTypes = PropTypes> {
+    open: SwipeActionSide | null;
+    dragging: boolean;
+    startActions: ResolvedSwipeActionItem[];
+    endActions: ResolvedSwipeActionItem[];
+    statusText: string;
+    show(side?: SwipeActionSide): void;
+    close(): void;
+    getRootProps(): T["element"];
+    getTrackProps(): T["element"];
+    getActionsProps(side: SwipeActionSide): T["element"];
+    getActionProps(item: ResolvedSwipeActionItem): T["button"];
+    getContentProps(): T["element"];
+    getStatusProps(): T["element"];
+}
+export interface SwipeActionDomEvent {
+    key: string;
+    defaultPrevented: boolean;
+    preventDefault(): void;
+}
+export interface SwipeActionConnectOptions {
+    onKeyDown?(event: SwipeActionDomEvent): void;
+}
+export declare function connectSwipeAction<T extends PropTypes>(service: QwSwipeActionService, normalize: NormalizeProps<T>, options?: SwipeActionConnectOptions): QwSwipeActionApi<T>;

package/dist/swiper/gesture.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Internal pointer-gesture helpers shared by Swiper and SwipeAction.
+ * Pure functions only (no DOM); not exported from any index.
+ */
+/** Movement in CSS pixels before the gesture axis is decided. */
+export declare const GESTURE_SLOP = 8;
+/** Release velocity in px/ms that counts as a flick. */
+export declare const GESTURE_FLICK_VELOCITY = 0.3;
+/** Minimum travel in px for a flick to count. */
+export declare const GESTURE_FLICK_DISTANCE = 12;
+/** Velocity samples older than this window (ms) are ignored. */
+export declare const GESTURE_VELOCITY_WINDOW = 100;
+/** pending: still under the slop; main: the component owns the drag; cross: hand it back to native scrolling. */
+export type GestureAxis = "pending" | "main" | "cross";
+export interface GestureSample {
+    position: number;
+    time: number;
+}
+/** Decide once per gesture which axis dominates. `vertical` means the component's main axis is block. */
+export declare function lockGestureAxis(dx: number, dy: number, vertical?: boolean, slop?: number): GestureAxis;
+/** Keep only the recent window and return the newest-minus-oldest velocity in px/ms. */
+export declare function sampleVelocity(samples: readonly GestureSample[], now: number, window?: number): number;
+/**
+ * Release decision along a signed logical axis (positive = forward).
+ * Commits when travel reaches `max(GESTURE_FLICK_DISTANCE, size * ratio)`, or on a same-direction flick.
+ */
+export declare function resolveSwipeIntent(input: {
+    distance: number;
+    velocity: number;
+    size: number;
+    ratio: number;
+}): -1 | 0 | 1;

package/dist/swiper/index.d.ts

@@ -0,0 +1 @@
+export * from "./swiper.js";

package/dist/swiper/index.js

@@ -0,0 +1,2 @@
+import { a as SWIPER_MAX_SLIDES, c as clampSwiperIndex, d as getSwiperSlides, f as resolveSwiperDragOffset, h as swiperMachine, i as SWIPER_EDGE_RESISTANCE, l as connectSwiper, m as stepSwiperIndex, n as SWIPER_DIRECTIONS, o as SWIPER_MIN_AUTOPLAY_INTERVAL, p as resolveSwiperState, r as SWIPER_DISTANCE_RATIO, s as SWIPER_PARTS, t as SWIPER_DEFAULT_AUTOPLAY_INTERVAL, u as createSwiperProps } from "../swiper-BKivDkHp.js";
+export { SWIPER_DEFAULT_AUTOPLAY_INTERVAL, SWIPER_DIRECTIONS, SWIPER_DISTANCE_RATIO, SWIPER_EDGE_RESISTANCE, SWIPER_MAX_SLIDES, SWIPER_MIN_AUTOPLAY_INTERVAL, SWIPER_PARTS, clampSwiperIndex, connectSwiper, createSwiperProps, getSwiperSlides, resolveSwiperDragOffset, resolveSwiperState, stepSwiperIndex, swiperMachine };

package/dist/swiper/swiper.d.ts

@@ -0,0 +1,177 @@
+import { type Machine, type Service } from "@zag-js/core";
+import type { NormalizeProps, PropTypes } from "@zag-js/types";
+import { type IconState } from "../icon/index.js";
+import type { PageIndicatorTone, QwPageIndicatorProps } from "../page-indicator/index.js";
+/** Main axis of the slides. */
+export declare const SWIPER_DIRECTIONS: readonly ["horizontal", "vertical"];
+/** Stable DOM parts shared by every adapter. */
+export declare const SWIPER_PARTS: readonly ["root", "viewport", "track", "slide", "prev", "next", "autoplay-toggle", "indicator"];
+/** Slides beyond this count are ignored (keeps labels and indicator bounded). */
+export declare const SWIPER_MAX_SLIDES = 100;
+/** Gesture contract: share of the viewport that commits a page; flicks commit earlier (see gesture.ts). */
+export declare const SWIPER_DISTANCE_RATIO = 0.25;
+/** Drag resistance past a non-loop boundary. */
+export declare const SWIPER_EDGE_RESISTANCE = 0.35;
+export declare const SWIPER_DEFAULT_AUTOPLAY_INTERVAL = 3000;
+export declare const SWIPER_MIN_AUTOPLAY_INTERVAL = 1000;
+export type SwiperDirection = (typeof SWIPER_DIRECTIONS)[number];
+/** Requested 0-based slide; controlled owners accept by updating `index`. */
+export interface SwiperIndexChangeDetails {
+    index: number;
+}
+/** Scalar, SSR-safe contract. Slide content stays caller-owned; adapters pass the slide count. */
+export interface QwSwiperProps {
+    /** Page-unique instance identity; adapters generate one when omitted. */
+    id?: string;
+    /** Number of slides rendered by the adapter (children / slots / slide channels). */
+    count?: number;
+    /** Controlled 0-based slide. Undefined enables Core-owned state. */
+    index?: number;
+    /** Initial Core-owned slide; defaults to 0. */
+    defaultIndex?: number;
+    /** Wrap from the last slide to the first (and back). Off by default. */
+    loop?: boolean;
+    direction?: SwiperDirection;
+    /** Pointer/touch dragging; defaults to true. Keyboard and buttons keep working when false. */
+    allowTouchMove?: boolean;
+    /** Carousel name; defaults to 轮播. */
+    label?: string;
+    /** Slide name with {page}/{total}; defaults to 第 {page} 张，共 {total} 张. */
+    slideLabelTemplate?: string;
+    /** Render the shared PageIndicator; defaults to true. */
+    indicator?: boolean;
+    indicatorTone?: PageIndicatorTone;
+    /** Render previous/next buttons (recommended when screen-reader users must browse slides). */
+    navigation?: boolean;
+    prevLabel?: string;
+    nextLabel?: string;
+    /** Rotate automatically; pauses on hover/focus/drag, starts stopped under reduced motion, with a stop/start button. */
+    autoplay?: boolean;
+    /** Milliseconds between rotations; defaults to 3000, minimum 1000. */
+    autoplayInterval?: number;
+    pauseLabel?: string;
+    playLabel?: string;
+    onIndexChange?: (details: SwiperIndexChangeDetails) => void;
+}
+export interface ResolvedSwiperState {
+    count: number;
+    loop: boolean;
+    direction: SwiperDirection;
+    allowTouchMove: boolean;
+    label: string;
+    slideLabelTemplate: string;
+    indicator: boolean;
+    indicatorTone: PageIndicatorTone;
+    navigation: boolean;
+    prevLabel: string;
+    nextLabel: string;
+    autoplay: boolean;
+    autoplayInterval: number;
+    pauseLabel: string;
+    playLabel: string;
+}
+export interface SwiperSlide {
+    index: number;
+    key: string;
+    label: string;
+    current: boolean;
+}
+export declare function resolveSwiperState(props?: QwSwiperProps): ResolvedSwiperState;
+/** Any requested index rendered against the live count: empty is 0, otherwise clamped. */
+export declare function clampSwiperIndex(state: Pick<ResolvedSwiperState, "count">, index: number): number;
+/** One step forward/back. Loop wraps; otherwise the boundary holds (returns the same index). */
+export declare function stepSwiperIndex(state: Pick<ResolvedSwiperState, "count" | "loop">, current: number, delta: -1 | 1): number;
+/** Physical drag offset with resistance when pulling past a non-loop boundary. `progress` is the logical forward distance. */
+export declare function resolveSwiperDragOffset(state: Pick<ResolvedSwiperState, "count" | "loop">, current: number, delta: number, progress: number): number;
+export declare function getSwiperSlides(state: ResolvedSwiperState, current: number): SwiperSlide[];
+export declare function createSwiperProps(props?: QwSwiperProps): QwSwiperProps;
+export interface QwSwiperSchema {
+    props: QwSwiperProps;
+    context: {
+        index: number;
+        offset: number;
+        dragging: boolean;
+        size: number;
+        rtl: boolean;
+        hovered: boolean;
+        focused: boolean;
+        stopped: boolean;
+    };
+    refs: {
+        reschedule: (() => void) | null;
+    };
+    state: "ready";
+    action: "setIndex" | "step" | "dragMove" | "dragEnd" | "measure" | "setHovered" | "setFocused" | "toggleAutoplay" | "setStopped" | "tick" | "clampIndex" | "reschedule";
+    effect: "trackGestures" | "autoplay";
+    event: {
+        type: "INDEX.SET";
+        value: number;
+    } | {
+        type: "STEP";
+        delta: -1 | 1;
+    } | {
+        type: "DRAG.MOVE";
+        offset: number;
+    } | {
+        type: "DRAG.END";
+        intent: -1 | 0 | 1;
+    } | {
+        type: "MEASURE";
+        size: number;
+        rtl: boolean;
+    } | {
+        type: "HOVER.SET";
+        value: boolean;
+    } | {
+        type: "FOCUS.SET";
+        value: boolean;
+    } | {
+        type: "AUTOPLAY.TOGGLE";
+    } | {
+        type: "AUTOPLAY.STOP";
+    } | {
+        type: "AUTOPLAY.TICK";
+    };
+}
+export type QwSwiperMachine = Machine<QwSwiperSchema>;
+export type QwSwiperService = Service<QwSwiperSchema>;
+/** Core owns paging, gestures, measurement, autoplay timers and cleanup; adapters only render parts. */
+export declare const swiperMachine: QwSwiperMachine;
+export interface QwSwiperApi<T extends PropTypes = PropTypes> {
+    index: number;
+    count: number;
+    dragging: boolean;
+    direction: SwiperDirection;
+    /** Autoplay is armed (not stopped by the user). */
+    autoplaying: boolean;
+    slides: SwiperSlide[];
+    /** Ready-made PageIndicator input; adapters spread it on the shared PageIndicator component/element. */
+    indicatorProps: QwPageIndicatorProps;
+    autoplayToggleLabel: string;
+    swipeTo(index: number): void;
+    swipeNext(): void;
+    swipePrev(): void;
+    toggleAutoplay(): void;
+    getRootProps(): T["element"];
+    getViewportProps(): T["element"];
+    getTrackProps(): T["element"];
+    getSlideProps(slide: SwiperSlide): T["element"];
+    getPrevProps(): T["button"];
+    getNextProps(): T["button"];
+    getAutoplayToggleProps(): T["button"];
+    getIndicatorProps(): T["element"];
+    getPrevIconState(): IconState;
+    getNextIconState(): IconState;
+    getAutoplayIconState(): IconState;
+}
+export interface SwiperDomEvent {
+    key: string;
+    target: unknown;
+    currentTarget: unknown;
+    defaultPrevented: boolean;
+    preventDefault(): void;
+}
+export interface SwiperConnectOptions {
+    onKeyDown?(event: SwiperDomEvent): void;
+}
+export declare function connectSwiper<T extends PropTypes>(service: QwSwiperService, normalize: NormalizeProps<T>, options?: SwiperConnectOptions): QwSwiperApi<T>;