@hanwenbo/x-taro-ui 0.0.1

package/lib/components/tag/tokens.js

@@ -0,0 +1,155 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/tag/tokens.ts
+var tokens_exports = {};
+__export(tokens_exports, {
+  useTagColors: () => useTagColors,
+  useTagInteractionTokens: () => useTagInteractionTokens,
+  useTagSizeTokens: () => useTagSizeTokens,
+  useTagStyle: () => useTagStyle
+});
+module.exports = __toCommonJS(tokens_exports);
+var import_react = require("react");
+var import_theme = require("../../theme");
+function getReadableTagTextColor(color, darkText, lightText) {
+  const rawHex = color.startsWith("#") ? color.slice(1) : "";
+  const normalized = rawHex.length === 3 || rawHex.length === 4 ? rawHex.split("").map((character) => `${character}${character}`).join("") : rawHex;
+  if (normalized.length !== 6 && normalized.length !== 8 || !/^[\da-f]+$/i.test(normalized)) {
+    return void 0;
+  }
+  const red = parseInt(normalized.slice(0, 2), 16);
+  const green = parseInt(normalized.slice(2, 4), 16);
+  const blue = parseInt(normalized.slice(4, 6), 16);
+  const luminance = (0.299 * red + 0.587 * green + 0.114 * blue) / 255;
+  return luminance > 0.62 ? darkText : lightText;
+}
+function useTagSizeTokens(size = "middle") {
+  return (0, import_react.useMemo)(() => {
+    const sizeMap = {
+      mini: { paddingInline: 6, paddingBlock: 2, fontSize: 12, lineHeight: 16 },
+      small: { paddingInline: 8, paddingBlock: 2, fontSize: 12, lineHeight: 16 },
+      middle: { paddingInline: 10, paddingBlock: 4, fontSize: 14, lineHeight: 20 },
+      large: { paddingInline: 12, paddingBlock: 6, fontSize: 16, lineHeight: 24 }
+    };
+    const tokens = sizeMap[size];
+    return {
+      ...tokens
+    };
+  }, [size]);
+}
+function useTagColors(variant = "default", color) {
+  const { colors, namedColors } = (0, import_theme.useTokens)();
+  return (0, import_react.useMemo)(() => {
+    let actualColor = color;
+    if (color && color in namedColors) {
+      actualColor = namedColors[color];
+    }
+    const baseColor = actualColor || colors.primary;
+    if (actualColor && variant !== "solid") {
+      return {
+        background: (0, import_theme.withOpacity)(actualColor, variant === "outlined" ? 0.06 : 0.12),
+        color: actualColor,
+        border: (0, import_theme.withOpacity)(actualColor, variant === "outlined" ? 0.36 : 0.24)
+      };
+    }
+    switch (variant) {
+      case "solid":
+        return {
+          background: baseColor,
+          color: actualColor ? getReadableTagTextColor(
+            actualColor,
+            colors.foreground,
+            colors["primary-foreground"]
+          ) ?? colors["primary-foreground"] : colors["primary-foreground"],
+          border: baseColor
+        };
+      case "filled":
+        return {
+          background: colors.muted,
+          color: colors.foreground,
+          border: colors.border
+        };
+      case "outlined":
+        return {
+          background: "transparent",
+          color: colors.foreground,
+          border: colors.border
+        };
+      case "default":
+      default:
+        return {
+          background: colors.muted,
+          color: colors.foreground,
+          border: colors.border
+        };
+    }
+  }, [variant, color, colors, namedColors]);
+}
+function useTagInteractionTokens() {
+  const { colors, motion } = (0, import_theme.useTokens)();
+  return (0, import_react.useMemo)(
+    () => ({
+      hoverBackground: (0, import_theme.withOpacity)(colors.accent, 0.6),
+      hoverBorder: (0, import_theme.withOpacity)(colors.primary, 0.3),
+      closeIcon: colors["muted-foreground"],
+      ring: colors.ring,
+      ringOffset: colors.background,
+      transition: `${motion.durationsMs.emphasis}ms ${motion.easing.standard}`
+    }),
+    [colors, motion]
+  );
+}
+function useTagStyle(variant, size, color, disabled) {
+  const { radius } = (0, import_theme.useTokens)();
+  const sizeTokens = useTagSizeTokens(size);
+  const colorTokens = useTagColors(variant, color);
+  return (0, import_react.useMemo)(() => {
+    return {
+      display: "inline-flex",
+      alignItems: "center",
+      alignSelf: "flex-start",
+      gap: 4,
+      // px
+      boxSizing: "border-box",
+      flexShrink: 0,
+      whiteSpace: "nowrap",
+      paddingLeft: sizeTokens.paddingInline,
+      paddingRight: sizeTokens.paddingInline,
+      paddingTop: sizeTokens.paddingBlock,
+      paddingBottom: sizeTokens.paddingBlock,
+      fontSize: sizeTokens.fontSize,
+      lineHeight: `${sizeTokens.lineHeight}px`,
+      borderRadius: radius.md,
+      borderWidth: 1,
+      borderStyle: "solid",
+      borderColor: colorTokens.border,
+      backgroundColor: colorTokens.background,
+      color: colorTokens.color,
+      opacity: disabled ? 0.5 : 1,
+      transition: "background-color var(--x-duration-emphasis) var(--x-easing-standard), border-color var(--x-duration-emphasis) var(--x-easing-standard), color var(--x-duration-emphasis) var(--x-easing-standard)"
+    };
+  }, [sizeTokens, colorTokens, radius.md, disabled]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useTagColors,
+  useTagInteractionTokens,
+  useTagSizeTokens,
+  useTagStyle
+});

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

@@ -0,0 +1,107 @@
+/**
+ * Tag Component Types
+ * Following x-design-system tag.yaml spec
+ */
+/// <reference types="react" />
+import type { SizeVariant } from '../../theme/types';
+export declare type TagVariant = 'default' | 'filled' | 'solid' | 'outlined';
+export interface TagCloseEvent {
+    /** Whether the default removal behavior has been prevented */
+    readonly defaultPrevented: boolean;
+    /** Keep the tag mounted */
+    preventDefault: () => void;
+    /** Stop the close action from reaching the tag root */
+    stopPropagation: () => void;
+}
+export interface TagProps {
+    /** Tag content */
+    children?: React.ReactNode;
+    /** Show close button */
+    closable?: boolean;
+    /** Custom close icon */
+    closeIcon?: React.ReactNode;
+    /** Tag color (preset names or custom) */
+    color?: string;
+    /** Internal semantic class names, matching x-web-ui */
+    classNames?: {
+        root?: string;
+        icon?: string;
+        content?: string;
+        closeIcon?: string;
+    };
+    /** Link URL */
+    href?: string;
+    /** Click handler */
+    onClick?: () => void;
+    /** Prefix icon */
+    icon?: React.ReactNode;
+    /** Close handler - preventDefault keeps tag visible */
+    onClose?: (e: TagCloseEvent) => void;
+    /** Internal semantic styles, matching x-web-ui */
+    styles?: {
+        root?: React.CSSProperties;
+        icon?: React.CSSProperties;
+        content?: React.CSSProperties;
+        closeIcon?: React.CSSProperties;
+    };
+    /** Link target */
+    target?: string;
+    /** Size variant */
+    size?: SizeVariant;
+    /** Visual variant */
+    variant?: TagVariant;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: React.CSSProperties;
+}
+export interface CheckableTagProps {
+    /** Checked state */
+    checked: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Prefix icon */
+    icon?: React.ReactNode;
+    /** Size variant */
+    size?: SizeVariant;
+    /** Change handler */
+    onChange?: (checked: boolean) => void;
+    /** Tag content */
+    children?: React.ReactNode;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: React.CSSProperties;
+}
+export interface CheckableTagGroupProps {
+    /** Initial selected value */
+    defaultValue?: string | number | Array<string | number> | null;
+    /** Disable all options */
+    disabled?: boolean;
+    /** Enable multiple selection */
+    multiple?: boolean;
+    /** Option list */
+    options?: Array<{
+        label: React.ReactNode;
+        value: string | number;
+    } | string | number>;
+    /** Controlled selected value */
+    value?: string | number | Array<string | number> | null;
+    /** Selection change callback */
+    onChange?: (value: string | number | Array<string | number> | null) => void;
+    /** Shared tag size */
+    size?: SizeVariant;
+    /** Internal semantic class names */
+    classNames?: {
+        root?: string;
+        item?: string;
+    };
+    /** Internal semantic styles */
+    styles?: {
+        root?: React.CSSProperties;
+        item?: React.CSSProperties;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/components/tag/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/tag/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

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

package/lib/components/text/index.js

@@ -0,0 +1,44 @@
+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/text/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Text: () => import_text.default,
+  default: () => import_text2.default
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./types"), module.exports);
+var import_text = __toESM(require("./text"));
+var import_text2 = __toESM(require("./text"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Text,
+  ...require("./types")
+});

package/lib/components/text/text.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { TextProps } from './types';
+declare const Text: React.FC<TextProps>;
+export default Text;
+//# sourceMappingURL=text.d.ts.map

package/lib/components/text/text.js

@@ -0,0 +1,220 @@
+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/text/text.tsx
+var text_exports = {};
+__export(text_exports, {
+  default: () => text_default
+});
+module.exports = __toCommonJS(text_exports);
+var import_react = __toESM(require("react"));
+var import_components = require("@tarojs/components");
+var import_utils = require("../../utils");
+var import_theme = require("../../theme");
+var tightTracking = "-0.025em";
+var variantMap = {
+  display: {
+    fontSize: 48,
+    fontWeight: 600,
+    lineHeight: (0, import_theme.typographyLineHeight)("display"),
+    letterSpacing: tightTracking
+  },
+  h1: {
+    fontSize: 36,
+    fontWeight: 600,
+    lineHeight: (0, import_theme.typographyLineHeight)("h1"),
+    letterSpacing: tightTracking
+  },
+  h2: {
+    fontSize: 30,
+    fontWeight: 600,
+    lineHeight: (0, import_theme.typographyLineHeight)("h2"),
+    letterSpacing: tightTracking
+  },
+  h3: {
+    fontSize: 24,
+    fontWeight: 600,
+    lineHeight: (0, import_theme.typographyLineHeight)("h3"),
+    letterSpacing: tightTracking
+  },
+  h4: {
+    fontSize: 20,
+    fontWeight: 600,
+    lineHeight: (0, import_theme.typographyLineHeight)("h4"),
+    letterSpacing: tightTracking
+  },
+  h5: {
+    fontSize: 18,
+    fontWeight: 600,
+    lineHeight: (0, import_theme.typographyLineHeight)("h5"),
+    letterSpacing: tightTracking
+  },
+  title: {
+    fontSize: 18,
+    fontWeight: 600,
+    lineHeight: (0, import_theme.typographyLineHeight)("h5"),
+    letterSpacing: tightTracking
+  },
+  body: { fontSize: 16, fontWeight: 400, lineHeight: (0, import_theme.typographyLineHeight)("body") },
+  bodyMuted: {
+    fontSize: 16,
+    fontWeight: 400,
+    lineHeight: (0, import_theme.typographyLineHeight)("body"),
+    muted: true
+  },
+  label: { fontSize: 14, fontWeight: 500, lineHeight: (0, import_theme.typographyLineHeight)("label") },
+  helper: {
+    fontSize: 14,
+    fontWeight: 400,
+    lineHeight: (0, import_theme.typographyLineHeight)("helper"),
+    muted: true
+  },
+  caption: {
+    fontSize: 12,
+    fontWeight: 400,
+    lineHeight: (0, import_theme.typographyLineHeight)("caption"),
+    muted: true
+  },
+  overline: { fontSize: 12, fontWeight: 500, lineHeight: (0, import_theme.typographyLineHeight)("overline") },
+  tableHeader: {
+    fontSize: 14,
+    fontWeight: 500,
+    lineHeight: (0, import_theme.typographyLineHeight)("tableHeader"),
+    foregroundOpacity: 0.7
+  },
+  tableBody: { fontSize: 14, fontWeight: 400, lineHeight: (0, import_theme.typographyLineHeight)("tableBody") },
+  numeric: { fontSize: 14, fontWeight: 400, lineHeight: (0, import_theme.typographyLineHeight)("numeric") },
+  code: { fontSize: 14, fontWeight: 400, lineHeight: (0, import_theme.typographyLineHeight)("code") }
+};
+var namedSizeMap = {
+  small: { fontSize: (0, import_theme.getTypographySize)("sm"), lineHeight: (0, import_theme.typographyLineHeight)("label") },
+  base: { fontSize: (0, import_theme.getTypographySize)("base"), lineHeight: (0, import_theme.typographyLineHeight)("body") },
+  large: { fontSize: (0, import_theme.getTypographySize)("lg"), lineHeight: (0, import_theme.typographyLineHeight)("h5") }
+};
+var defaultTextPreset = {
+  fontSize: 14,
+  fontWeight: 400,
+  lineHeight: "22px"
+};
+function resolveColor(color, themeColors) {
+  if (!color) return void 0;
+  const colorMap = {
+    primary: themeColors.primary,
+    success: themeColors.success,
+    warning: themeColors.warning,
+    danger: themeColors.destructive,
+    weak: themeColors["muted-foreground"],
+    light: (0, import_theme.withOpacity)(themeColors.foreground, 0.55),
+    text: themeColors.foreground,
+    // x-mobile-ui's `white` compatibility name maps to the inverse foreground token.
+    white: themeColors["primary-foreground"]
+  };
+  if (color in colorMap) return colorMap[color];
+  if (color === "secondary") return themeColors["muted-foreground"];
+  return color;
+}
+function resolveSize(size) {
+  if (typeof size === "number") return `${size}px`;
+  return size;
+}
+var Text = ({
+  variant,
+  color,
+  size,
+  weight,
+  align,
+  lineHeight,
+  block = true,
+  decoration,
+  numberOfLines,
+  onClick,
+  children,
+  className,
+  style,
+  testID,
+  ariaLabel,
+  role,
+  maxLines,
+  ...nativeProps
+}) => {
+  const { theme } = (0, import_theme.useTheme)();
+  const resolvedVariant = variant ?? "body";
+  const preset = variant ? variantMap[resolvedVariant] : defaultTextPreset;
+  const namedSize = size && size in namedSizeMap ? namedSizeMap[size] : null;
+  const resolvedSize = namedSize ? `${namedSize.fontSize}px` : !variant && size ? resolveSize(size) : `${preset.fontSize}px`;
+  const clampedLines = typeof numberOfLines === "number" && numberOfLines > 0 ? Math.floor(numberOfLines) : void 0;
+  const foregroundColor = "foregroundOpacity" in preset && typeof preset.foregroundOpacity === "number" ? (0, import_theme.withOpacity)(theme.colors.foreground, preset.foregroundOpacity) : theme.colors.foreground;
+  const resolvedStyle = {
+    display: clampedLines ? "-webkit-box" : block ? "block" : "inline",
+    color: resolveColor(color, theme.colors) ?? ("muted" in preset && preset.muted ? theme.colors["muted-foreground"] : foregroundColor),
+    fontSize: resolvedSize,
+    fontWeight: preset.fontWeight,
+    textAlign: align,
+    lineHeight: (namedSize == null ? void 0 : namedSize.lineHeight) ?? preset.lineHeight,
+    letterSpacing: "letterSpacing" in preset ? preset.letterSpacing : resolvedVariant === "overline" ? "0.2em" : void 0,
+    textTransform: resolvedVariant === "overline" ? "uppercase" : void 0,
+    fontVariantNumeric: resolvedVariant === "numeric" ? "tabular-nums" : void 0,
+    fontFamily: resolvedVariant === "code" ? "monospace" : void 0,
+    textDecoration: decoration && decoration !== "none" ? decoration : void 0,
+    overflow: clampedLines ? "hidden" : void 0,
+    textOverflow: clampedLines ? "ellipsis" : void 0,
+    WebkitLineClamp: clampedLines,
+    WebkitBoxOrient: clampedLines ? "vertical" : void 0,
+    ...style
+  };
+  if (!variant && lineHeight) {
+    resolvedStyle.lineHeight = typeof lineHeight === "number" ? String(lineHeight) : lineHeight;
+  }
+  if (!variant && size && !namedSize) {
+    resolvedStyle.fontSize = resolveSize(size);
+  }
+  if (weight !== void 0) {
+    resolvedStyle.fontWeight = weight;
+  }
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_components.Text,
+    {
+      ...nativeProps,
+      className: (0, import_utils.classNames)("x-text", className),
+      "data-slot": "text",
+      "data-text-color": color && color in theme.colors ? color : void 0,
+      "data-text-variant": resolvedVariant,
+      "data-text-truncated": clampedLines ? "true" : "false",
+      "data-text-native-max-lines": clampedLines ?? maxLines,
+      "data-testid": testID,
+      ariaLabel,
+      role,
+      style: resolvedStyle,
+      numberOfLines: clampedLines,
+      maxLines: clampedLines ?? maxLines,
+      onClick
+    },
+    children
+  );
+};
+var text_default = Text;

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

@@ -0,0 +1,50 @@
+/**
+ * Text Component Types
+ *
+ * @description
+ * Design system aligned text component types
+ */
+import type { CSSProperties, ReactNode } from 'react';
+import type { TextProps as TaroTextProps } from '@tarojs/components/types/Text';
+import type { designSystemTypographyRoles } from '../../theme/generated/design-system.generated';
+declare type NativeTextProps = Omit<TaroTextProps, 'children' | 'className' | 'numberOfLines' | 'onClick' | 'ref' | 'style'>;
+export declare type TextVariant = keyof typeof designSystemTypographyRoles | 'title';
+export declare type TextColor = 'primary' | 'success' | 'warning' | 'danger' | 'weak' | 'light' | 'text' | 'white';
+export declare type TextNamedSize = 'small' | 'base' | 'large';
+export declare type TextWeight = 'normal' | 'bold' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+export interface TextProps extends NativeTextProps {
+    /** Typography preset */
+    variant?: TextVariant;
+    /** Semantic text color or custom CSS color. */
+    color?: TextColor | (string & {});
+    /** Font size override */
+    size?: number | TextNamedSize | (string & {});
+    /** Font weight override */
+    weight?: TextWeight;
+    /** Text alignment */
+    align?: 'left' | 'center' | 'right' | 'justify';
+    /** Line height */
+    lineHeight?: number | string;
+    /** Render as block */
+    block?: boolean;
+    /** Text decoration */
+    decoration?: 'none' | 'underline' | 'line-through';
+    /** Clamp line count */
+    numberOfLines?: number;
+    /** Click callback with the native Taro event. */
+    onClick?: TaroTextProps['onClick'];
+    /** Component children */
+    children?: ReactNode;
+    /** Custom className */
+    className?: string;
+    /** Custom styles */
+    style?: CSSProperties;
+    /** React Native compatible test id. */
+    testID?: string;
+    /** Accessible label forwarded to the Taro primitive. */
+    ariaLabel?: string;
+    /** Optional semantic role. */
+    role?: string;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/components/text/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/text/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

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

package/lib/components/textInput/index.js

@@ -0,0 +1,44 @@
+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/textInput/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TextInput: () => import_textInput.default,
+  default: () => import_textInput2.default
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./types"), module.exports);
+var import_textInput = __toESM(require("./textInput"));
+var import_textInput2 = __toESM(require("./textInput"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TextInput,
+  ...require("./types")
+});