@rocapine/react-native-onboarding 1.26.0 → 1.28.0

package/src/steps/ComposableScreen/elements/WheelPickerElement.ts

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import { BaseBoxProps, BaseBoxPropsSchema } from "./BaseBoxProps";
+
+export type WheelPickerItem = { label: string; value: string };
+
+export type WheelPickerRange = {
+  min: number;
+  max: number;
+  step?: number;
+  unit?: string;
+};
+
+export type WheelPickerElementProps = BaseBoxProps & {
+  variableName?: string;
+  defaultValue?: string;
+  /** Explicit option list. Mutually exclusive with `range`. */
+  items?: WheelPickerItem[];
+  /** Numeric range that auto-generates options. Mutually exclusive with `items`. */
+  range?: WheelPickerRange;
+  /** Text color of the wheel items. */
+  itemColor?: string;
+  /** Font size of the wheel items (iOS `itemStyle`). */
+  itemFontSize?: number;
+  /** Font family of the wheel items (iOS `itemStyle`). */
+  itemFontFamily?: string;
+};
+
+// Hard cap on generated range items — guards against runaway ranges
+// (e.g. min 0 / max 1e9 / step 0.01) producing millions of <Picker.Item>.
+const RANGE_MAX_ITEMS = 1000;
+
+/**
+ * Expand a numeric `range` into wheel items. Shared by the UI renderer,
+ * default-collection, and schema validation so all three agree on the exact
+ * generated value set (and its string formatting).
+ */
+export function generateWheelPickerRangeItems(range: WheelPickerRange): WheelPickerItem[] {
+  const step = range.step ?? 1;
+  const items: WheelPickerItem[] = [];
+  if (!(step > 0) || range.max < range.min) return items;
+  for (let i = 0; i < RANGE_MAX_ITEMS; i++) {
+    const raw = range.min + i * step;
+    if (raw > range.max + 1e-9) break;
+    // Trim float accumulation noise (e.g. 0.30000000000000004 → 0.3).
+    const value = Math.round(raw * 1e6) / 1e6;
+    const valueStr = String(value);
+    const label = range.unit ? `${valueStr} ${range.unit}` : valueStr;
+    items.push({ label, value: valueStr });
+  }
+  return items;
+}
+
+/**
+ * Resolve the effective item list for a WheelPicker: explicit `items` win,
+ * otherwise the numeric `range` is expanded. Returns `[]` when neither is set.
+ */
+export function resolveWheelPickerItems(props: WheelPickerElementProps): WheelPickerItem[] {
+  if (props.items && props.items.length > 0) return props.items;
+  if (props.range) return generateWheelPickerRangeItems(props.range);
+  return [];
+}
+
+const WheelPickerItemSchema = z.object({
+  label: z.string().trim().min(1, "item label must not be empty"),
+  value: z.string().trim().min(1, "item value must not be empty"),
+});
+
+const WheelPickerRangeSchema = z.object({
+  min: z.number(),
+  max: z.number(),
+  step: z.number().positive().optional(),
+  unit: z.string().optional(),
+});
+
+export const WheelPickerElementPropsSchema = BaseBoxPropsSchema.extend({
+  variableName: z.string().optional(),
+  defaultValue: z.string().optional(),
+  items: z.array(WheelPickerItemSchema).min(1, "items must not be empty").optional(),
+  range: WheelPickerRangeSchema.optional(),
+  itemColor: z.string().optional(),
+  itemFontSize: z.number().optional(),
+  itemFontFamily: z.string().optional(),
+}).superRefine((data, ctx) => {
+  const hasItems = data.items !== undefined;
+  const hasRange = data.range !== undefined;
+  // Exactly one source must be present — both or neither is ambiguous.
+  if (hasItems === hasRange) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "provide exactly one of `items` or `range`",
+      path: hasItems ? ["range"] : ["items"],
+    });
+    return;
+  }
+  if (hasRange && data.range!.max < data.range!.min) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "range.max must be >= range.min",
+      path: ["range", "max"],
+    });
+    return;
+  }
+  const values = resolveWheelPickerItems(data as WheelPickerElementProps).map((i) => i.value);
+  const unique = new Set(values);
+  if (hasItems && unique.size !== values.length) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: "item values must be unique", path: ["items"] });
+  }
+  if (data.defaultValue !== undefined && !unique.has(data.defaultValue)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "defaultValue must match one of the available values",
+      path: ["defaultValue"],
+    });
+  }
+});

package/src/steps/ComposableScreen/types.ts

@@ -18,6 +18,7 @@ import { type ButtonElementProps, ButtonElementPropsSchema } from "./elements/Bu
 import { type RadioGroupElementProps, RadioGroupElementPropsSchema } from "./elements/RadioGroupElement";
 import { type CheckboxGroupElementProps, CheckboxGroupElementPropsSchema } from "./elements/CheckboxGroupElement";
 import { type DatePickerElementProps, DatePickerElementPropsSchema } from "./elements/DatePickerElement";
+import { type WheelPickerElementProps, WheelPickerElementPropsSchema } from "./elements/WheelPickerElement";
 import { type CarouselElementProps, CarouselElementPropsSchema } from "./elements/CarouselElement";
 import { type ZStackElementProps, ZStackElementPropsSchema } from "./elements/ZStackElement";
 import { type SafeAreaViewElementProps, SafeAreaViewElementPropsSchema } from "./elements/SafeAreaViewElement";
@@ -42,6 +43,8 @@ export { ButtonActionSchema, CustomButtonActionSchema } from "./elements/ButtonE
 export type { RadioGroupElementProps } from "./elements/RadioGroupElement";
 export type { CheckboxGroupElementProps } from "./elements/CheckboxGroupElement";
 export type { DatePickerElementProps } from "./elements/DatePickerElement";
+export type { WheelPickerElementProps, WheelPickerItem, WheelPickerRange } from "./elements/WheelPickerElement";
+export { WheelPickerElementPropsSchema, generateWheelPickerRangeItems, resolveWheelPickerItems } from "./elements/WheelPickerElement";
 export type { CarouselElementProps } from "./elements/CarouselElement";
 export type { ZStackElementProps } from "./elements/ZStackElement";
 export type { SafeAreaViewElementProps, SafeAreaEdge, SafeAreaEdgeMode } from "./elements/SafeAreaViewElement";
@@ -156,6 +159,13 @@ type UIElement =
       type: "DatePicker";
       props: DatePickerElementProps;
     }
+  | {
+      id: string;
+      name?: string;
+      renderWhen?: LeafCondition | ConditionGroup;
+      type: "WheelPicker";
+      props: WheelPickerElementProps;
+    }
   | {
       id: string;
       name?: string;
@@ -284,6 +294,13 @@ const UIElementSchema: z.ZodType<UIElement> = z.lazy(() =>
       type: z.literal("DatePicker"),
       props: DatePickerElementPropsSchema,
     }),
+    z.object({
+      id: z.string(),
+      name: z.string().optional(),
+      renderWhen: z.union([LeafConditionSchema, ConditionGroupSchema]).optional(),
+      type: z.literal("WheelPicker"),
+      props: WheelPickerElementPropsSchema,
+    }),
     z.object({
       id: z.string(),
       name: z.string().optional(),

package/src/steps/common.types.ts

@@ -41,9 +41,32 @@ export const ConditionOperatorSchema = z.enum([
   "contains",
   "in",
   "not_in",
+  // Unary presence operators — no `value` required. `empty` is type-aware
+  // (empty string / empty array / null|undefined); `null` is strictly
+  // null|undefined (a set-but-empty value is "not null" yet "is empty").
+  "is_empty",
+  "is_not_empty",
+  "is_null",
+  "is_not_null",
 ]);
 export type ConditionOperator = z.infer<typeof ConditionOperatorSchema>;
 
+/**
+ * Operators that test the variable alone and ignore `value`. A LeafCondition
+ * using one of these may omit `value`; all other operators require it.
+ */
+export const UNARY_CONDITION_OPERATORS = [
+  "is_empty",
+  "is_not_empty",
+  "is_null",
+  "is_not_null",
+] as const satisfies readonly ConditionOperator[];
+
+const UNARY_OPERATOR_SET = new Set<ConditionOperator>(UNARY_CONDITION_OPERATORS);
+
+export const isUnaryConditionOperator = (operator: ConditionOperator): boolean =>
+  UNARY_OPERATOR_SET.has(operator);
+
 export const ConditionValueSchema = z.union([
   z.string(),
   z.number(),
@@ -52,11 +75,21 @@ export const ConditionValueSchema = z.union([
 ]);
 export type ConditionValue = z.infer<typeof ConditionValueSchema>;
 
-export const LeafConditionSchema = z.object({
-  variable: z.string().min(1),
-  operator: ConditionOperatorSchema,
-  value: ConditionValueSchema,
-});
+export const LeafConditionSchema = z
+  .object({
+    variable: z.string().min(1),
+    operator: ConditionOperatorSchema,
+    value: ConditionValueSchema.optional(),
+  })
+  .superRefine((data, ctx) => {
+    if (!isUnaryConditionOperator(data.operator) && data.value === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `operator "${data.operator}" requires a value`,
+        path: ["value"],
+      });
+    }
+  });
 export type LeafCondition = z.infer<typeof LeafConditionSchema>;
 
 export type ConditionGroup = {