tyrell-react 1.0.0-TC7

package/src/components/TyMultiselect.tsx

@@ -0,0 +1,189 @@
+import React, { useEffect, useRef, useCallback } from 'react';
+
+// Type definitions for Ty Multiselect component
+export interface TyMultiselectEventDetail {
+  /** Array of currently selected values */
+  values: string[];
+  /** Action that triggered the change: "add" | "remove" */
+  action: 'add' | 'remove';
+  /** The specific item that was added or removed */
+  item: string;
+}
+
+export interface TyMultiselectProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange' | 'style'> {
+  style?: import('./TyInput').TyInputCSSProperties;
+  /** Current selected values as comma-separated string or array */
+  value?: string | string[];
+  
+  /** Placeholder text when no items are selected */
+  placeholder?: string;
+  
+  /** Disable the multiselect component */
+  disabled?: boolean;
+  
+  /** Make the multiselect read-only */
+  readonly?: boolean;
+  
+  /** Semantic styling variant */
+  flavor?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'neutral';
+  
+  /** Label text for the multiselect */
+  label?: string;
+  
+  /** Mark the field as required */
+  required?: boolean;
+
+  /**
+   * Switch to external (remote) search mode. Default is `false` — the
+   * multiselect filters its own children client-side. Set to `true` when you
+   * want to handle filtering yourself (e.g. server-side): the component will
+   * dispatch `search` events on each keystroke, and you must update the children
+   * in response. The `onSearch` prop receives those events.
+   */
+  externalSearch?: boolean;
+
+  /** Debounce in milliseconds (0-5000) */
+  debounce?: number;
+  
+  /** Mobile section label for selected items */
+  selectedLabel?: string;
+  
+  /** Form field name for form submission */
+  name?: string;
+  
+  /** Callback when selection changes */
+  onChange?: (event: CustomEvent<TyMultiselectEventDetail>) => void;
+
+  /** Callback fired on each search input change (debounced by `debounce`). Use for external/server-side filtering. */
+  onSearch?: (event: CustomEvent<{ query: string; element: HTMLElement }>) => void;
+
+  /** Children should be TyTag components, not TyOption */
+  children?: React.ReactNode;
+}
+
+// React wrapper for ty-multiselect web component
+export const TyMultiselect = React.forwardRef<HTMLElement, TyMultiselectProps>(
+  ({
+    value,
+    placeholder,
+    disabled,
+    readonly,
+    flavor,
+    label,
+    required,
+    externalSearch,
+    debounce,
+    selectedLabel,
+    name,
+    onChange,
+    onSearch,
+    children,
+    ...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]);
+
+    // Handle change events
+    const handleChange = useCallback((event: Event) => {
+      const customEvent = event as CustomEvent<TyMultiselectEventDetail>;
+      if (onChange) {
+        onChange(customEvent);
+      }
+    }, [onChange]);
+
+    const handleSearch = useCallback((event: Event) => {
+      const customEvent = event as CustomEvent<{ query: string; element: HTMLElement }>;
+      if (onSearch) {
+        onSearch(customEvent);
+      }
+    }, [onSearch]);
+
+    // Set up event listeners
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      if (onChange) element.addEventListener('change', handleChange);
+      if (onSearch) element.addEventListener('search', handleSearch);
+
+      return () => {
+        if (onChange) element.removeEventListener('change', handleChange);
+        if (onSearch) element.removeEventListener('search', handleSearch);
+      };
+    }, [handleChange, handleSearch, onChange, onSearch]);
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    // Handle value conversion (array to comma-separated string)
+    if (value !== undefined) {
+      const valueString = Array.isArray(value) ? value.join(',') : value;
+      webComponentProps.value = valueString;
+    }
+
+    // Add optional attributes only if they have values
+    if (placeholder) {
+      webComponentProps.placeholder = placeholder;
+    }
+
+    if (disabled) {
+      webComponentProps.disabled = '';  // Boolean attributes as empty string
+    }
+
+    if (readonly) {
+      webComponentProps.readonly = '';  // Boolean attributes as empty string
+    }
+
+    if (flavor) {
+      webComponentProps.flavor = flavor;
+    }
+
+    if (label) {
+      webComponentProps.label = label;
+    }
+
+    if (required) {
+      webComponentProps.required = '';  // Boolean attributes as empty string
+    }
+
+    if (name) {
+      webComponentProps.name = name;
+    }
+    
+    // External (remote) search mode: parent owns filtering, multiselect dispatches search events
+    if (externalSearch) {
+      webComponentProps['external-search'] = '';
+    }
+
+    // Add debounce attribute
+    if (debounce !== undefined) {
+      webComponentProps.debounce = debounce;
+    }
+    
+    // Add selectedLabel attribute
+    if (selectedLabel) {
+      webComponentProps['selected-label'] = selectedLabel;
+    }
+
+    return React.createElement(
+      'ty-multiselect',
+      webComponentProps,
+      children
+    );
+  }
+);
+
+TyMultiselect.displayName = 'TyMultiselect';

package/src/components/TyOption.tsx

@@ -0,0 +1,42 @@
+import React, { useEffect, useRef } from 'react';
+
+// Type definitions for Ty Option component
+export interface TyOptionProps extends React.HTMLAttributes<HTMLElement> {
+  value?: string;
+  disabled?: boolean;
+  selected?: boolean;
+  hidden?: boolean;
+  children?: React.ReactNode;
+}
+
+// React wrapper for ty-option web component
+export const TyOption = React.forwardRef<HTMLElement, TyOptionProps>(
+  ({ children, disabled, selected, hidden, ...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]);
+
+    return React.createElement(
+      'ty-option',
+      {
+        ...props,
+        ...(disabled && { disabled: "" }),
+        ...(selected && { selected: "" }),
+        ...(hidden && { hidden: "" }),
+        ref: elementRef,
+      },
+      children
+    );
+  }
+);
+
+TyOption.displayName = 'TyOption';

package/src/components/TyPopup.tsx

@@ -0,0 +1,111 @@
+import React, { useEffect, useRef } from 'react';
+
+// Type definitions for Ty Popup component
+export interface TyPopupProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onClose'> {
+  /** Preferred placement of the popup relative to anchor parent: "top" | "bottom" | "left" | "right" */
+  placement?: 'top' | 'bottom' | 'left' | 'right';
+
+  /** Distance offset from the anchor in pixels (default: 8) */
+  offset?: number;
+
+  /** Disable automatic click trigger - requires manual open/close via ref methods */
+  manual?: boolean;
+
+  /** Disable automatic close on outside click and ESC key */
+  disableClose?: boolean;
+
+  /** Fired when the popup opens (after the open animation starts) */
+  onOpen?: (event: CustomEvent) => void;
+
+  /** Fired when the popup closes */
+  onClose?: (event: CustomEvent) => void;
+
+  /** Popup content - popup should be a child of the anchor element */
+  children?: React.ReactNode;
+}
+
+// Programmatic API for popup control
+export interface TyPopupElement extends HTMLElement {
+  openPopup(): void;
+  closePopup(): void;
+  togglePopup(): void;
+}
+
+// React wrapper for ty-popup web component
+export const TyPopup = React.forwardRef<TyPopupElement, TyPopupProps>(
+  ({
+    placement,
+    offset,
+    manual,
+    disableClose,
+    onOpen,
+    onClose,
+    children,
+    ...props
+  }, ref) => {
+    const elementRef = useRef<TyPopupElement>(null);
+
+    // Handle ref forwarding
+    useEffect(() => {
+      if (ref && elementRef.current) {
+        if (typeof ref === 'function') {
+          ref(elementRef.current);
+        } else {
+          ref.current = elementRef.current;
+        }
+      }
+    }, [ref]);
+
+    // Listen for popup open/close events
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      const handleOpen = (event: Event) => {
+        if (onOpen) onOpen(event as CustomEvent);
+      };
+      const handleClose = (event: Event) => {
+        if (onClose) onClose(event as CustomEvent);
+      };
+
+      if (onOpen) element.addEventListener('open', handleOpen);
+      if (onClose) element.addEventListener('close', handleClose);
+
+      return () => {
+        if (onOpen) element.removeEventListener('open', handleOpen);
+        if (onClose) element.removeEventListener('close', handleClose);
+      };
+    }, [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 (placement) {
+      webComponentProps.placement = placement;
+    }
+
+    if (offset !== undefined) {
+      webComponentProps.offset = offset.toString();
+    }
+
+    if (manual) {
+      webComponentProps.manual = '';  // Boolean attributes as empty string
+    }
+
+    if (disableClose) {
+      webComponentProps['disable-close'] = '';  // Boolean attributes as empty string
+    }
+
+    return React.createElement(
+      'ty-popup',
+      webComponentProps,
+      children
+    );
+  }
+);
+
+TyPopup.displayName = 'TyPopup';

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/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';