@hanwenbo/x-taro-ui 0.0.1

package/lib/components/form/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/form/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Form: () => import_form.default,
+  default: () => import_form2.default
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./types"), module.exports);
+var import_form = __toESM(require("./form"));
+var import_form2 = __toESM(require("./form"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Form,
+  ...require("./types")
+});

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

@@ -0,0 +1,156 @@
+/**
+ * Form Component Types
+ *
+ * @description
+ * Design system aligned form component types
+ */
+import type { ReactNode } from 'react';
+import type { SizeVariant } from '../../theme/types';
+import type { SelectOption } from '../select/types';
+export declare type FormLayout = 'vertical' | 'horizontal' | 'inline';
+export declare type FormFieldType = 'text' | 'textarea' | 'select' | 'custom';
+export declare type FormVariant = 'outlined' | 'filled' | 'borderless' | 'underlined';
+export declare type FormSize = SizeVariant | 'medium';
+export declare type FormSemanticSlot = 'root' | 'label' | 'content';
+export declare type FormValues = Record<string, any>;
+export declare type FormErrors = Record<string, string | undefined>;
+export declare type FormSemanticClassNames = Partial<Record<FormSemanticSlot, string>>;
+export declare type FormSemanticStyles = Partial<Record<FormSemanticSlot, React.CSSProperties>>;
+export interface FormColumnConfig {
+    flex?: number | string;
+    span?: number;
+    offset?: number;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare type FormRequiredMark = boolean | 'optional' | ((label: ReactNode, info: {
+    required: boolean;
+}) => ReactNode);
+export interface FormScrollToFirstErrorOptions {
+    focus?: boolean;
+    behavior?: 'auto' | 'smooth';
+    block?: 'start' | 'center' | 'end' | 'nearest';
+}
+export interface FormFieldRenderProps {
+    field: FormField;
+    value: any;
+    values: FormValues;
+    error?: string;
+    disabled: boolean;
+    onChange: (value: any) => void;
+}
+export interface FormField {
+    /** Stable field key */
+    key: string;
+    /** Field label */
+    label?: ReactNode;
+    /** Field type */
+    type?: FormFieldType;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Supporting description */
+    description?: ReactNode;
+    /** Helper text */
+    helperText?: ReactNode;
+    /** Required mark and validation */
+    required?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Hidden field */
+    hidden?: boolean;
+    /** Initial field value */
+    initialValue?: any;
+    /** Select options */
+    options?: SelectOption[];
+    /** Multiple select mode */
+    multiple?: boolean;
+    /** Text rows for textarea */
+    rows?: number;
+    /** Max input length */
+    maxLength?: number;
+    /** Allow clear */
+    clearable?: boolean;
+    /** Field-level visual variant override */
+    variant?: FormVariant;
+    /** Accessible name for the generated control */
+    ariaLabel?: string;
+    /** Custom renderer */
+    render?: (props: FormFieldRenderProps) => ReactNode;
+    /** Custom validator */
+    validator?: (value: any, values: FormValues, field: FormField) => string | undefined;
+}
+export interface FormRenderProps {
+    values: FormValues;
+    errors: FormErrors;
+    submit: () => void;
+    reset: () => void;
+}
+export interface FormSubmitPayload {
+    values: FormValues;
+    errors: FormErrors;
+    valid: boolean;
+}
+export interface FormProps {
+    classNames?: FormSemanticClassNames | ((info: {
+        props: FormProps;
+    }) => FormSemanticClassNames);
+    prefixCls?: string;
+    colon?: boolean;
+    tooltip?: ReactNode;
+    name?: string;
+    labelAlign?: 'left' | 'right';
+    labelWrap?: boolean;
+    labelCol?: FormColumnConfig;
+    wrapperCol?: FormColumnConfig;
+    form?: unknown;
+    feedbackIcons?: unknown;
+    styles?: FormSemanticStyles | ((info: {
+        props: FormProps;
+    }) => FormSemanticStyles);
+    scrollToFirstError?: boolean | FormScrollToFirstErrorOptions;
+    requiredMark?: FormRequiredMark;
+    hideRequiredMark?: boolean;
+    rootClassName?: string;
+    variant?: FormVariant;
+    /** Field definitions */
+    fields?: FormField[];
+    /** Controlled values */
+    values?: FormValues;
+    /** Default values */
+    defaultValues?: FormValues;
+    /** Controlled errors */
+    errors?: FormErrors;
+    /** Layout mode */
+    layout?: FormLayout;
+    /** Size variant */
+    size?: FormSize;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Gap between items */
+    gap?: number;
+    /** Whether to render footer actions */
+    showFooter?: boolean;
+    /** Submit button text */
+    submitText?: ReactNode;
+    /** Reset button text */
+    resetText?: ReactNode;
+    /** Custom header */
+    header?: ReactNode;
+    /** Custom footer */
+    footer?: ReactNode;
+    /** Form validation */
+    validate?: (values: FormValues) => FormErrors;
+    /** Field change handler */
+    onValuesChange?: (values: FormValues, changedKey: string) => void;
+    /** Submit handler */
+    onSubmit?: (payload: FormSubmitPayload) => void;
+    /** Reset handler */
+    onReset?: (values: FormValues) => void;
+    /** Additional content */
+    children?: ReactNode | ((context: FormRenderProps) => ReactNode);
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: React.CSSProperties;
+}
+//# sourceMappingURL=types.d.ts.map

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

package/lib/components/grid/grid.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { GridItemProps, GridProps } from './types';
+export declare const GridItem: React.FC<GridItemProps>;
+declare type GridComponent = (<T = unknown>(props: GridProps<T>) => React.ReactElement) & {
+    Item: typeof GridItem;
+};
+declare const Grid: GridComponent;
+export default Grid;
+//# sourceMappingURL=grid.d.ts.map

package/lib/components/grid/grid.js

@@ -0,0 +1,259 @@
+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/grid/grid.tsx
+var grid_exports = {};
+__export(grid_exports, {
+  GridItem: () => GridItem,
+  default: () => grid_default
+});
+module.exports = __toCommonJS(grid_exports);
+var import_react = __toESM(require("react"));
+var import_components = require("@tarojs/components");
+var import_patterns = require("../../patterns");
+var import_theme = require("../../theme");
+var import_utils = require("../../utils");
+var sizeGapMap = {
+  mini: import_theme.designSystemSpacing["1"],
+  small: import_theme.designSystemSpacing["2"],
+  middle: import_theme.designSystemSpacing["3"],
+  large: import_theme.designSystemSpacing["4"]
+};
+var GridContext = (0, import_react.createContext)(null);
+function normalizeVariant(variant) {
+  if (variant === "plain") return "default";
+  if (variant === "outline") return "bordered";
+  return variant ?? "default";
+}
+function normalizeColumns(columns) {
+  if (!Number.isFinite(columns)) return 4;
+  return Math.max(1, Math.floor(columns ?? 4));
+}
+function normalizeSpan(span, columns) {
+  if (!Number.isFinite(span)) return 1;
+  return Math.max(1, Math.min(columns, Math.floor(span ?? 1)));
+}
+function toLength(value) {
+  return typeof value === "number" ? `${value}px` : value;
+}
+var GridItem = ({
+  span = 1,
+  children,
+  clickable = false,
+  variant,
+  onClick,
+  onPress,
+  className,
+  style,
+  testID
+}) => {
+  const { theme } = (0, import_theme.useTheme)();
+  const context = (0, import_react.useContext)(GridContext);
+  const columns = (context == null ? void 0 : context.columns) ?? 1;
+  const resolvedSpan = normalizeSpan(span, columns);
+  const resolvedVariant = normalizeVariant(variant ?? (context == null ? void 0 : context.variant));
+  const interactive = clickable || Boolean(onClick) || Boolean(onPress);
+  const {
+    handlers,
+    pressed,
+    style: pressStyle
+  } = (0, import_patterns.usePressable)({
+    onPress: () => {
+      onClick == null ? void 0 : onClick();
+      onPress == null ? void 0 : onPress();
+    },
+    scale: 0.985
+  });
+  const variantStyle = resolvedVariant === "bordered" ? { backgroundColor: theme.colors.background } : resolvedVariant === "card" ? {
+    backgroundColor: pressed ? theme.colors.accent : theme.colors.card,
+    borderRadius: "var(--x-grid-item-radius-card)",
+    boxShadow: "var(--x-grid-item-shadow-card)"
+  } : {};
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_components.View,
+    {
+      className: (0, import_utils.classNames)(
+        "x-grid-item",
+        `x-grid-item--${resolvedVariant}`,
+        interactive && "x-grid-item--clickable",
+        className
+      ),
+      "data-slot": "grid-item",
+      "data-grid-variant": resolvedVariant,
+      "data-grid-clickable": interactive ? "true" : "false",
+      "data-testid": testID,
+      role: interactive ? "button" : void 0,
+      style: {
+        minWidth: 0,
+        gridColumn: `span ${resolvedSpan}`,
+        overflow: resolvedVariant === "card" ? "hidden" : void 0,
+        transition: interactive ? `transform ${import_theme.designSystemMotion.patterns.subtlePress.durationMs}ms ${import_theme.designSystemMotion.patterns.subtlePress.easing}, background-color ${import_theme.designSystemMotion.durationsMs.emphasis}ms ${import_theme.designSystemMotion.easing.standard}, box-shadow ${import_theme.designSystemMotion.durationsMs.emphasis}ms ${import_theme.designSystemMotion.easing.standard}` : `background-color ${import_theme.designSystemMotion.durationsMs.emphasis}ms ${import_theme.designSystemMotion.easing.standard}, box-shadow ${import_theme.designSystemMotion.durationsMs.emphasis}ms ${import_theme.designSystemMotion.easing.standard}`,
+        ...variantStyle,
+        ...style,
+        ...interactive ? pressStyle : void 0
+      },
+      ...interactive ? handlers : void 0
+    },
+    children
+  );
+};
+GridItem.displayName = "GridItem";
+var Grid = (({
+  items = [],
+  renderItem,
+  keyExtractor,
+  columns = 4,
+  size = "middle",
+  gap,
+  columnGap,
+  rowGap,
+  getItemSpan,
+  variant = "default",
+  emptyText = "No data",
+  loading = false,
+  loadingText = "Loading...",
+  itemStyle,
+  getItemStyle,
+  children,
+  className,
+  style,
+  testID
+}) => {
+  const { theme } = (0, import_theme.useTheme)();
+  const resolvedColumns = normalizeColumns(columns);
+  const resolvedVariant = normalizeVariant(variant);
+  const resolvedGap = gap ?? sizeGapMap[size];
+  const resolvedColumnGap = columnGap ?? resolvedGap;
+  const resolvedRowGap = rowGap ?? resolvedGap;
+  const childItems = import_react.default.Children.toArray(children).filter((child) => child !== null);
+  const hasDataItems = items.length > 0;
+  const shellStyle = resolvedVariant === "bordered" ? {
+    padding: 1,
+    backgroundColor: theme.colors.border
+  } : resolvedVariant === "card" ? {
+    padding: import_theme.designSystemSpacing["2"],
+    borderRadius: "var(--x-grid-card-shell-radius)",
+    backgroundColor: (0, import_theme.withOpacity)(theme.colors.muted, 0.5)
+  } : {};
+  if (loading) {
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_components.View,
+      {
+        className: (0, import_utils.classNames)("x-grid", "x-grid--loading", className),
+        "data-slot": "grid",
+        "data-grid-state": "loading",
+        "data-testid": testID,
+        style
+      },
+      /* @__PURE__ */ import_react.default.createElement(import_components.View, { style: { padding: 16, display: "flex", alignItems: "center" } }, typeof loadingText === "string" ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: theme.colors["muted-foreground"] } }, loadingText) : loadingText)
+    );
+  }
+  if (!hasDataItems && childItems.length === 0) {
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_components.View,
+      {
+        className: (0, import_utils.classNames)("x-grid", "x-grid--empty", className),
+        "data-slot": "grid",
+        "data-grid-state": "empty",
+        "data-testid": testID,
+        style
+      },
+      /* @__PURE__ */ import_react.default.createElement(import_components.View, { style: { padding: 16, display: "flex", alignItems: "center" } }, typeof emptyText === "string" ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: theme.colors["muted-foreground"] } }, emptyText) : emptyText)
+    );
+  }
+  return /* @__PURE__ */ import_react.default.createElement(GridContext.Provider, { value: { columns: resolvedColumns, variant: resolvedVariant } }, /* @__PURE__ */ import_react.default.createElement(
+    import_components.View,
+    {
+      className: (0, import_utils.classNames)("x-grid", `x-grid--${resolvedVariant}`, className),
+      "data-slot": "grid",
+      "data-grid-state": "ready",
+      "data-grid-size": size,
+      "data-grid-variant": resolvedVariant,
+      "data-testid": testID,
+      style: {
+        display: "grid",
+        gridTemplateColumns: `repeat(${resolvedColumns}, minmax(0, 1fr))`,
+        columnGap: toLength(resolvedColumnGap),
+        rowGap: toLength(resolvedRowGap),
+        width: "100%",
+        boxSizing: "border-box",
+        transition: `background-color ${import_theme.designSystemMotion.durationsMs.emphasis}ms ${import_theme.designSystemMotion.easing.standard}`,
+        ...shellStyle,
+        ...style
+      }
+    },
+    hasDataItems ? items.map((item, index) => /* @__PURE__ */ import_react.default.createElement(
+      GridItem,
+      {
+        key: (keyExtractor == null ? void 0 : keyExtractor(item, index)) ?? String(index),
+        span: getItemSpan == null ? void 0 : getItemSpan(item, index),
+        style: { ...itemStyle, ...getItemStyle == null ? void 0 : getItemStyle(item, index) }
+      },
+      renderItem ? renderItem(item, index) : renderDefaultNode(item, theme.colors)
+    )) : childItems.map(
+      (child, index) => import_react.default.isValidElement(child) && child.type === GridItem ? child : /* @__PURE__ */ import_react.default.createElement(GridItem, { key: index }, child)
+    )
+  ));
+});
+Grid.Item = GridItem;
+function renderDefaultNode(item, colors) {
+  if (import_react.default.isValidElement(item)) return item;
+  if (typeof item === "string" || typeof item === "number") {
+    return /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors.foreground } }, item);
+  }
+  if (item && typeof item === "object") {
+    const record = item;
+    const title = record.title ?? record.label ?? record.name;
+    const description = record.description ?? record.subtitle;
+    const extra = record.extra ?? record.value;
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_components.View,
+      {
+        style: { display: "flex", flexDirection: "column", gap: import_theme.designSystemSpacing["1.5"] }
+      },
+      title !== void 0 && /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors.foreground, fontWeight: "600" } }, String(title)),
+      description !== void 0 && /* @__PURE__ */ import_react.default.createElement(
+        import_components.Text,
+        {
+          style: {
+            color: colors["muted-foreground"],
+            fontSize: import_theme.designSystemTypography.sizes.sm
+          }
+        },
+        String(description)
+      ),
+      extra !== void 0 && /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors.foreground } }, String(extra))
+    );
+  }
+  return null;
+}
+var grid_default = Grid;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GridItem
+});

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

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

package/lib/components/grid/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/grid/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Grid: () => import_grid.default,
+  GridItem: () => import_grid.GridItem,
+  default: () => import_grid2.default
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./types"), module.exports);
+var import_grid = __toESM(require("./grid"));
+var import_grid2 = __toESM(require("./grid"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Grid,
+  GridItem,
+  ...require("./types")
+});

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

@@ -0,0 +1,53 @@
+/**
+ * Grid Component Types
+ *
+ * Canonical props follow x-mobile-ui. The data-driven props are retained as
+ * backwards-compatible Taro conveniences.
+ */
+import type { CSSProperties, ReactNode } from 'react';
+export declare type GridSize = 'mini' | 'small' | 'middle' | 'large';
+export declare type GridVariant = 'default' | 'bordered' | 'card';
+export declare type GridLegacyVariant = 'plain' | 'outline';
+export interface GridItemProps {
+    /** Number of columns occupied by the item. */
+    span?: number;
+    children?: ReactNode;
+    /** Enables button semantics and subtle press feedback. */
+    clickable?: boolean;
+    /** Overrides the variant inherited from Grid. */
+    variant?: GridVariant | GridLegacyVariant;
+    onClick?: () => void;
+    /** React Native compatibility alias. */
+    onPress?: () => void;
+    className?: string;
+    style?: CSSProperties;
+    testID?: string;
+}
+export interface GridProps<T = unknown> {
+    /** Canonical child composition, including Grid.Item. */
+    children?: ReactNode;
+    /** Number of columns. */
+    columns?: number;
+    /** Deprecated compatibility override; prefer size. */
+    gap?: number | string;
+    /** Canonical size-based gap. */
+    size?: GridSize;
+    /** Canonical visual variant. */
+    variant?: GridVariant | GridLegacyVariant;
+    /** Data-driven compatibility API. */
+    items?: T[];
+    renderItem?: (item: T, index: number) => ReactNode;
+    keyExtractor?: (item: T, index: number) => string;
+    columnGap?: number | string;
+    rowGap?: number | string;
+    getItemSpan?: (item: T, index: number) => number;
+    emptyText?: ReactNode;
+    loading?: boolean;
+    loadingText?: ReactNode;
+    itemStyle?: CSSProperties;
+    getItemStyle?: (item: T, index: number) => CSSProperties | undefined;
+    className?: string;
+    style?: CSSProperties;
+    testID?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

package/lib/components/icon/aliases.d.ts

@@ -0,0 +1,7 @@
+import type { LucideIconName } from './lucide.generated';
+/**
+ * Map common Lucide export names to icons available in the bundled subset.
+ */
+export declare const lucideIconAliases: Record<string, LucideIconName>;
+export declare function resolveLucideIconName(name: string): LucideIconName | undefined;
+//# sourceMappingURL=aliases.d.ts.map