tyrell-react 1.0.0-RC10

package/src/components/TyDatePicker.tsx

@@ -0,0 +1,215 @@
+import React, { useEffect, useRef, useCallback } from 'react';
+import { needsPropertyBridge } from '../utils/react-version';
+import { useBooleanProperty } from '../utils/use-boolean-prop';
+
+// Type definitions for Ty DatePicker component
+export interface TyDatePickerEventDetail {
+  /** The selected date value (ISO string or formatted string based on format) */
+  value: string | null;
+  /** The selected date as milliseconds since epoch */
+  milliseconds: number | null;
+  /** Source of the change: "selection" | "time-change" | "clear" | "external" */
+  source: 'selection' | 'time-change' | 'clear' | 'external';
+  /** Formatted display value */
+  formatted: string | null;
+}
+
+export interface TyDatePickerProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange'> {
+  /** The selected date value (ISO string or formatted string) */
+  value?: string;
+  
+  /** Input size: "sm" | "md" | "lg" */
+  size?: 'sm' | 'md' | 'lg';
+  
+  /** Visual flavor: "default" | "success" | "danger" | "warning" */
+  flavor?: 'default' | 'success' | 'danger' | 'warning';
+  
+  /** Label text displayed above the input */
+  label?: string;
+  
+  /** Placeholder text when no date is selected */
+  placeholder?: string;
+  
+  /** Whether the field is required */
+  required?: boolean;
+  
+  /** Whether the field is disabled */
+  disabled?: boolean;
+  
+  /** Form field name for form submission */
+  name?: string;
+  
+  /** Whether to show a clear button */
+  clearable?: boolean;
+  
+  /** Date format: "short" | "medium" | "long" | "full" | custom format string */
+  format?: 'short' | 'medium' | 'long' | 'full' | string;
+  
+  /** Locale for date formatting (e.g., "en-US", "de-DE") */
+  locale?: string;
+  
+  /** Whether to include time selection */
+  withTime?: boolean;
+  
+  /** Callback when the date value changes */
+  onChange?: (event: CustomEvent<TyDatePickerEventDetail>) => void;
+  
+  /** Callback when the dropdown opens */
+  onOpen?: (event: CustomEvent<{}>) => void;
+  
+  /** Callback when the dropdown closes */
+  onClose?: (event: CustomEvent<{}>) => void;
+}
+
+// React wrapper for ty-date-picker web component
+export const TyDatePicker = React.forwardRef<HTMLElement, TyDatePickerProps>(
+  ({ 
+    value,
+    size,
+    flavor,
+    label,
+    placeholder,
+    required,
+    disabled,
+    name,
+    clearable,
+    format,
+    locale,
+    withTime,
+    onChange,
+    onOpen,
+    onClose,
+    ...props 
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // Handle ref forwarding
+    useEffect(() => {
+      if (ref && elementRef.current) {
+        if (typeof ref === 'function') {
+          ref(elementRef.current);
+        } else {
+          ref.current = elementRef.current;
+        }
+      }
+    }, [ref]);
+
+    // Sync value property with the web component.
+    // React 18 workaround: prop-to-property bridging is unreliable for empty
+    // strings on custom elements. React 19+ handles this natively.
+    useEffect(() => {
+      if (!needsPropertyBridge) return;
+      const element = elementRef.current;
+      if (element && value !== undefined) {
+        // Set the value property directly on the element
+        (element as any).value = value || '';
+      }
+    }, [value]);
+
+    // Handle change events
+    const handleChange = useCallback((event: Event) => {
+      const customEvent = event as CustomEvent<TyDatePickerEventDetail>;
+      if (onChange) {
+        onChange(customEvent);
+      }
+    }, [onChange]);
+
+    // Handle open/close events. Guard with `event.target === element` so
+    // bubbled open/close events from popup-like descendants slotted inside
+    // (rare for a date-picker, but defensive — same fix as TyModal/TyPopup)
+    // don't fire the consumer's onOpen/onClose.
+    const handleOpen = useCallback((event: Event) => {
+      if (event.target !== elementRef.current) return;
+      if (onOpen) onOpen(event as CustomEvent<{}>);
+    }, [onOpen]);
+
+    const handleClose = useCallback((event: Event) => {
+      if (event.target !== elementRef.current) return;
+      if (onClose) onClose(event as CustomEvent<{}>);
+    }, [onClose]);
+
+    // Set up event listeners
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      const listeners: Array<[string, EventListener]> = [];
+
+      if (onChange) {
+        element.addEventListener('change', handleChange);
+        listeners.push(['change', handleChange]);
+      }
+      
+      if (onOpen) {
+        element.addEventListener('open', handleOpen);
+        listeners.push(['open', handleOpen]);
+      }
+      
+      if (onClose) {
+        element.addEventListener('close', handleClose);
+        listeners.push(['close', handleClose]);
+      }
+
+      return () => {
+        listeners.forEach(([eventName, handler]) => {
+          element.removeEventListener(eventName, handler);
+        });
+      };
+    }, [handleChange, handleOpen, handleClose, onChange, onOpen, onClose]);
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    // Add optional attributes only if they have values
+    if (value !== undefined) {
+      webComponentProps.value = value;
+    }
+
+    if (size) {
+      webComponentProps.size = size;
+    }
+
+    if (flavor) {
+      webComponentProps.flavor = flavor;
+    }
+
+    if (label) {
+      webComponentProps.label = label;
+    }
+
+    if (placeholder) {
+      webComponentProps.placeholder = placeholder;
+    }
+
+    const isRequired = useBooleanProperty(elementRef, 'required', required);
+    const isDisabled = useBooleanProperty(elementRef, 'disabled', disabled);
+    const isClearable = useBooleanProperty(elementRef, 'clearable', clearable);
+
+    if (isRequired) webComponentProps.required = '';
+    if (isDisabled) webComponentProps.disabled = '';
+    if (isClearable) webComponentProps.clearable = '';
+
+    if (name) {
+      webComponentProps.name = name;
+    }
+
+    if (format) {
+      webComponentProps.format = format;
+    }
+
+    if (locale) {
+      webComponentProps.locale = locale;
+    }
+
+    if (withTime) {
+      webComponentProps['with-time'] = '';  // Convert camelCase to kebab-case
+    }
+
+    return React.createElement('ty-date-picker', webComponentProps);
+  }
+);
+
+TyDatePicker.displayName = 'TyDatePicker';

package/src/components/TyDropdown.tsx

@@ -0,0 +1,240 @@
+import React, { useEffect, useRef, useCallback } from 'react';
+import { needsPropertyBridge } from '../utils/react-version';
+import { useBooleanProperty, coerceBool } from '../utils/use-boolean-prop';
+
+// Option data structure for data-driven approach
+export interface OptionData {
+  value: string;
+  text: string;
+  disabled?: boolean;
+}
+
+// Event detail structure for dropdown events
+export interface TyDropdownEventDetail {
+  option: HTMLElement;
+}
+
+// Type definitions for Ty Dropdown component
+export interface TyDropdownProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange' | 'style'> {
+  style?: import('./TyInput').TyInputCSSProperties;
+  /** Semantic styling variant */
+  flavor?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'neutral';
+  
+  /** Dropdown size */
+  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+  
+  /** Selected value */
+  value?: string;
+  
+  /** Placeholder text */
+  placeholder?: string;
+  
+  /** Dropdown label */
+  label?: string;
+  
+  /** Disable the dropdown */
+  disabled?: boolean;
+
+  /**
+   * Loading state — replaces the open popup options list with a centered
+   * spinner. Search input stays usable. Pair with `externalSearch` while
+   * fetching results from a parent-owned data source.
+   */
+  loading?: boolean;
+
+  /** Make dropdown readonly */
+  readonly?: boolean;
+  
+  /** Required field */
+  required?: boolean;
+  
+  /** Show clear button */
+  clearable?: boolean;
+
+  /** Disable clear button (alias for clearable={false}) */
+  notClearable?: boolean;
+
+  /** Debounce in milliseconds (0-5000) */
+  debounce?: number;
+
+  /**
+   * Switch to external (remote) search mode. Default is `false` — the dropdown
+   * filters its options locally. When `true`, the dropdown stops filtering and
+   * dispatches `search` events on each keystroke; the parent owns filtering
+   * and updates the children.
+   */
+  externalSearch?: boolean;
+
+  /** @deprecated Use `externalSearch` instead. */
+  notSearchable?: boolean;
+
+  /** @deprecated Use `externalSearch` instead. Pass `searchable={false}` was equivalent to `externalSearch={true}`. */
+  searchable?: boolean;
+  
+  /** Form field name for form submission */
+  name?: string;
+  
+  // Data-driven approach
+  options?: OptionData[];
+  
+  // React event handlers
+  onChange?: (event: CustomEvent<TyDropdownEventDetail>) => void;
+  onSearch?: (event: CustomEvent<{ query: string; element: HTMLElement }>) => void;
+  
+  // Children for slotted approach
+  children?: React.ReactNode;
+}
+
+// React wrapper for ty-dropdown web component
+export const TyDropdown = React.forwardRef<HTMLElement, TyDropdownProps>(
+  ({
+    options,
+    children,
+    onChange,
+    onSearch,
+    disabled,
+    loading,
+    externalSearch,
+    notSearchable,
+    searchable,
+    clearable,
+    notClearable,
+    debounce,
+    name,
+    value,
+    ...props
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    const handleChange = useCallback((event: CustomEvent<TyDropdownEventDetail>) => {
+      if (onChange) {
+        onChange(event);
+      }
+    }, [onChange]);
+
+    const handleSearch = useCallback((event: CustomEvent<{ query: string; element: HTMLElement }>) => {
+      if (onSearch) {
+        onSearch(event);
+      }
+    }, [onSearch]);
+
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      // Listen for custom events from ty-dropdown
+      if (onChange) {
+        element.addEventListener('change', handleChange as EventListener);
+      }
+
+      if (onSearch) {
+        element.addEventListener('search', handleSearch as EventListener);
+      }
+
+      return () => {
+        if (onChange) {
+          element.removeEventListener('change', handleChange as EventListener);
+        }
+        if (onSearch) {
+          element.removeEventListener('search', handleSearch as EventListener);
+        }
+      };
+    }, [handleChange, handleSearch, onChange, onSearch]);
+
+    // Imperatively sync `value` to the underlying element's property whenever
+    // it changes. React 18's prop-to-property bridging for custom elements is
+    // unreliable for empty strings (programmatic resets), so we set the
+    // property directly to guarantee the dropdown clears on `value=""`.
+    // React 19+ handles this natively, so the effect short-circuits there.
+    useEffect(() => {
+      if (!needsPropertyBridge) return;
+      const element = elementRef.current as any;
+      if (!element) return;
+      if (element.value !== value) {
+        element.value = value ?? '';
+      }
+    }, [value]);
+
+    // Handle ref forwarding
+    useEffect(() => {
+      if (ref && elementRef.current) {
+        if (typeof ref === 'function') {
+          ref(elementRef.current);
+        } else {
+          ref.current = elementRef.current;
+        }
+      }
+    }, [ref]);
+
+    // Render options from data if provided, otherwise use children
+    const renderContent = () => {
+      if (options && options.length > 0) {
+        // Data-driven approach - create ty-option elements
+        return options.map((option, index) => 
+          React.createElement(
+            'ty-option',
+            {
+              key: option.value || index,
+              value: option.value,
+              ...(option.disabled && { disabled: "" }),
+            },
+            option.text
+          )
+        );
+      }
+      
+      // Slotted approach - use provided children
+      return children;
+    };
+
+    // Imperative property sync for boolean props (see use-boolean-prop.ts).
+    const isDisabled = useBooleanProperty(elementRef, 'disabled', disabled);
+    const isLoading = useBooleanProperty(elementRef, 'loading', loading);
+    const isExternalSearch = coerceBool(externalSearch) || coerceBool(notSearchable) || searchable === false;
+    useBooleanProperty(elementRef, 'externalSearch', isExternalSearch);
+    // clearable: explicit boolean OR the `notClearable` alias inverts it
+    const isClearable = clearable !== undefined
+      ? coerceBool(clearable)
+      : (coerceBool(notClearable) ? false : undefined);
+    useEffect(() => {
+      if (!needsPropertyBridge) return;
+      if (isClearable === undefined) return;
+      const el = elementRef.current as any;
+      if (!el) return;
+      if (Boolean(el.clearable) !== isClearable) el.clearable = isClearable;
+    }, [isClearable]);
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    if (isDisabled) webComponentProps.disabled = '';
+    if (isLoading) webComponentProps.loading = '';
+    if (isExternalSearch) webComponentProps['external-search'] = '';
+
+    // Handle clearable functionality
+    if (isClearable === true) {
+      webComponentProps.clearable = '';
+    } else if (isClearable === false) {
+      webComponentProps['not-clearable'] = '';
+    }
+
+    // Add debounce attribute
+    if (debounce !== undefined) {
+      webComponentProps.debounce = debounce;
+    }
+
+    // Add string attributes
+    if (name) webComponentProps.name = name;
+
+    return React.createElement(
+      'ty-dropdown',
+      webComponentProps,
+      renderContent()
+    );
+  }
+);
+
+TyDropdown.displayName = 'TyDropdown';

package/src/components/TyFileUpload.tsx

@@ -0,0 +1,108 @@
+import React, { useEffect, useRef } from 'react';
+import { useBooleanProperty } from '../utils/use-boolean-prop';
+
+// Type definitions for Ty File Upload component
+export interface TyFileUploadProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange'> {
+  /** Form field name — used as the FormData key */
+  name?: string;
+
+  /** Allow selecting multiple files */
+  multiple?: boolean;
+
+  /** File type filter passed to the underlying input (e.g. "image/*", ".pdf,.docx") */
+  accept?: string;
+
+  /** Field label rendered above the drop zone */
+  label?: string;
+
+  /** Hint text shown inside the drop zone when no files are selected */
+  placeholder?: string;
+
+  /** Disable interaction */
+  disabled?: boolean;
+
+  /** Mark the field as required (shows asterisk) */
+  required?: boolean;
+
+  /** Validation error message — also applies danger border styling */
+  error?: string;
+
+  /**
+   * Fires when the selection changes — browse, drag-drop, or remove.
+   * Maps to the native 'change' event from ty-file-upload.
+   */
+  onChange?: (event: CustomEvent<TyFileUploadEventDetail>) => void;
+}
+
+export interface TyFileUploadEventDetail {
+  value: File[];
+  files: File[];
+  names: string[];
+}
+
+// React wrapper for ty-file-upload web component
+export const TyFileUpload = React.forwardRef<HTMLElement, TyFileUploadProps>(
+  ({
+    name,
+    multiple,
+    accept,
+    label,
+    placeholder,
+    disabled,
+    required,
+    error,
+    onChange,
+    ...props
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      const handleChange = (event: Event) => {
+        if (onChange) {
+          onChange(event as CustomEvent<TyFileUploadEventDetail>);
+        }
+      };
+
+      element.addEventListener('change', handleChange);
+      return () => {
+        element.removeEventListener('change', handleChange);
+      };
+    }, [onChange]);
+
+    useEffect(() => {
+      if (ref && elementRef.current) {
+        if (typeof ref === 'function') {
+          ref(elementRef.current);
+        } else {
+          ref.current = elementRef.current;
+        }
+      }
+    }, [ref]);
+
+    const isMultiple = useBooleanProperty(elementRef, 'multiple', multiple);
+    const isDisabled = useBooleanProperty(elementRef, 'disabled', disabled);
+    const isRequired = useBooleanProperty(elementRef, 'required', required);
+
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    if (isMultiple) webComponentProps.multiple = '';
+    if (isDisabled) webComponentProps.disabled = '';
+    if (isRequired) webComponentProps.required = '';
+
+    if (name) webComponentProps.name = name;
+    if (accept) webComponentProps.accept = accept;
+    if (label) webComponentProps.label = label;
+    if (placeholder) webComponentProps.placeholder = placeholder;
+    if (error) webComponentProps.error = error;
+
+    return React.createElement('ty-file-upload', webComponentProps);
+  }
+);
+
+TyFileUpload.displayName = 'TyFileUpload';

package/src/components/TyIcon.tsx

@@ -0,0 +1,71 @@
+import React, { useEffect, useRef } from 'react';
+import { useBooleanProperty } from '../utils/use-boolean-prop';
+
+// Type definitions for Ty Icon component
+export interface TyIconProps extends React.HTMLAttributes<HTMLElement> {
+  /** Icon name from the icon registry (e.g., 'home', 'star', 'settings') */
+  name: string;
+
+  /** Icon size - relative (em-based) or absolute (pixel-based) */
+  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '12' | '14' | '16' | '18' | '20' | '24' | '32' | '48';
+
+  /** Enable spinning animation */
+  spin?: boolean;
+
+  /** Enable pulse animation */
+  pulse?: boolean;
+
+  /** Animation tempo/speed */
+  tempo?: 'slow' | 'fast';
+
+  /** Additional CSS classes */
+  className?: string;
+}
+
+// React wrapper for ty-icon web component
+export const TyIcon = React.forwardRef<HTMLElement, TyIconProps>(
+  ({ name, size, spin, pulse, tempo, className, ...props }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // Handle ref forwarding
+    useEffect(() => {
+      if (ref && elementRef.current) {
+        if (typeof ref === 'function') {
+          ref(elementRef.current);
+        } else {
+          ref.current = elementRef.current;
+        }
+      }
+    }, [ref]);
+
+    const isSpin = useBooleanProperty(elementRef, 'spin', spin);
+    const isPulse = useBooleanProperty(elementRef, 'pulse', pulse);
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      name,
+      ref: elementRef,
+    };
+
+    // Add optional attributes only if they have values
+    if (size) {
+      webComponentProps.size = size;
+    }
+
+    if (isSpin) webComponentProps.spin = '';
+    if (isPulse) webComponentProps.pulse = '';
+
+    if (tempo) {
+      webComponentProps.tempo = tempo;
+    }
+
+    if (className) {
+      webComponentProps.class = className;  // HTML attribute is 'class', not 'className'
+    }
+
+    return React.createElement('ty-icon', webComponentProps);
+  }
+);
+
+TyIcon.displayName = 'TyIcon';