tyrell-react 1.0.0-TC7

package/src/components/TyDropdown.tsx

@@ -0,0 +1,205 @@
+import React, { useEffect, useRef, useCallback } from 'react';
+
+// 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;
+  
+  /** Make dropdown readonly */
+  readonly?: boolean;
+  
+  /** Required field */
+  required?: boolean;
+  
+  /** Enable search functionality */
+  searchable?: boolean;
+  
+  /** Show clear button */
+  clearable?: boolean;
+  
+  /** Disable clear button (alias for clearable={false}) */
+  notClearable?: boolean;
+  
+  /** Debounce in milliseconds (0-5000) */
+  debounce?: number;
+  
+  /** Disable search functionality (ClojureScript: not-searchable) */
+  notSearchable?: boolean;
+  
+  /** @deprecated Use notSearchable instead. External search handling */
+  externalSearch?: 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, 
+    notSearchable,
+    externalSearch,
+    clearable,
+    notClearable,
+    debounce,
+    name,
+    ...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]);
+
+    // 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;
+    };
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    // Add conditional attributes
+    if (disabled) webComponentProps.disabled = '';
+    
+    // Handle search functionality (prefer not-searchable over deprecated externalSearch)
+    if (notSearchable) {
+      webComponentProps['not-searchable'] = '';
+    } else if (externalSearch) {
+      // Support deprecated externalSearch for backward compatibility
+      webComponentProps['not-searchable'] = '';
+    }
+    
+    // Handle clearable functionality
+    if (clearable !== undefined) {
+      if (clearable) {
+        webComponentProps.clearable = '';
+      } else {
+        webComponentProps['not-clearable'] = '';
+      }
+    }
+    
+    if (notClearable) {
+      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/TyIcon.tsx

@@ -0,0 +1,72 @@
+import React, { useEffect, useRef } from 'react';
+
+// 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]);
+
+    // 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 (spin) {
+      webComponentProps.spin = '';  // Boolean attributes as empty string
+    }
+
+    if (pulse) {
+      webComponentProps.pulse = '';  // Boolean attributes as empty string
+    }
+
+    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';

package/src/components/TyInput.tsx

@@ -0,0 +1,194 @@
+import React, { useEffect, useRef, useCallback } from 'react';
+
+// Event detail structure for ty-input events
+export interface TyInputEventDetail {
+  value: any; // shadow value (processed/parsed)
+  formattedValue: string; // user-visible formatted value
+  rawValue: string; // raw input value
+  originalEvent: Event; // original DOM event
+}
+
+export interface TyInputCSSProperties extends React.CSSProperties {
+  '--input-bg'?: string;
+  '--input-color'?: string;
+  '--input-border'?: string;
+  '--input-border-hover'?: string;
+  '--input-border-focus'?: string;
+  '--input-shadow-focus'?: string;
+  '--input-placeholder'?: string;
+  '--input-disabled-bg'?: string;
+  '--input-disabled-border'?: string;
+  '--input-disabled-color'?: string;
+}
+
+// Type definitions for Ty Input component
+export interface TyInputProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange' | 'onFocus' | 'onBlur' | 'style'> {
+  style?: TyInputCSSProperties;
+  /** Input type */
+  type?: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'search'
+  | 'currency' | 'percent' | 'compact';
+
+  /** Semantic styling variant */
+  flavor?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'neutral';
+
+  /** Input size */
+  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+  /** Input value */
+  value?: string;
+
+  /** Placeholder text */
+  placeholder?: string;
+
+  /** Input label */
+  label?: string;
+
+  /** Error message */
+  error?: string;
+
+  /** Disable the input */
+  disabled?: boolean;
+
+  /** Required field */
+  required?: boolean;
+
+  /** Form field name for form submission */
+  name?: string;
+
+  /** Checked state for checkbox inputs */
+  checked?: boolean;
+
+  // Numeric formatting props
+  currency?: string;
+  locale?: string;
+  precision?: string | number;
+
+  /** Debounce in milliseconds (0-5000) */
+  debounce?: number;
+
+  // React event handlers - override with our custom types
+  /**
+   * Fires on every keystroke (React convention)
+   * Maps to native 'input' event from ty-input
+   */
+  onChange?: (event: CustomEvent<TyInputEventDetail>) => void;
+
+  /**
+   * Fires on blur if value changed (native DOM behavior)
+   * Maps to native 'change' event from ty-input
+   */
+  onChangeCommit?: (event: CustomEvent<TyInputEventDetail>) => void;
+
+  /** Standard focus event */
+  onFocus?: (event: FocusEvent) => void;
+
+  /** Standard blur event */
+  onBlur?: (event: FocusEvent) => void;
+}
+
+// React wrapper for ty-input web component
+export const TyInput = React.forwardRef<HTMLElement, TyInputProps>(
+  ({ onChange, onChangeCommit, onFocus, onBlur, disabled, name, checked, debounce, ...props }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // Map onChange to input event (React convention)
+    const handleInput = useCallback((event: CustomEvent<TyInputEventDetail>) => {
+      if (onChange) {
+        onChange(event);
+      }
+    }, [onChange]);
+
+    // Map onChangeCommit to change event (blur behavior)
+    const handleChangeCommit = useCallback((event: CustomEvent<TyInputEventDetail>) => {
+      if (onChangeCommit) {
+        onChangeCommit(event);
+      }
+    }, [onChangeCommit]);
+
+    const handleFocus = useCallback((event: FocusEvent) => {
+      if (onFocus) {
+        onFocus(event);
+      }
+    }, [onFocus]);
+
+    const handleBlur = useCallback((event: FocusEvent) => {
+      if (onBlur) {
+        onBlur(event);
+      }
+    }, [onBlur]);
+
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      // Listen for custom input/change events from ty-input
+      // Map onChange → input event (React convention)
+      if (onChange) {
+        element.addEventListener('input', handleInput as EventListener);
+      }
+
+      // Map onChangeCommit → change event (blur behavior)
+      if (onChangeCommit) {
+        element.addEventListener('change', handleChangeCommit as EventListener);
+      }
+
+      // Listen for standard focus/blur events
+      if (onFocus) {
+        element.addEventListener('focus', handleFocus as EventListener);
+      }
+
+      if (onBlur) {
+        element.addEventListener('blur', handleBlur as EventListener);
+      }
+
+      return () => {
+        if (onChange) {
+          element.removeEventListener('input', handleInput as EventListener);
+        }
+        if (onChangeCommit) {
+          element.removeEventListener('change', handleChangeCommit as EventListener);
+        }
+        if (onFocus) {
+          element.removeEventListener('focus', handleFocus as EventListener);
+        }
+        if (onBlur) {
+          element.removeEventListener('blur', handleBlur as EventListener);
+        }
+      };
+    }, [handleInput, handleChangeCommit, handleFocus, handleBlur, onChange, onChangeCommit, onFocus, onBlur]);
+
+    // 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 conditional attributes
+    if (disabled) webComponentProps.disabled = '';
+    if (checked) webComponentProps.checked = '';
+
+    // Add string attributes
+    if (name) webComponentProps.name = name;
+
+    // Add debounce attribute
+    if (debounce !== undefined) webComponentProps.debounce = debounce;
+
+    return React.createElement(
+      'ty-input',
+      webComponentProps
+    );
+  }
+);
+
+TyInput.displayName = 'TyInput';

package/src/components/TyModal.tsx

@@ -0,0 +1,142 @@
+import React, { useEffect, useRef, useImperativeHandle } from 'react';
+
+// Event detail structure for modal events
+export interface TyModalEventDetail {
+  reason?: 'programmatic' | 'native' | 'backdrop' | 'escape' | 'close-button';
+  returnValue?: string;
+}
+
+// Type definitions for Ty Modal component
+export interface TyModalProps extends React.HTMLAttributes<HTMLElement> {
+  /** Controls modal visibility */
+  open?: boolean;
+  
+  /** Show backdrop behind modal (default: true) */
+  backdrop?: boolean;
+  
+  /** Allow closing modal by clicking backdrop (default: true) */
+  closeOnOutsideClick?: boolean;
+  
+  /** Allow closing modal with Escape key (default: true) */
+  closeOnEscape?: boolean;
+  
+  /** Require confirmation before closing when there are unsaved changes */
+  protected?: boolean;
+  
+  /** React event handlers */
+  onOpen?: (event: CustomEvent<TyModalEventDetail>) => void;
+  onClose?: (event: CustomEvent<TyModalEventDetail>) => void;
+  
+  /** Modal content */
+  children?: React.ReactNode;
+}
+
+// Ref interface for imperative methods
+export interface TyModalRef {
+  show: () => void;
+  hide: () => void;
+  element: HTMLElement | null;
+}
+
+// React wrapper for ty-modal web component
+export const TyModal = React.forwardRef<TyModalRef, TyModalProps>(
+  ({ 
+    open, 
+    backdrop, 
+    closeOnOutsideClick, 
+    closeOnEscape, 
+    protected: isProtected,
+    onOpen, 
+    onClose, 
+    children, 
+    ...props 
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // Expose imperative methods through ref
+    useImperativeHandle(ref, () => ({
+      show: () => {
+        if (elementRef.current && typeof (elementRef.current as any).show === 'function') {
+          (elementRef.current as any).show();
+        }
+      },
+      hide: () => {
+        if (elementRef.current && typeof (elementRef.current as any).hide === 'function') {
+          (elementRef.current as any).hide();
+        }
+      },
+      element: elementRef.current,
+    }), []);
+
+    // Handle modal events
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      const handleOpen = (event: CustomEvent<TyModalEventDetail>) => {
+        if (onOpen) {
+          onOpen(event);
+        }
+      };
+
+      const handleClose = (event: CustomEvent<TyModalEventDetail>) => {
+        if (onClose) {
+          onClose(event);
+        }
+      };
+
+      // Listen for custom modal events
+      if (onOpen) {
+        element.addEventListener('open', handleOpen as EventListener);
+      }
+
+      if (onClose) {
+        element.addEventListener('close', handleClose as EventListener);
+      }
+
+      return () => {
+        if (onOpen) {
+          element.removeEventListener('open', handleOpen as EventListener);
+        }
+        if (onClose) {
+          element.removeEventListener('close', handleClose as EventListener);
+        }
+      };
+    }, [onOpen, onClose]);
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    // Add boolean attributes using correct HTML attribute names
+    if (open) {
+      webComponentProps.open = '';  // Boolean attributes as empty string
+    }
+
+    if (backdrop === false) {  // Only set if explicitly false (default is true)
+      webComponentProps.backdrop = 'false';
+    }
+
+    if (closeOnOutsideClick === false) {  // Only set if explicitly false (default is true)
+      webComponentProps['close-on-outside-click'] = 'false';
+    }
+
+    if (closeOnEscape === false) {  // Only set if explicitly false (default is true)
+      webComponentProps['close-on-escape'] = 'false';
+    }
+
+    if (isProtected) {
+      webComponentProps.protected = '';  // Boolean attributes as empty string
+    }
+
+    return React.createElement(
+      'ty-modal',
+      webComponentProps,
+      children
+    );
+  }
+);
+
+TyModal.displayName = 'TyModal';