@hanwenbo/x-taro-ui 0.0.1

package/lib/components/rollingNumber/rollingNumber.js

@@ -0,0 +1,306 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/rollingNumber/rollingNumber.tsx
+var rollingNumber_exports = {};
+__export(rollingNumber_exports, {
+  default: () => rollingNumber_default
+});
+module.exports = __toCommonJS(rollingNumber_exports);
+var import_react = __toESM(require("react"));
+var import_components = require("@tarojs/components");
+var import_theme = require("../../theme");
+var import_utils = require("../../utils");
+var DIGITS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+var FRAME_MS = 32;
+function easeOutCubic(progress) {
+  return 1 - Math.pow(1 - progress, 3);
+}
+function normalizeDigits(digits) {
+  if (!Number.isFinite(digits)) return 2;
+  return Math.max(1, Math.floor(digits ?? 2));
+}
+function toDigitString(value, digits) {
+  const maxValue = Math.pow(10, Math.min(digits, 15)) - 1;
+  return Math.max(0, Math.min(maxValue, Math.floor(value))).toString().padStart(digits, "0").slice(-digits);
+}
+var DigitReel = (0, import_react.forwardRef)(
+  ({
+    index,
+    cellHeight,
+    reelWidth,
+    fontSize,
+    color,
+    fontWeight,
+    fontFamily,
+    spinDurationMs,
+    revealDurationMs,
+    easing
+  }, ref) => {
+    const [offset, setOffset] = (0, import_react.useState)(0);
+    const [isAnimating, setIsAnimating] = (0, import_react.useState)(false);
+    const offsetRef = (0, import_react.useRef)(0);
+    const timerRef = (0, import_react.useRef)(null);
+    const updateOffset = (0, import_react.useCallback)((nextOffset) => {
+      offsetRef.current = nextOffset;
+      setOffset(nextOffset);
+    }, []);
+    const clearTimer = (0, import_react.useCallback)(() => {
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+        timerRef.current = null;
+      }
+    }, []);
+    const start = (0, import_react.useCallback)(() => {
+      clearTimer();
+      setIsAnimating(true);
+      const startedAt = Date.now();
+      const duration = Math.max(1, spinDurationMs);
+      timerRef.current = setInterval(() => {
+        const elapsed = Date.now() - startedAt;
+        updateOffset(elapsed / duration * 10 * cellHeight % (10 * cellHeight));
+      }, FRAME_MS);
+    }, [cellHeight, clearTimer, spinDurationMs, updateOffset]);
+    const reveal = (0, import_react.useCallback)(
+      (digit) => {
+        clearTimer();
+        setIsAnimating(true);
+        const targetOffset = Math.max(0, Math.min(9, Math.floor(digit))) * cellHeight;
+        const startOffset = offsetRef.current % (10 * cellHeight);
+        const startedAt = Date.now();
+        const duration = Math.max(0, revealDurationMs);
+        if (duration === 0 || startOffset === targetOffset) {
+          updateOffset(targetOffset);
+          setIsAnimating(false);
+          return;
+        }
+        timerRef.current = setInterval(() => {
+          const progress = Math.min((Date.now() - startedAt) / duration, 1);
+          const easedProgress = easing(progress);
+          updateOffset(startOffset + (targetOffset - startOffset) * easedProgress);
+          if (progress >= 1) {
+            clearTimer();
+            updateOffset(targetOffset);
+            setIsAnimating(false);
+          }
+        }, FRAME_MS);
+      },
+      [cellHeight, clearTimer, easing, revealDurationMs, updateOffset]
+    );
+    const reset = (0, import_react.useCallback)(() => {
+      clearTimer();
+      updateOffset(0);
+      setIsAnimating(false);
+    }, [clearTimer, updateOffset]);
+    (0, import_react.useImperativeHandle)(ref, () => ({ start, reveal, reset }), [reset, reveal, start]);
+    (0, import_react.useEffect)(() => clearTimer, [clearTimer]);
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_components.View,
+      {
+        className: "x-rolling-number__reel",
+        "data-slot": "rolling-number-reel",
+        "data-index": index,
+        "data-animating": isAnimating ? "true" : "false",
+        style: {
+          position: "relative",
+          width: reelWidth,
+          height: cellHeight,
+          flexShrink: 0,
+          overflow: "hidden",
+          fontFamily
+        }
+      },
+      /* @__PURE__ */ import_react.default.createElement(
+        import_components.View,
+        {
+          className: "x-rolling-number__track",
+          "data-slot": "rolling-number-track",
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            transform: `translateY(-${offset}px)`,
+            willChange: "transform"
+          }
+        },
+        [...DIGITS, ...DIGITS].map((digit, digitIndex) => /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            key: digitIndex,
+            className: "x-rolling-number__digit",
+            "data-slot": "rolling-number-digit",
+            "data-digit": digit,
+            style: {
+              width: reelWidth,
+              height: cellHeight,
+              flexShrink: 0,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center"
+            }
+          },
+          /* @__PURE__ */ import_react.default.createElement(
+            import_components.Text,
+            {
+              style: {
+                fontSize,
+                lineHeight: `${cellHeight}px`,
+                fontWeight,
+                fontFamily,
+                fontVariantNumeric: "tabular-nums",
+                color
+              }
+            },
+            digit
+          )
+        ))
+      )
+    );
+  }
+);
+DigitReel.displayName = "DigitReel";
+var RollingNumber = (0, import_react.forwardRef)(
+  ({
+    value,
+    digits = 2,
+    cellHeight = 40,
+    reelWidth = 30,
+    fontSize,
+    spinDurationMs = 800,
+    revealDurationMs = 600,
+    staggerMs = 120,
+    easing = easeOutCubic,
+    color,
+    fontWeight = "bold",
+    fontFamily,
+    onRevealEnd,
+    loading = false,
+    className,
+    style,
+    testID = "rolling-number",
+    ariaLabel = "滚动数字",
+    onClick
+  }, ref) => {
+    const { theme } = (0, import_theme.useTheme)();
+    const resolvedDigits = normalizeDigits(digits);
+    const resolvedCellHeight = Math.max(1, cellHeight);
+    const resolvedReelWidth = Math.max(1, reelWidth);
+    const resolvedFontSize = fontSize ?? Math.floor(resolvedCellHeight * 0.72);
+    const resolvedColor = color ?? theme.colors.foreground;
+    const reelRefs = (0, import_react.useRef)([]);
+    const staggerTimeoutsRef = (0, import_react.useRef)([]);
+    const revealEndTimeoutRef = (0, import_react.useRef)(null);
+    const clearPendingTimers = (0, import_react.useCallback)(() => {
+      staggerTimeoutsRef.current.forEach((timeoutId) => clearTimeout(timeoutId));
+      staggerTimeoutsRef.current = [];
+      if (revealEndTimeoutRef.current) {
+        clearTimeout(revealEndTimeoutRef.current);
+        revealEndTimeoutRef.current = null;
+      }
+    }, []);
+    const start = (0, import_react.useCallback)(() => {
+      clearPendingTimers();
+      reelRefs.current.forEach((reel) => reel == null ? void 0 : reel.start());
+    }, [clearPendingTimers]);
+    const reveal = (0, import_react.useCallback)(
+      (nextValue) => {
+        clearPendingTimers();
+        const valueString = toDigitString(nextValue, resolvedDigits);
+        reelRefs.current.slice(0, resolvedDigits).forEach((reel, index) => {
+          if (!reel) return;
+          const timeoutId = setTimeout(
+            () => reel.reveal(Number(valueString[index] ?? 0)),
+            index * Math.max(0, staggerMs)
+          );
+          staggerTimeoutsRef.current.push(timeoutId);
+        });
+        const totalDuration = Math.max(0, revealDurationMs) + Math.max(0, resolvedDigits - 1) * Math.max(0, staggerMs);
+        revealEndTimeoutRef.current = setTimeout(() => onRevealEnd == null ? void 0 : onRevealEnd(nextValue), totalDuration);
+      },
+      [clearPendingTimers, onRevealEnd, resolvedDigits, revealDurationMs, staggerMs]
+    );
+    const reset = (0, import_react.useCallback)(() => {
+      clearPendingTimers();
+      reelRefs.current.forEach((reel) => reel == null ? void 0 : reel.reset());
+    }, [clearPendingTimers]);
+    (0, import_react.useImperativeHandle)(ref, () => ({ start, reveal, reset }), [reset, reveal, start]);
+    (0, import_react.useEffect)(() => {
+      if (loading) {
+        start();
+      } else if (value !== void 0) {
+        reveal(value);
+      } else {
+        reset();
+      }
+      return clearPendingTimers;
+    }, [clearPendingTimers, loading, reset, reveal, start, value]);
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_components.View,
+      {
+        className: (0, import_utils.classNames)("x-rolling-number", className),
+        "data-slot": "rolling-number-root",
+        "data-loading": loading ? "true" : "false",
+        "data-state": loading ? "loading" : value !== void 0 ? "revealed" : "idle",
+        "data-digits": resolvedDigits,
+        "data-testid": testID,
+        ariaRole: "text",
+        ariaLabel: value === void 0 ? ariaLabel : `${ariaLabel} ${value}`,
+        style: {
+          display: "inline-flex",
+          flexDirection: "row",
+          alignItems: "center",
+          alignSelf: "flex-start",
+          flexShrink: 0,
+          gap: 4,
+          ...style
+        },
+        onClick
+      },
+      Array.from({ length: resolvedDigits }).map((_, index) => /* @__PURE__ */ import_react.default.createElement(
+        DigitReel,
+        {
+          key: index,
+          ref: (instance) => {
+            reelRefs.current[index] = instance;
+          },
+          index,
+          cellHeight: resolvedCellHeight,
+          reelWidth: resolvedReelWidth,
+          fontSize: resolvedFontSize,
+          color: resolvedColor,
+          fontWeight,
+          fontFamily,
+          spinDurationMs,
+          revealDurationMs,
+          easing
+        }
+      ))
+    );
+  }
+);
+RollingNumber.displayName = "RollingNumber";
+var rollingNumber_default = RollingNumber;

package/lib/components/rollingNumber/types.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="react" />
+export interface RollingNumberProps {
+    /** Final value. Undefined leaves the component idle unless loading is true. */
+    value?: number;
+    /** Number of reels. Values are padded on the left with zeroes. */
+    digits?: number;
+    /** Height of one digit cell in px. */
+    cellHeight?: number;
+    /** Width of one reel in px. */
+    reelWidth?: number;
+    /** Digit font size in px. Defaults to 72% of cellHeight. */
+    fontSize?: number;
+    /** Duration of one loading spin cycle in ms. */
+    spinDurationMs?: number;
+    /** Duration of the reveal animation in ms. */
+    revealDurationMs?: number;
+    /** Delay between adjacent reels in ms. */
+    staggerMs?: number;
+    /** Custom reveal easing function. */
+    easing?: (progress: number) => number;
+    color?: string;
+    fontWeight?: React.CSSProperties['fontWeight'];
+    fontFamily?: string;
+    onRevealEnd?: (value: number) => void;
+    loading?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    testID?: string;
+    ariaLabel?: string;
+    onClick?: () => void;
+}
+export interface RollingNumberRef {
+    /** Start the indefinite loading animation. */
+    start: () => void;
+    /** Reveal a value immediately through the configured reel animation. */
+    reveal: (value: number) => void;
+    /** Stop animations and return every reel to zero. */
+    reset: () => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/components/rollingNumber/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/rollingNumber/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -0,0 +1,4 @@
+export * from './types';
+export { SafeArea, useSafeArea } from './safeArea';
+export { default } from './safeArea';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/safeArea/index.js

@@ -0,0 +1,46 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/safeArea/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SafeArea: () => import_safeArea.SafeArea,
+  default: () => import_safeArea2.default,
+  useSafeArea: () => import_safeArea.useSafeArea
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./types"), module.exports);
+var import_safeArea = require("./safeArea");
+var import_safeArea2 = __toESM(require("./safeArea"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SafeArea,
+  useSafeArea,
+  ...require("./types")
+});

package/lib/components/safeArea/safeArea.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { SafeAreaInsets, SafeAreaProps } from './types';
+export declare const SafeArea: React.FC<SafeAreaProps>;
+/** Stable zero fallback aligned with x-mobile-ui. CSS env() owns visual insets. */
+export declare const useSafeArea: () => SafeAreaInsets;
+export default SafeArea;
+//# sourceMappingURL=safeArea.d.ts.map

package/lib/components/safeArea/safeArea.js

@@ -0,0 +1,101 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/safeArea/safeArea.tsx
+var safeArea_exports = {};
+__export(safeArea_exports, {
+  SafeArea: () => SafeArea,
+  default: () => safeArea_default,
+  useSafeArea: () => useSafeArea
+});
+module.exports = __toCommonJS(safeArea_exports);
+var import_react = __toESM(require("react"));
+var import_components = require("@tarojs/components");
+var import_utils = require("../../utils");
+var import_style = require("../../utils/style");
+var zeroInsets = Object.freeze({ top: 0, bottom: 0, left: 0, right: 0 });
+var SafeArea = ({
+  position,
+  top,
+  bottom,
+  height,
+  backgroundColor,
+  testID,
+  children,
+  className,
+  style
+}) => {
+  const usesLegacyFlags = top !== void 0 || bottom !== void 0;
+  const applyTop = position ? position === "top" : usesLegacyFlags ? Boolean(top) : true;
+  const applyBottom = position ? position === "bottom" : usesLegacyFlags ? Boolean(bottom) : true;
+  const dataPosition = position ?? (applyTop && applyBottom ? "both" : applyTop ? "top" : applyBottom ? "bottom" : "none");
+  const {
+    padding,
+    paddingTop,
+    paddingBottom,
+    paddingBlock,
+    paddingBlockStart,
+    paddingBlockEnd,
+    ...customStyle
+  } = style ?? {};
+  const normalizedPadding = (0, import_style.toCssLength)(padding);
+  const topPadding = paddingTop ?? paddingBlockStart ?? (0, import_style.resolveBlockPaddingEdge)(paddingBlock, "start") ?? (0, import_style.resolvePhysicalPadding)(normalizedPadding, "top");
+  const bottomPadding = paddingBottom ?? paddingBlockEnd ?? (0, import_style.resolveBlockPaddingEdge)(paddingBlock, "end") ?? (0, import_style.resolvePhysicalPadding)(normalizedPadding, "bottom");
+  const leftPadding = (0, import_style.resolvePhysicalPadding)(normalizedPadding, "left");
+  const rightPadding = (0, import_style.resolvePhysicalPadding)(normalizedPadding, "right");
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_components.View,
+    {
+      "aria-hidden": children == null ? "true" : void 0,
+      className: (0, import_utils.classNames)("x-safe-area", className),
+      "data-slot": "safe-area-root",
+      "data-position": dataPosition,
+      "data-testid": testID,
+      style: {
+        width: "100%",
+        boxSizing: "border-box",
+        paddingLeft: leftPadding,
+        paddingRight: rightPadding,
+        paddingTop: (0, import_style.addCssEnvironmentInset)(applyTop, "safe-area-inset-top", topPadding),
+        paddingBottom: (0, import_style.addCssEnvironmentInset)(applyBottom, "safe-area-inset-bottom", bottomPadding),
+        height,
+        backgroundColor,
+        ...customStyle
+      }
+    },
+    children
+  );
+};
+var useSafeArea = () => zeroInsets;
+SafeArea.displayName = "SafeArea";
+var safeArea_default = SafeArea;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SafeArea,
+  useSafeArea
+});

package/lib/components/safeArea/types.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+export interface SafeAreaProps {
+    /** Canonical x-mobile-ui position. */
+    position?: 'top' | 'bottom';
+    /** Compatibility flags for wrapping both insets. */
+    top?: boolean;
+    bottom?: boolean;
+    /** Mini-program spacer extensions from the native contract. */
+    height?: number | string;
+    backgroundColor?: string;
+    testID?: string;
+    children?: ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface SafeAreaInsets {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/components/safeArea/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/safeArea/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -0,0 +1,3 @@
+export { ScrollFade, default } from './scrollFade';
+export type { ScrollFadeProps, ScrollFadeDirection, ScrollFadeEdges, ScrollFadeScrollEvent } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/scrollFade/index.js

@@ -0,0 +1,40 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/scrollFade/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ScrollFade: () => import_scrollFade.ScrollFade,
+  default: () => import_scrollFade.default
+});
+module.exports = __toCommonJS(index_exports);
+var import_scrollFade = __toESM(require("./scrollFade"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScrollFade
+});

package/lib/components/scrollFade/scrollFade.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ScrollFade Component
+ *
+ * Taro (H5 + WeApp) port of the x-rn-ui ScrollFade: renders start/end
+ * gradient overlays above a Taro ScrollView while more content exists
+ * beyond that edge. Gradients use inline CSS linear-gradient on View
+ * (SVG is not available cross-platform); visibility toggles are deduped
+ * and animated with a token-driven opacity transition.
+ */
+import React from 'react';
+import type { ScrollFadeEdges, ScrollFadeProps } from './types';
+export declare const ScrollFade: React.FC<ScrollFadeProps>;
+export type { ScrollFadeEdges, ScrollFadeProps };
+export default ScrollFade;
+//# sourceMappingURL=scrollFade.d.ts.map