tyrell-react 1.0.0-TC7

package/src/components/TyCalendarNavigation.tsx

@@ -0,0 +1,91 @@
+import React, { useEffect, useRef } from 'react';
+
+// Type definitions for Ty Calendar Navigation component
+export interface TyCalendarNavigationProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange'> {
+  /** Display month (1-12) */
+  displayMonth?: number;
+  
+  /** Display year */
+  displayYear?: number;
+  
+  /** Locale for month name formatting */
+  locale?: string;
+  
+  /** Navigation size */
+  size?: 'sm' | 'md' | 'lg';
+  
+  /** Width of navigation */
+  width?: string;
+  
+  /** Navigation change event handler */
+  onChange?: (event: CustomEvent<NavigationChangeDetail>) => void;
+}
+
+export interface NavigationChangeDetail {
+  month: number;  // 1-12
+  year: number;   // e.g., 2025
+}
+
+// React wrapper for ty-calendar-navigation web component
+export const TyCalendarNavigation = React.forwardRef<HTMLElement, TyCalendarNavigationProps>(
+  ({ 
+    displayMonth,
+    displayYear,
+    locale,
+    size,
+    width,
+    onChange,
+    ...props 
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // Handle change events
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      const handleChange = (event: Event) => {
+        if (onChange) {
+          onChange(event as CustomEvent<NavigationChangeDetail>);
+        }
+      };
+
+      element.addEventListener('change', handleChange);
+
+      return () => {
+        element.removeEventListener('change', handleChange);
+      };
+    }, [onChange]);
+
+    // Combine refs if needed
+    useEffect(() => {
+      if (ref && elementRef.current) {
+        if (typeof ref === 'function') {
+          ref(elementRef.current);
+        } else {
+          ref.current = elementRef.current;
+        }
+      }
+    }, [ref]);
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    // Add attributes
+    if (displayMonth !== undefined) webComponentProps['display-month'] = displayMonth;
+    if (displayYear !== undefined) webComponentProps['display-year'] = displayYear;
+    if (locale) webComponentProps.locale = locale;
+    if (size) webComponentProps.size = size;
+    if (width) webComponentProps.width = width;
+
+    return React.createElement(
+      'ty-calendar-navigation',
+      webComponentProps
+    );
+  }
+);
+
+TyCalendarNavigation.displayName = 'TyCalendarNavigation';

package/src/components/TyCheckbox.tsx

@@ -0,0 +1,138 @@
+import React, { useEffect, useRef } from 'react';
+
+// Type definitions for Ty Checkbox component
+export interface TyCheckboxProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange' | 'onInput'> {
+  /** Checked state */
+  checked?: boolean;
+  
+  /** Form field value when checked */
+  value?: string;
+  
+  /** Form field name */
+  name?: string;
+  
+  /** Disable the checkbox */
+  disabled?: boolean;
+  
+  /** Required field */
+  required?: boolean;
+  
+  /** Error message */
+  error?: string;
+  
+  /** Checkbox size */
+  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+  
+  /** Semantic styling variant */
+  flavor?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'neutral';
+  
+  /**
+   * Fires when checkbox state changes (React convention)
+   * Maps to native 'input' event from ty-checkbox
+   */
+  onChange?: (event: CustomEvent<TyCheckboxEventDetail>) => void;
+  
+  /**
+   * Fires on blur if value changed (native DOM behavior)
+   * Maps to native 'change' event from ty-checkbox
+   */
+  onChangeCommit?: (event: CustomEvent<TyCheckboxEventDetail>) => void;
+  
+  /** Checkbox label content */
+  children?: React.ReactNode;
+}
+
+export interface TyCheckboxEventDetail {
+  value: boolean;
+  checked: boolean;
+  formValue: string | null;
+  originalEvent: Event;
+}
+
+// React wrapper for ty-checkbox web component
+export const TyCheckbox = React.forwardRef<HTMLElement, TyCheckboxProps>(
+  ({ 
+    children, 
+    checked,
+    value,
+    name,
+    disabled,
+    required,
+    error,
+    size,
+    flavor,
+    onChange,
+    onChangeCommit,
+    ...props 
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // Handle change events
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      // Map onChange to input event (React convention)
+      const handleInput = (event: Event) => {
+        if (onChange) {
+          onChange(event as CustomEvent<TyCheckboxEventDetail>);
+        }
+      };
+
+      // Map onChangeCommit to change event (blur behavior)
+      const handleChangeCommit = (event: Event) => {
+        if (onChangeCommit) {
+          onChangeCommit(event as CustomEvent<TyCheckboxEventDetail>);
+        }
+      };
+
+      // Map onChange → input event (React convention)
+      element.addEventListener('input', handleInput);
+      
+      // Map onChangeCommit → change event (blur behavior)
+      element.addEventListener('change', handleChangeCommit);
+
+      return () => {
+        element.removeEventListener('input', handleInput);
+        element.removeEventListener('change', handleChangeCommit);
+      };
+    }, [onChange, onChangeCommit]);
+
+    // Combine refs if needed
+    useEffect(() => {
+      if (ref && elementRef.current) {
+        if (typeof ref === 'function') {
+          ref(elementRef.current);
+        } else {
+          ref.current = elementRef.current;
+        }
+      }
+    }, [ref]);
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    // Add boolean attributes
+    if (checked) webComponentProps.checked = '';
+    if (disabled) webComponentProps.disabled = '';
+    if (required) webComponentProps.required = '';
+    
+    // Add string attributes
+    if (value) webComponentProps.value = value;
+    if (name) webComponentProps.name = name;
+    if (error) webComponentProps.error = error;
+    if (size) webComponentProps.size = size;
+    if (flavor) webComponentProps.flavor = flavor;
+
+    return React.createElement(
+      'ty-checkbox',
+      webComponentProps,
+      children
+    );
+  }
+);
+
+TyCheckbox.displayName = 'TyCheckbox';

package/src/components/TyCopy.tsx

@@ -0,0 +1,78 @@
+import React, { useEffect, useRef } from 'react';
+
+// Type definitions for Ty Copy component
+export interface TyCopyProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange'> {
+  /** Text to copy */
+  value?: string;
+  
+  /** Field label */
+  label?: string;
+  
+  /** Component size */
+  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+  
+  /** Semantic styling variant */
+  flavor?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'neutral';
+  
+  /** Display format */
+  format?: 'text' | 'code';
+  
+  /** Multi-line display */
+  multiline?: boolean;
+  
+  /** Disable the field */
+  disabled?: boolean;
+  
+  /** Required field */
+  required?: boolean;
+}
+
+// React wrapper for ty-copy web component
+export const TyCopy = React.forwardRef<HTMLElement, TyCopyProps>(
+  ({ 
+    value,
+    label,
+    size,
+    flavor,
+    format,
+    multiline,
+    disabled,
+    required,
+    ...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]);
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    // Add string attributes
+    if (value) webComponentProps.value = value;
+    if (label) webComponentProps.label = label;
+    if (size) webComponentProps.size = size;
+    if (flavor) webComponentProps.flavor = flavor;
+    if (format) webComponentProps.format = format;
+    
+    // Add boolean attributes
+    if (multiline) webComponentProps.multiline = '';
+    if (disabled) webComponentProps.disabled = '';
+    if (required) webComponentProps.required = '';
+
+    return React.createElement('ty-copy', webComponentProps);
+  }
+);
+
+TyCopy.displayName = 'TyCopy';

package/src/components/TyDatePicker.tsx

@@ -0,0 +1,216 @@
+import React, { useEffect, useRef, useCallback } from 'react';
+
+// 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
+    useEffect(() => {
+      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 events
+    const handleOpen = useCallback((event: Event) => {
+      const customEvent = event as CustomEvent<{}>;
+      if (onOpen) {
+        onOpen(customEvent);
+      }
+    }, [onOpen]);
+
+    // Handle close events
+    const handleClose = useCallback((event: Event) => {
+      const customEvent = event as CustomEvent<{}>;
+      if (onClose) {
+        onClose(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;
+    }
+
+    if (required) {
+      webComponentProps.required = '';  // Boolean attributes as empty string
+    }
+
+    if (disabled) {
+      webComponentProps.disabled = '';  // Boolean attributes as empty string
+    }
+
+    if (name) {
+      webComponentProps.name = name;
+    }
+
+    if (clearable) {
+      webComponentProps.clearable = '';  // Boolean attributes as empty string
+    }
+
+    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';