tyrell-react 1.0.0-TC10

package/src/components/TyResizeObserver.tsx

@@ -0,0 +1,54 @@
+import React, { useEffect, useRef } from 'react';
+
+// Type definitions for Ty ResizeObserver component
+export interface TyResizeObserverProps extends React.HTMLAttributes<HTMLElement> {
+  /** Required unique identifier for size registry */
+  id: string;
+
+  /** Debounce in milliseconds (default: 0 = no debounce) */
+  debounce?: number;
+
+  /** Content to observe */
+  children?: React.ReactNode;
+}
+
+// React wrapper for ty-resize-observer web component
+export const TyResizeObserver = React.forwardRef<HTMLElement, TyResizeObserverProps>(
+  ({
+    children,
+    id,
+    debounce,
+    ...props
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // 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,
+      id,
+    };
+
+    // Add number attributes
+    if (debounce !== undefined) webComponentProps.debounce = debounce;
+
+    return React.createElement(
+      'ty-resize-observer',
+      webComponentProps,
+      children
+    );
+  }
+);
+
+TyResizeObserver.displayName = 'TyResizeObserver';

package/src/components/TyScrollContainer.tsx

@@ -0,0 +1,87 @@
+import React, { useEffect, useRef, useImperativeHandle } from 'react';
+
+// Type definitions for Ty ScrollContainer component
+export interface TyScrollContainerProps extends React.HTMLAttributes<HTMLElement> {
+  /** Maximum height of the scroll container */
+  maxHeight?: string;
+
+  /** Enable/disable scroll shadows (default: true) */
+  shadow?: boolean;
+
+  /** Hide native scrollbar */
+  hideScrollbar?: boolean;
+
+  /** Content to scroll */
+  children?: React.ReactNode;
+}
+
+// Ref interface for imperative methods
+export interface TyScrollContainerRef {
+  /** Force update shadows (useful after dynamic content changes) */
+  updateShadows: () => void;
+  /** Scroll to top */
+  scrollToTop: (smooth?: boolean) => void;
+  /** Scroll to bottom */
+  scrollToBottom: (smooth?: boolean) => void;
+  /** Get the underlying scroll element */
+  scrollElement: HTMLElement | null;
+  /** Get the native element */
+  element: HTMLElement | null;
+}
+
+// React wrapper for ty-scroll-container web component
+export const TyScrollContainer = React.forwardRef<TyScrollContainerRef, TyScrollContainerProps>(
+  ({
+    children,
+    maxHeight,
+    shadow,
+    hideScrollbar,
+    ...props
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // Expose imperative methods via ref
+    useImperativeHandle(ref, () => ({
+      updateShadows: () => {
+        const el = elementRef.current as any;
+        el?.updateShadows?.();
+      },
+      scrollToTop: (smooth = true) => {
+        const el = elementRef.current as any;
+        el?.scrollToTop?.(smooth);
+      },
+      scrollToBottom: (smooth = true) => {
+        const el = elementRef.current as any;
+        el?.scrollToBottom?.(smooth);
+      },
+      get scrollElement() {
+        const el = elementRef.current as any;
+        return el?.scrollElement ?? null;
+      },
+      get element() {
+        return elementRef.current;
+      }
+    }), []);
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    // Add string attributes
+    if (maxHeight) webComponentProps['max-height'] = maxHeight;
+
+    // Add boolean attributes
+    if (shadow === false) webComponentProps.shadow = 'false';
+    if (hideScrollbar) webComponentProps['hide-scrollbar'] = true;
+
+    return React.createElement(
+      'ty-scroll-container',
+      webComponentProps,
+      children
+    );
+  }
+);
+
+TyScrollContainer.displayName = 'TyScrollContainer';

package/src/components/TyStep.tsx

@@ -0,0 +1,71 @@
+import React, { useEffect, useRef } from 'react';
+
+// Type definitions for Ty Step component
+export interface TyStepProps extends React.HTMLAttributes<HTMLElement> {
+  /** Required unique identifier for the step */
+  id: string;
+
+  /** Main step title displayed in indicator */
+  label?: string;
+
+  /** Optional subtitle/description */
+  description?: string;
+
+  /** Whether the step is disabled */
+  disabled?: boolean;
+
+  /** User-controlled status override */
+  status?: 'completed' | 'active' | 'pending' | 'error';
+
+  /** Step content */
+  children?: React.ReactNode;
+}
+
+// React wrapper for ty-step web component
+export const TyStep = React.forwardRef<HTMLElement, TyStepProps>(
+  ({
+    children,
+    id,
+    label,
+    description,
+    disabled,
+    status,
+    ...props
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // 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,
+      id,
+    };
+
+    // Add string attributes
+    if (label) webComponentProps.label = label;
+    if (description) webComponentProps.description = description;
+    if (status) webComponentProps.status = status;
+
+    // Add boolean attributes
+    if (disabled) webComponentProps.disabled = true;
+
+    return React.createElement(
+      'ty-step',
+      webComponentProps,
+      children
+    );
+  }
+);
+
+TyStep.displayName = 'TyStep';

package/src/components/TySwitch.tsx

@@ -0,0 +1,108 @@
+import React, { useEffect, useRef } from 'react';
+
+export interface TySwitchProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange' | 'onInput'> {
+  /** Checked (on) state */
+  checked?: boolean;
+
+  /** Form field value when checked */
+  value?: string;
+
+  /** Form field name */
+  name?: string;
+
+  /** Disable the switch */
+  disabled?: boolean;
+
+  /** Required field */
+  required?: boolean;
+
+  /** Switch size */
+  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+  /** Semantic styling variant */
+  flavor?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'neutral';
+
+  /**
+   * Fires when switch state changes (React convention)
+   * Maps to native 'input' event from ty-switch
+   */
+  onChange?: (event: CustomEvent<TySwitchEventDetail>) => void;
+
+  /**
+   * Fires on blur if value changed (native DOM behavior)
+   * Maps to native 'change' event from ty-switch
+   */
+  onChangeCommit?: (event: CustomEvent<TySwitchEventDetail>) => void;
+}
+
+export interface TySwitchEventDetail {
+  value: boolean;
+  checked: boolean;
+  formValue: string | null;
+  originalEvent: Event;
+}
+
+export const TySwitch = React.forwardRef<HTMLElement, TySwitchProps>(
+  ({
+    checked,
+    value,
+    name,
+    disabled,
+    required,
+    size,
+    flavor,
+    onChange,
+    onChangeCommit,
+    ...props
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      const handleInput = (event: Event) => {
+        if (onChange) onChange(event as CustomEvent<TySwitchEventDetail>);
+      };
+      const handleChangeCommit = (event: Event) => {
+        if (onChangeCommit) onChangeCommit(event as CustomEvent<TySwitchEventDetail>);
+      };
+
+      element.addEventListener('input', handleInput);
+      element.addEventListener('change', handleChangeCommit);
+
+      return () => {
+        element.removeEventListener('input', handleInput);
+        element.removeEventListener('change', handleChangeCommit);
+      };
+    }, [onChange, onChangeCommit]);
+
+    useEffect(() => {
+      if (ref && elementRef.current) {
+        if (typeof ref === 'function') {
+          ref(elementRef.current);
+        } else {
+          ref.current = elementRef.current;
+        }
+      }
+    }, [ref]);
+
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    if (checked) webComponentProps.checked = '';
+    if (disabled) webComponentProps.disabled = '';
+    if (required) webComponentProps.required = '';
+
+    if (value) webComponentProps.value = value;
+    if (name) webComponentProps.name = name;
+    if (size) webComponentProps.size = size;
+    if (flavor) webComponentProps.flavor = flavor;
+
+    return React.createElement('ty-switch', webComponentProps);
+  }
+);
+
+TySwitch.displayName = 'TySwitch';

package/src/components/TyTab.tsx

@@ -0,0 +1,63 @@
+import React, { useEffect, useRef } from 'react';
+
+// Type definitions for Ty Tab component
+export interface TyTabProps extends React.HTMLAttributes<HTMLElement> {
+  /** Required unique identifier */
+  id: string;
+  
+  /** Simple text label */
+  label?: string;
+  
+  /** Whether the tab is disabled */
+  disabled?: boolean;
+  
+  /** Tab content */
+  children?: React.ReactNode;
+}
+
+// React wrapper for ty-tab web component
+export const TyTab = React.forwardRef<HTMLElement, TyTabProps>(
+  ({ 
+    children, 
+    id,
+    label,
+    disabled,
+    ...props 
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // 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 required attribute
+    webComponentProps.id = id;
+    
+    // Add boolean attributes
+    if (disabled) webComponentProps.disabled = '';
+    
+    // Add string attributes
+    if (label) webComponentProps.label = label;
+
+    return React.createElement(
+      'ty-tab',
+      webComponentProps,
+      children
+    );
+  }
+);
+
+TyTab.displayName = 'TyTab';

package/src/components/TyTabs.tsx

@@ -0,0 +1,93 @@
+import React, { useEffect, useRef } from 'react';
+
+// Type definitions for Ty Tabs component
+export interface TyTabsProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange'> {
+  /** Content area width (accepts px or %) */
+  width?: string;
+  
+  /** Total container height including buttons */
+  height?: string;
+  
+  /** ID of currently active tab */
+  active?: string;
+  
+  /** Position of tab buttons */
+  placement?: 'top' | 'bottom';
+  
+  /** Tab change event handler */
+  onChange?: (event: CustomEvent<TabChangeDetail>) => void;
+  
+  /** Tabs content (TyTab components) */
+  children?: React.ReactNode;
+}
+
+export interface TabChangeDetail {
+  activeId: string;
+  activeIndex: number;
+  previousId: string | null;
+  previousIndex: number | null;
+}
+
+// React wrapper for ty-tabs web component
+export const TyTabs = React.forwardRef<HTMLElement, TyTabsProps>(
+  ({ 
+    children, 
+    width,
+    height,
+    active,
+    placement,
+    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<TabChangeDetail>);
+        }
+      };
+
+      element.addEventListener('ty-tab-change', handleChange);
+
+      return () => {
+        element.removeEventListener('ty-tab-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 string attributes
+    if (width) webComponentProps.width = width;
+    if (height) webComponentProps.height = height;
+    if (active) webComponentProps.active = active;
+    if (placement) webComponentProps.placement = placement;
+
+    return React.createElement(
+      'ty-tabs',
+      webComponentProps,
+      children
+    );
+  }
+);
+
+TyTabs.displayName = 'TyTabs';

package/src/components/TyTag.tsx

@@ -0,0 +1,79 @@
+import React, { useEffect, useRef, useCallback } from 'react';
+
+// CSS custom properties that cascade into the shadow DOM for full color control
+export interface TyTagCSSProperties extends React.CSSProperties {
+  '--tag-bg'?: string;
+  '--tag-color'?: string;
+  '--tag-border-color'?: string;
+}
+
+// Type definitions for Ty Tag component
+export interface TyTagProps extends Omit<React.HTMLAttributes<HTMLElement>, 'style' | 'onClick'> {
+  flavor?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'neutral';
+  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+  notPill?: boolean;
+  clickable?: boolean;
+  dismissible?: boolean;
+  disabled?: boolean;
+  selected?: boolean;
+  value?: string;
+  style?: TyTagCSSProperties;
+  // click is a composed CustomEvent from the web component — React's onClick picks it up
+  onClick?: (event: CustomEvent) => void;
+  onTagDismiss?: (event: CustomEvent) => void;
+  children?: React.ReactNode;
+}
+
+// React wrapper for ty-tag web component
+export const TyTag = React.forwardRef<HTMLElement, TyTagProps>(
+  ({ children, onClick, onTagDismiss, notPill, clickable, dismissible, disabled, selected, ...props }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    const handleDismiss = useCallback((event: CustomEvent) => {
+      if (onTagDismiss) {
+        onTagDismiss(event);
+      }
+    }, [onTagDismiss]);
+
+    // dismiss is a custom event — React doesn't know about it, so we need a manual listener
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element || !onTagDismiss) return;
+
+      element.addEventListener('dismiss', handleDismiss as EventListener);
+      return () => {
+        element.removeEventListener('dismiss', handleDismiss as EventListener);
+      };
+    }, [handleDismiss, onTagDismiss]);
+
+    // Handle ref forwarding
+    useEffect(() => {
+      if (ref && elementRef.current) {
+        if (typeof ref === 'function') {
+          ref(elementRef.current);
+        } else {
+          ref.current = elementRef.current;
+        }
+      }
+    }, [ref]);
+
+    return React.createElement(
+      'ty-tag',
+      {
+        ...props,
+        // click is dispatched as composed CustomEvent by the web component — React's
+        // synthetic onClick already catches it, so we just pass it through as onClick
+        ...(onClick && { onClick }),
+        ...(notPill && { 'not-pill': "" }),
+        ...(clickable && { clickable: "" }),
+        ...(dismissible && { dismissible: "" }),
+        ...(disabled && { disabled: "" }),
+        ...(selected && { selected: "" }),
+        ref: elementRef,
+      },
+      children
+    );
+  }
+);
+
+TyTag.displayName = 'TyTag';