@onlynative/components 0.1.0-alpha.0

package/dist/card/index.js

@@ -0,0 +1,264 @@
+"use strict";
+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/card/index.ts
+var card_exports = {};
+__export(card_exports, {
+  Card: () => Card
+});
+module.exports = __toCommonJS(card_exports);
+
+// src/card/Card.tsx
+var import_react = require("react");
+var import_react_native3 = require("react-native");
+var import_core = require("@onlynative/core");
+
+// src/card/styles.ts
+var import_react_native2 = require("react-native");
+
+// src/utils/color.ts
+function parseHexColor(color) {
+  const normalized = color.replace("#", "");
+  if (normalized.length !== 6 && normalized.length !== 8) {
+    return null;
+  }
+  const r = Number.parseInt(normalized.slice(0, 2), 16);
+  const g = Number.parseInt(normalized.slice(2, 4), 16);
+  const b = Number.parseInt(normalized.slice(4, 6), 16);
+  if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
+    return null;
+  }
+  return { r, g, b };
+}
+function clampAlpha(alpha) {
+  return Math.max(0, Math.min(1, alpha));
+}
+function alphaColor(color, alpha) {
+  const channels = parseHexColor(color);
+  const boundedAlpha = clampAlpha(alpha);
+  if (!channels) {
+    return color;
+  }
+  return `rgba(${channels.r}, ${channels.g}, ${channels.b}, ${boundedAlpha})`;
+}
+function blendColor(base, overlay, overlayAlpha) {
+  const baseChannels = parseHexColor(base);
+  const overlayChannels = parseHexColor(overlay);
+  const boundedAlpha = clampAlpha(overlayAlpha);
+  if (!baseChannels || !overlayChannels) {
+    return alphaColor(overlay, boundedAlpha);
+  }
+  const r = Math.round(
+    (1 - boundedAlpha) * baseChannels.r + boundedAlpha * overlayChannels.r
+  );
+  const g = Math.round(
+    (1 - boundedAlpha) * baseChannels.g + boundedAlpha * overlayChannels.g
+  );
+  const b = Math.round(
+    (1 - boundedAlpha) * baseChannels.b + boundedAlpha * overlayChannels.b
+  );
+  return `rgb(${r}, ${g}, ${b})`;
+}
+
+// src/utils/elevation.ts
+var import_react_native = require("react-native");
+function elevationStyle(level) {
+  if (import_react_native.Platform.OS === "web") {
+    const { shadowOffset, shadowOpacity, shadowRadius } = level;
+    if (shadowOpacity === 0) {
+      return { boxShadow: "none" };
+    }
+    return {
+      boxShadow: `${shadowOffset.width}px ${shadowOffset.height}px ${shadowRadius}px rgba(0, 0, 0, ${shadowOpacity})`
+    };
+  }
+  return {
+    shadowColor: level.shadowColor,
+    shadowOffset: {
+      width: level.shadowOffset.width,
+      height: level.shadowOffset.height
+    },
+    shadowOpacity: level.shadowOpacity,
+    shadowRadius: level.shadowRadius,
+    elevation: level.elevation
+  };
+}
+
+// src/card/styles.ts
+function getVariantColors(theme, variant) {
+  const disabledContainerColor = alphaColor(theme.colors.onSurface, 0.12);
+  const disabledOutlineColor = alphaColor(theme.colors.onSurface, 0.12);
+  if (variant === "outlined") {
+    return {
+      backgroundColor: theme.colors.surface,
+      borderColor: theme.colors.outline,
+      borderWidth: 1,
+      hoveredBackgroundColor: alphaColor(
+        theme.colors.onSurface,
+        theme.stateLayer.hoveredOpacity
+      ),
+      pressedBackgroundColor: alphaColor(
+        theme.colors.onSurface,
+        theme.stateLayer.pressedOpacity
+      ),
+      disabledBackgroundColor: theme.colors.surface,
+      disabledBorderColor: disabledOutlineColor
+    };
+  }
+  if (variant === "filled") {
+    return {
+      backgroundColor: theme.colors.surfaceContainerHighest,
+      borderColor: "transparent",
+      borderWidth: 0,
+      hoveredBackgroundColor: blendColor(
+        theme.colors.surfaceContainerHighest,
+        theme.colors.onSurface,
+        theme.stateLayer.hoveredOpacity
+      ),
+      pressedBackgroundColor: blendColor(
+        theme.colors.surfaceContainerHighest,
+        theme.colors.onSurface,
+        theme.stateLayer.pressedOpacity
+      ),
+      disabledBackgroundColor: disabledContainerColor,
+      disabledBorderColor: "transparent"
+    };
+  }
+  return {
+    backgroundColor: theme.colors.surface,
+    borderColor: "transparent",
+    borderWidth: 0,
+    hoveredBackgroundColor: blendColor(
+      theme.colors.surface,
+      theme.colors.onSurface,
+      theme.stateLayer.hoveredOpacity
+    ),
+    pressedBackgroundColor: blendColor(
+      theme.colors.surface,
+      theme.colors.onSurface,
+      theme.stateLayer.pressedOpacity
+    ),
+    disabledBackgroundColor: disabledContainerColor,
+    disabledBorderColor: "transparent"
+  };
+}
+function applyColorOverrides(theme, colors, containerColor) {
+  if (!containerColor) return colors;
+  return {
+    ...colors,
+    backgroundColor: containerColor,
+    borderColor: containerColor,
+    borderWidth: 0,
+    hoveredBackgroundColor: blendColor(
+      containerColor,
+      theme.colors.onSurface,
+      theme.stateLayer.hoveredOpacity
+    ),
+    pressedBackgroundColor: blendColor(
+      containerColor,
+      theme.colors.onSurface,
+      theme.stateLayer.pressedOpacity
+    )
+  };
+}
+function createStyles(theme, variant, containerColor) {
+  const baseColors = getVariantColors(theme, variant);
+  const colors = applyColorOverrides(theme, baseColors, containerColor);
+  const elevationLevel0 = elevationStyle(theme.elevation.level0);
+  const elevationLevel1 = elevationStyle(theme.elevation.level1);
+  const elevationLevel2 = elevationStyle(theme.elevation.level2);
+  const baseElevation = variant === "elevated" ? elevationLevel1 : elevationLevel0;
+  return import_react_native2.StyleSheet.create({
+    container: {
+      borderRadius: theme.shape.cornerMedium,
+      backgroundColor: colors.backgroundColor,
+      borderColor: colors.borderColor,
+      borderWidth: colors.borderWidth,
+      overflow: "hidden",
+      ...baseElevation
+    },
+    interactiveContainer: {
+      cursor: "pointer"
+    },
+    hoveredContainer: {
+      backgroundColor: colors.hoveredBackgroundColor,
+      ...variant === "elevated" ? elevationLevel2 : variant === "filled" ? elevationLevel1 : void 0
+    },
+    pressedContainer: {
+      backgroundColor: colors.pressedBackgroundColor
+    },
+    disabledContainer: {
+      backgroundColor: colors.disabledBackgroundColor,
+      borderColor: colors.disabledBorderColor,
+      cursor: "auto",
+      ...elevationLevel0
+    },
+    disabledContent: {
+      opacity: theme.stateLayer.disabledOpacity
+    }
+  });
+}
+
+// src/card/Card.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function Card({
+  children,
+  style,
+  variant = "elevated",
+  onPress,
+  disabled = false,
+  containerColor,
+  ...props
+}) {
+  const isDisabled = Boolean(disabled);
+  const isInteractive = onPress !== void 0;
+  const theme = (0, import_core.useTheme)();
+  const styles = (0, import_react.useMemo)(
+    () => createStyles(theme, variant, containerColor),
+    [theme, variant, containerColor]
+  );
+  if (!isInteractive) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native3.View, { ...props, style: [styles.container, style], children });
+  }
+  const resolvedStyle = (state) => [
+    styles.container,
+    styles.interactiveContainer,
+    state.hovered && !state.pressed && !isDisabled ? styles.hoveredContainer : void 0,
+    state.pressed && !isDisabled ? styles.pressedContainer : void 0,
+    isDisabled ? styles.disabledContainer : void 0,
+    typeof style === "function" ? style(state) : style
+  ];
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_react_native3.Pressable,
+    {
+      ...props,
+      role: "button",
+      accessibilityState: { disabled: isDisabled },
+      hitSlop: import_react_native3.Platform.OS === "web" ? void 0 : 4,
+      disabled: isDisabled,
+      onPress,
+      style: resolvedStyle,
+      children: isDisabled ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native3.View, { style: styles.disabledContent, children }) : children
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Card
+});

package/dist/checkbox/index.d.ts

@@ -0,0 +1,25 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { PressableProps } from 'react-native';
+
+interface CheckboxProps extends Omit<PressableProps, 'children'> {
+    /**
+     * Whether the checkbox is checked.
+     * @default false
+     */
+    value?: boolean;
+    /** Callback fired when the checkbox is toggled. Receives the new value. */
+    onValueChange?: (value: boolean) => void;
+    /**
+     * Override the container (box) color when checked.
+     * State-layer colors (hover, press) are derived automatically.
+     */
+    containerColor?: string;
+    /**
+     * Override the checkmark icon color.
+     */
+    contentColor?: string;
+}
+
+declare function Checkbox({ style, value, onValueChange, containerColor, contentColor, disabled, ...props }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+export { Checkbox, type CheckboxProps };

package/dist/checkbox/index.js

@@ -0,0 +1,291 @@
+"use strict";
+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/checkbox/index.ts
+var checkbox_exports = {};
+__export(checkbox_exports, {
+  Checkbox: () => Checkbox
+});
+module.exports = __toCommonJS(checkbox_exports);
+
+// src/checkbox/Checkbox.tsx
+var import_MaterialCommunityIcons = __toESM(require("@expo/vector-icons/MaterialCommunityIcons"));
+var import_react = require("react");
+var import_react_native2 = require("react-native");
+var import_core = require("@onlynative/core");
+
+// src/checkbox/styles.ts
+var import_react_native = require("react-native");
+
+// src/utils/color.ts
+function parseHexColor(color) {
+  const normalized = color.replace("#", "");
+  if (normalized.length !== 6 && normalized.length !== 8) {
+    return null;
+  }
+  const r = Number.parseInt(normalized.slice(0, 2), 16);
+  const g = Number.parseInt(normalized.slice(2, 4), 16);
+  const b = Number.parseInt(normalized.slice(4, 6), 16);
+  if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
+    return null;
+  }
+  return { r, g, b };
+}
+function clampAlpha(alpha) {
+  return Math.max(0, Math.min(1, alpha));
+}
+function alphaColor(color, alpha) {
+  const channels = parseHexColor(color);
+  const boundedAlpha = clampAlpha(alpha);
+  if (!channels) {
+    return color;
+  }
+  return `rgba(${channels.r}, ${channels.g}, ${channels.b}, ${boundedAlpha})`;
+}
+function blendColor(base, overlay, overlayAlpha) {
+  const baseChannels = parseHexColor(base);
+  const overlayChannels = parseHexColor(overlay);
+  const boundedAlpha = clampAlpha(overlayAlpha);
+  if (!baseChannels || !overlayChannels) {
+    return alphaColor(overlay, boundedAlpha);
+  }
+  const r = Math.round(
+    (1 - boundedAlpha) * baseChannels.r + boundedAlpha * overlayChannels.r
+  );
+  const g = Math.round(
+    (1 - boundedAlpha) * baseChannels.g + boundedAlpha * overlayChannels.g
+  );
+  const b = Math.round(
+    (1 - boundedAlpha) * baseChannels.b + boundedAlpha * overlayChannels.b
+  );
+  return `rgb(${r}, ${g}, ${b})`;
+}
+
+// src/checkbox/styles.ts
+function getColors(theme, checked) {
+  const disabledOnSurface38 = alphaColor(theme.colors.onSurface, 0.38);
+  if (checked) {
+    return {
+      backgroundColor: theme.colors.primary,
+      borderColor: "transparent",
+      borderWidth: 0,
+      iconColor: theme.colors.onPrimary,
+      hoveredBackgroundColor: blendColor(
+        theme.colors.primary,
+        theme.colors.onPrimary,
+        theme.stateLayer.hoveredOpacity
+      ),
+      pressedBackgroundColor: blendColor(
+        theme.colors.primary,
+        theme.colors.onPrimary,
+        theme.stateLayer.pressedOpacity
+      ),
+      disabledBackgroundColor: disabledOnSurface38,
+      disabledBorderColor: "transparent",
+      disabledBorderWidth: 0,
+      disabledIconColor: theme.colors.surface
+    };
+  }
+  return {
+    backgroundColor: "transparent",
+    borderColor: theme.colors.onSurfaceVariant,
+    borderWidth: 2,
+    iconColor: "transparent",
+    hoveredBackgroundColor: alphaColor(
+      theme.colors.onSurface,
+      theme.stateLayer.hoveredOpacity
+    ),
+    pressedBackgroundColor: alphaColor(
+      theme.colors.onSurface,
+      theme.stateLayer.pressedOpacity
+    ),
+    disabledBackgroundColor: "transparent",
+    disabledBorderColor: disabledOnSurface38,
+    disabledBorderWidth: 2,
+    disabledIconColor: "transparent"
+  };
+}
+function applyColorOverrides(theme, colors, containerColor, contentColor) {
+  if (!containerColor && !contentColor) return colors;
+  const result = { ...colors };
+  if (contentColor) {
+    result.iconColor = contentColor;
+  }
+  if (containerColor) {
+    const overlay = contentColor != null ? contentColor : colors.iconColor;
+    result.backgroundColor = containerColor;
+    result.borderColor = containerColor;
+    result.hoveredBackgroundColor = blendColor(
+      containerColor,
+      overlay,
+      theme.stateLayer.hoveredOpacity
+    );
+    result.pressedBackgroundColor = blendColor(
+      containerColor,
+      overlay,
+      theme.stateLayer.pressedOpacity
+    );
+  }
+  return result;
+}
+function createStyles(theme, checked, containerColor, contentColor) {
+  const colors = applyColorOverrides(
+    theme,
+    getColors(theme, checked),
+    containerColor,
+    contentColor
+  );
+  const size = 18;
+  const touchTarget = 48;
+  return import_react_native.StyleSheet.create({
+    container: {
+      width: touchTarget,
+      height: touchTarget,
+      alignItems: "center",
+      justifyContent: "center",
+      cursor: "pointer"
+    },
+    hoveredContainer: {
+      borderRadius: touchTarget / 2,
+      backgroundColor: colors.hoveredBackgroundColor
+    },
+    pressedContainer: {
+      borderRadius: touchTarget / 2,
+      backgroundColor: colors.pressedBackgroundColor
+    },
+    disabledContainer: {
+      cursor: "auto"
+    },
+    box: {
+      width: size,
+      height: size,
+      borderRadius: theme.shape.cornerExtraSmall,
+      backgroundColor: colors.backgroundColor,
+      borderColor: colors.borderColor,
+      borderWidth: colors.borderWidth,
+      alignItems: "center",
+      justifyContent: "center"
+    },
+    disabledBox: {
+      backgroundColor: colors.disabledBackgroundColor,
+      borderColor: colors.disabledBorderColor,
+      borderWidth: colors.disabledBorderWidth
+    },
+    iconColor: {
+      color: colors.iconColor
+    },
+    disabledIconColor: {
+      color: colors.disabledIconColor
+    }
+  });
+}
+
+// src/checkbox/Checkbox.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function resolveStyle(containerStyle, hoveredContainerStyle, pressedContainerStyle, disabledContainerStyle, disabled, style) {
+  if (typeof style === "function") {
+    return (state) => [
+      containerStyle,
+      state.hovered && !state.pressed && !disabled ? hoveredContainerStyle : void 0,
+      state.pressed && !disabled ? pressedContainerStyle : void 0,
+      disabled ? disabledContainerStyle : void 0,
+      style(state)
+    ];
+  }
+  return (state) => [
+    containerStyle,
+    state.hovered && !state.pressed && !disabled ? hoveredContainerStyle : void 0,
+    state.pressed && !disabled ? pressedContainerStyle : void 0,
+    disabled ? disabledContainerStyle : void 0,
+    style
+  ];
+}
+function Checkbox({
+  style,
+  value = false,
+  onValueChange,
+  containerColor,
+  contentColor,
+  disabled = false,
+  ...props
+}) {
+  const isDisabled = Boolean(disabled);
+  const isChecked = Boolean(value);
+  const theme = (0, import_core.useTheme)();
+  const styles = (0, import_react.useMemo)(
+    () => createStyles(theme, isChecked, containerColor, contentColor),
+    [theme, isChecked, containerColor, contentColor]
+  );
+  const resolvedIconColor = (0, import_react.useMemo)(() => {
+    const base = import_react_native2.StyleSheet.flatten([
+      styles.iconColor,
+      isDisabled ? styles.disabledIconColor : void 0
+    ]);
+    return typeof (base == null ? void 0 : base.color) === "string" ? base.color : void 0;
+  }, [styles.iconColor, styles.disabledIconColor, isDisabled]);
+  const handlePress = () => {
+    if (!isDisabled) {
+      onValueChange == null ? void 0 : onValueChange(!isChecked);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_react_native2.Pressable,
+    {
+      ...props,
+      accessibilityRole: "checkbox",
+      accessibilityState: {
+        disabled: isDisabled,
+        checked: isChecked
+      },
+      hitSlop: import_react_native2.Platform.OS === "web" ? void 0 : 4,
+      disabled: isDisabled,
+      onPress: handlePress,
+      style: resolveStyle(
+        styles.container,
+        styles.hoveredContainer,
+        styles.pressedContainer,
+        styles.disabledContainer,
+        isDisabled,
+        style
+      ),
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native2.View, { style: [styles.box, isDisabled ? styles.disabledBox : void 0], children: isChecked ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_MaterialCommunityIcons.default,
+        {
+          name: "check",
+          size: 14,
+          color: resolvedIconColor
+        }
+      ) : null })
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Checkbox
+});

package/dist/chip/index.d.ts

@@ -0,0 +1,62 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import MaterialCommunityIcons from '@expo/vector-icons/MaterialCommunityIcons';
+import { ComponentProps, ReactNode } from 'react';
+import { PressableProps, StyleProp, TextStyle } from 'react-native';
+
+/** Visual variant of the chip following Material Design 3 chip types. */
+type ChipVariant = 'assist' | 'filter' | 'input' | 'suggestion';
+interface ChipProps extends Omit<PressableProps, 'children'> {
+    /** Text label rendered inside the chip. */
+    children: string;
+    /**
+     * Chip type variant. Controls appearance, allowed interactions, and icon behavior.
+     * @default 'assist'
+     */
+    variant?: ChipVariant;
+    /**
+     * Whether the chip uses an elevated surface instead of an outline border.
+     * Available on `assist`, `filter`, and `suggestion` variants.
+     * Ignored on `input` variant (always outlined).
+     * @default false
+     */
+    elevated?: boolean;
+    /**
+     * Whether the chip is in a selected (toggled-on) state.
+     * Only meaningful for the `filter` variant. Ignored by other variants.
+     */
+    selected?: boolean;
+    /** Name of a MaterialCommunityIcons icon to show before the label. */
+    leadingIcon?: ComponentProps<typeof MaterialCommunityIcons>['name'];
+    /**
+     * Size of the leading icon in dp.
+     * @default 18
+     */
+    iconSize?: number;
+    /**
+     * Custom avatar content (e.g. a small Image or View) to render before the label.
+     * Only applicable to the `input` variant. Takes precedence over `leadingIcon`.
+     */
+    avatar?: ReactNode;
+    /**
+     * Callback fired when the close/remove icon is pressed.
+     * When provided, renders a trailing close icon.
+     * Only renders on `input` and `filter` (when selected) variants.
+     */
+    onClose?: () => void;
+    /**
+     * Override the container (background) color.
+     * State-layer colors (hover, press) are derived automatically.
+     */
+    containerColor?: string;
+    /**
+     * Override the content (label and icon) color.
+     * State-layer colors are derived automatically when no containerColor is set.
+     */
+    contentColor?: string;
+    /** Additional style applied to the label text. */
+    labelStyle?: StyleProp<TextStyle>;
+}
+
+declare function Chip({ children, style, variant, elevated, selected, leadingIcon, iconSize, avatar, onClose, containerColor, contentColor, labelStyle: labelStyleOverride, disabled, ...props }: ChipProps): react_jsx_runtime.JSX.Element;
+
+export { Chip, type ChipProps, type ChipVariant };