tyrell-react 1.0.0-TC7

package/src/components/EventConventionTest.tsx

@@ -0,0 +1,155 @@
+/**
+ * Test Example: React Event Convention
+ * 
+ * This file demonstrates the new event handling convention
+ * for tyrell-react components.
+ *
+ * To test:
+ * 1. Create a new React project or use existing
+ * 2. npm install tyrell-react
+ * 3. Add this component to your app
+ * 4. Observe console logs and state updates
+ */
+
+import React, { useState } from 'react';
+import { TyInput } from './TyInput';
+import { TyTextarea } from './TyTextarea';
+import { TyCheckbox } from './TyCheckbox';
+import type { TyInputEventDetail } from './TyInput';
+import type { TyTextareaEventDetail } from './TyTextarea';
+import type { TyCheckboxEventDetail } from './TyCheckbox';
+
+export function EventConventionTest() {
+  const [inputValue, setInputValue] = useState('');
+  const [textareaValue, setTextareaValue] = useState('');
+  const [checked, setChecked] = useState(false);
+  const [logs, setLogs] = useState<string[]>([]);
+
+  const addLog = (message: string) => {
+    setLogs(prev => [...prev, `${new Date().toLocaleTimeString()}: ${message}`]);
+  };
+
+  return (
+    <div className="p-8 space-y-6 max-w-2xl">
+      <h1 className="text-2xl font-bold">React Event Convention Test</h1>
+      
+      {/* Input Test */}
+      <div className="space-y-2">
+        <h2 className="text-lg font-semibold">TyInput Test</h2>
+        <TyInput
+          label="Email"
+          placeholder="Type to test onChange..."
+          value={inputValue}
+          onChange={(e: CustomEvent<TyInputEventDetail>) => {
+            setInputValue(e.detail.value);
+            addLog(`onChange: "${e.detail.value}" (fires on keystroke)`);
+          }}
+          onChangeCommit={(e: CustomEvent<TyInputEventDetail>) => {
+            addLog(`onChangeCommit: "${e.detail.value}" (fires on blur)`);
+          }}
+          onFocus={() => addLog('onFocus')}
+          onBlur={() => addLog('onBlur')}
+        />
+        <p className="text-sm text-gray-600">
+          Current value: <strong>{inputValue}</strong>
+        </p>
+      </div>
+
+      {/* Textarea Test */}
+      <div className="space-y-2">
+        <h2 className="text-lg font-semibold">TyTextarea Test</h2>
+        <TyTextarea
+          label="Comments"
+          placeholder="Type to test onChange..."
+          value={textareaValue}
+          rows={3}
+          onChange={(e: CustomEvent<TyTextareaEventDetail>) => {
+            setTextareaValue(e.detail.value);
+            addLog(`Textarea onChange: "${e.detail.value}"`);
+          }}
+          onChangeCommit={(e: CustomEvent<TyTextareaEventDetail>) => {
+            addLog(`Textarea onChangeCommit: "${e.detail.value}"`);
+          }}
+        />
+        <p className="text-sm text-gray-600">
+          Current value: <strong>{textareaValue}</strong>
+        </p>
+      </div>
+
+      {/* Checkbox Test */}
+      <div className="space-y-2">
+        <h2 className="text-lg font-semibold">TyCheckbox Test</h2>
+        <TyCheckbox
+          checked={checked}
+          onChange={(e: CustomEvent<TyCheckboxEventDetail>) => {
+            setChecked(e.detail.checked);
+            addLog(`Checkbox onChange: ${e.detail.checked} (fires immediately)`);
+          }}
+          onChangeCommit={(e: CustomEvent<TyCheckboxEventDetail>) => {
+            addLog(`Checkbox onChangeCommit: ${e.detail.checked} (fires on blur)`);
+          }}
+        >
+          Subscribe to newsletter
+        </TyCheckbox>
+        <p className="text-sm text-gray-600">
+          Current state: <strong>{checked ? 'Checked' : 'Unchecked'}</strong>
+        </p>
+      </div>
+
+      {/* Event Log */}
+      <div className="space-y-2">
+        <h2 className="text-lg font-semibold">Event Log</h2>
+        <div className="bg-gray-100 p-4 rounded max-h-64 overflow-y-auto font-mono text-xs">
+          {logs.length === 0 ? (
+            <p className="text-gray-500">No events yet. Start typing or checking boxes!</p>
+          ) : (
+            logs.map((log, i) => (
+              <div key={i} className="text-gray-800">
+                {log}
+              </div>
+            ))
+          )}
+        </div>
+        <button
+          onClick={() => setLogs([])}
+          className="px-4 py-2 bg-gray-200 rounded hover:bg-gray-300"
+        >
+          Clear Log
+        </button>
+      </div>
+
+      {/* Expected Behavior */}
+      <div className="bg-blue-50 p-4 rounded">
+        <h3 className="font-semibold mb-2">Expected Behavior:</h3>
+        <ul className="list-disc list-inside space-y-1 text-sm">
+          <li>
+            <strong>onChange</strong> - Fires on every keystroke/state change (React convention)
+          </li>
+          <li>
+            <strong>onChangeCommit</strong> - Fires on blur if value changed (optional)
+          </li>
+          <li>
+            <strong>onFocus</strong> - Fires when element gains focus
+          </li>
+          <li>
+            <strong>onBlur</strong> - Fires when element loses focus
+          </li>
+        </ul>
+      </div>
+
+      {/* Verification */}
+      <div className="bg-green-50 p-4 rounded">
+        <h3 className="font-semibold mb-2">Verification Checklist:</h3>
+        <ul className="list-disc list-inside space-y-1 text-sm">
+          <li>✅ onChange fires on EVERY keystroke (not just on blur)</li>
+          <li>✅ State updates in real-time as you type</li>
+          <li>✅ onChangeCommit fires ONLY on blur (if value changed)</li>
+          <li>✅ Event order: onChange → onBlur → onChangeCommit</li>
+          <li>✅ Checkbox onChange fires immediately on click</li>
+        </ul>
+      </div>
+    </div>
+  );
+}
+
+export default EventConventionTest;

package/src/components/TyButton.tsx

@@ -0,0 +1,140 @@
+import React, { useEffect, useRef, useCallback } from 'react';
+
+type BuiltinFlavor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'neutral';
+type ShadedFlavor = BuiltinFlavor | `${BuiltinFlavor}+` | `${BuiltinFlavor}-`;
+type ButtonAppearance = 'solid' | 'outlined' | 'ghost';
+
+export interface TyButtonCSSProperties extends React.CSSProperties {
+  '--ty-button-bg'?: string;
+  '--ty-button-bg-hover'?: string;
+  '--ty-button-color'?: string;
+  '--ty-button-border'?: string;
+}
+
+export interface TyButtonProps extends Omit<React.HTMLAttributes<HTMLElement>, 'style'> {
+  style?: TyButtonCSSProperties;
+  /**
+   * Semantic styling variant. Built-in flavors get themed styles; append `+`
+   * for a stronger shade or `-` for a softer one (e.g. `"primary+"`,
+   * `"danger-"`). Any other string is passed through as-is — theme it via
+   * `--ty-button-*` CSS variables.
+   */
+  flavor?: ShadedFlavor | (string & {});
+
+  /**
+   * Visual appearance:
+   * - `"solid"` (default) — saturated brand fill with paired text color
+   * - `"outlined"` — transparent background, text === border
+   * - `"ghost"` — text only with hover background
+   */
+  appearance?: ButtonAppearance;
+
+  /** Button size */
+  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+  /** Button type for form submission */
+  type?: 'button' | 'submit' | 'reset';
+
+  /** Disable the button */
+  disabled?: boolean;
+
+  /** Pill-shaped button (rounded ends) */
+  pill?: boolean;
+
+  /** Action (icon-only square) */
+  action?: boolean;
+
+  /** Accessible label for screen readers */
+  label?: string;
+
+  /** Form field name for form submission */
+  name?: string;
+
+  /** Form field value for form submission */
+  value?: string;
+
+  /** Full-width button */
+  wide?: boolean;
+
+  /** Button content */
+  children?: React.ReactNode;
+}
+
+export const TyButton = React.forwardRef<HTMLElement, TyButtonProps>(
+  ({
+    children,
+    type,
+    appearance,
+    disabled,
+    pill,
+    action,
+    wide,
+    label,
+    name,
+    value,
+    ...props
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    const handleFormSubmission = useCallback((event: Event) => {
+      const element = elementRef.current;
+      if (!element || type !== 'submit') return;
+
+      const form = element.closest('form');
+      if (!form) return;
+
+      event.preventDefault();
+      event.stopPropagation();
+
+      const syntheticEvent = new Event('submit', {
+        bubbles: true,
+        cancelable: true
+      });
+      form.dispatchEvent(syntheticEvent);
+    }, [type]);
+
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element || type !== 'submit') return;
+
+      element.addEventListener('click', handleFormSubmission);
+      return () => {
+        element.removeEventListener('click', handleFormSubmission);
+      };
+    }, [type, handleFormSubmission]);
+
+    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 (disabled) webComponentProps.disabled = '';
+    if (pill) webComponentProps.pill = '';
+    if (action) webComponentProps.action = '';
+    if (wide) webComponentProps.wide = '';
+
+    if (appearance) webComponentProps.appearance = appearance;
+    if (type) webComponentProps.type = type;
+    if (label) webComponentProps.label = label;
+    if (name) webComponentProps.name = name;
+    if (value) webComponentProps.value = value;
+
+    return React.createElement(
+      'ty-button',
+      webComponentProps,
+      children
+    );
+  }
+);
+
+TyButton.displayName = 'TyButton';

package/src/components/TyCalendar.tsx

@@ -0,0 +1,244 @@
+import React, { useEffect, useRef, useCallback } from 'react';
+
+// Type definitions for Ty Calendar component
+export interface TyCalendarChangeEventDetail {
+  /** Selected month (1-12) */
+  month: number;
+  /** Selected year (4-digit) */
+  year: number;
+  /** Selected day (1-31) */
+  day: number;
+  /** Action that triggered the change: "select" */
+  action: 'select';
+  /** Source of the change: "day-click" */
+  source: 'day-click';
+  /** Complete day context from the calendar month */
+  dayContext: any;
+}
+
+export interface TyCalendarNavigateEventDetail {
+  /** Navigation target month (1-12) */
+  month: number;
+  /** Navigation target year (4-digit) */
+  year: number;
+  /** Action that triggered the navigation: "navigate" */
+  action: 'navigate';
+  /** Source of the change: "navigation" */
+  source: 'navigation';
+}
+
+export interface TyCalendarProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange'> {
+  /** Selected year (4-digit) */
+  year?: number | string;
+  
+  /** Selected month (1-12) */
+  month?: number | string;
+  
+  /** Selected day (1-31) */
+  day?: number | string;
+  
+  /** Show navigation controls */
+  showNavigation?: boolean;
+  
+  /** Stateless mode - no internal state management */
+  stateless?: boolean;
+  
+  /** Calendar size */
+  size?: 'sm' | 'md' | 'lg';
+  
+  /** Locale for date formatting */
+  locale?: string;
+  
+  /** Calendar width */
+  width?: string | number;
+  
+  /** Minimum calendar width */
+  minWidth?: string | number;
+  
+  /** Maximum calendar width */
+  maxWidth?: string | number;
+  
+  /** Form field name for form submission */
+  name?: string;
+  
+  /** Form value (ISO date string) */
+  value?: string;
+  
+  /** Function to render custom day content */
+  dayContentFn?: (dayContext: any) => HTMLElement | string;
+  
+  /** Function to determine day CSS classes */
+  dayClassesFn?: (dayContext: any) => string[];
+  
+  /** Custom CSS injection for render functions */
+  customCSS?: string;
+  
+  /** Callback when a date is selected */
+  onChange?: (event: CustomEvent<TyCalendarChangeEventDetail>) => void;
+  
+  /** Callback when navigation changes month/year */
+  onNavigate?: (event: CustomEvent<TyCalendarNavigateEventDetail>) => void;
+}
+
+// React wrapper for ty-calendar web component
+export const TyCalendar = React.forwardRef<HTMLElement, TyCalendarProps>(
+  ({ 
+    year,
+    month,
+    day,
+    showNavigation,
+    stateless,
+    size,
+    locale,
+    width,
+    minWidth,
+    maxWidth,
+    name,
+    value,
+    dayContentFn,
+    dayClassesFn,
+    customCSS,
+    onChange,
+    onNavigate,
+    ...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 (date selection)
+    const handleChange = useCallback((event: Event) => {
+      const customEvent = event as CustomEvent<TyCalendarChangeEventDetail>;
+      if (onChange) {
+        onChange(customEvent);
+      }
+    }, [onChange]);
+
+    // Handle navigate events (month/year navigation)
+    const handleNavigate = useCallback((event: Event) => {
+      const customEvent = event as CustomEvent<TyCalendarNavigateEventDetail>;
+      if (onNavigate) {
+        onNavigate(customEvent);
+      }
+    }, [onNavigate]);
+
+    // 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 (onNavigate) {
+        element.addEventListener('navigate', handleNavigate);
+        listeners.push(['navigate', handleNavigate]);
+      }
+
+      return () => {
+        listeners.forEach(([eventName, handler]) => {
+          element.removeEventListener(eventName, handler);
+        });
+      };
+    }, [handleChange, handleNavigate, onChange, onNavigate]);
+
+    // Set function properties directly on the element (preferred over attributes)
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      // Day content function property (preferred over attribute)
+      if (dayContentFn) {
+        (element as any).dayContentFn = dayContentFn;
+      } else {
+        (element as any).dayContentFn = null;
+      }
+
+      // Day classes function property (preferred over attribute)
+      if (dayClassesFn) {
+        (element as any).dayClassesFn = dayClassesFn;
+      } else {
+        (element as any).dayClassesFn = null;
+      }
+
+      // Custom CSS property
+      if (customCSS) {
+        (element as any).customCSS = customCSS;
+      } else {
+        (element as any).customCSS = null;
+      }
+    }, [dayContentFn, dayClassesFn, customCSS]);
+
+    // Convert React props to web component attributes
+    const webComponentProps: Record<string, any> = {
+      ...props,
+      ref: elementRef,
+    };
+
+    // Add optional attributes only if they have values
+    if (year !== undefined) {
+      webComponentProps.year = year.toString();
+    }
+
+    if (month !== undefined) {
+      webComponentProps.month = month.toString();
+    }
+
+    if (day !== undefined) {
+      webComponentProps.day = day.toString();
+    }
+
+    if (showNavigation) {
+      webComponentProps['show-navigation'] = '';  // Boolean attributes as empty string
+    }
+
+    if (stateless) {
+      webComponentProps.stateless = '';  // Boolean attributes as empty string
+    }
+
+    if (size) {
+      webComponentProps.size = size;
+    }
+
+    if (locale) {
+      webComponentProps.locale = locale;
+    }
+
+    if (width !== undefined) {
+      webComponentProps.width = width.toString();
+    }
+
+    if (minWidth !== undefined) {
+      webComponentProps['min-width'] = minWidth.toString();
+    }
+
+    if (maxWidth !== undefined) {
+      webComponentProps['max-width'] = maxWidth.toString();
+    }
+
+    if (name) {
+      webComponentProps.name = name;
+    }
+
+    if (value) {
+      webComponentProps.value = value;
+    }
+
+    return React.createElement('ty-calendar', webComponentProps);
+  }
+);
+
+TyCalendar.displayName = 'TyCalendar';

package/src/components/TyCalendarMonth.tsx

@@ -0,0 +1,108 @@
+import React, { useEffect, useRef } from 'react';
+
+// Type definitions for Ty Calendar Month component
+export interface TyCalendarMonthProps extends React.HTMLAttributes<HTMLElement> {
+  /** Display year */
+  displayYear?: number;
+  
+  /** Display month (1-12) */
+  displayMonth?: number;
+  
+  /** Locale for date formatting */
+  locale?: string;
+  
+  /** Calendar size */
+  size?: 'sm' | 'md' | 'lg';
+  
+  /** Width of calendar */
+  width?: string;
+  
+  /** Minimum width */
+  minWidth?: string;
+  
+  /** Maximum width */
+  maxWidth?: string;
+  
+  /** Day click event handler */
+  onDayClick?: (event: CustomEvent<DayClickDetail>) => void;
+}
+
+export interface DayClickDetail {
+  dayContext: any; // DayContext type from calendar-utils
+  value: number;
+  year: number;
+  month: number;
+  day: number;
+  isHoliday?: boolean;
+  isToday?: boolean;
+  isWeekend: boolean;
+  isOtherMonth: boolean;
+}
+
+// React wrapper for ty-calendar-month web component
+export const TyCalendarMonth = React.forwardRef<HTMLElement, TyCalendarMonthProps>(
+  ({ 
+    displayYear,
+    displayMonth,
+    locale,
+    size,
+    width,
+    minWidth,
+    maxWidth,
+    onDayClick,
+    ...props 
+  }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    // Handle day click events
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      const handleDayClick = (event: Event) => {
+        if (onDayClick) {
+          onDayClick(event as CustomEvent<DayClickDetail>);
+        }
+      };
+
+      element.addEventListener('day-click', handleDayClick);
+
+      return () => {
+        element.removeEventListener('day-click', handleDayClick);
+      };
+    }, [onDayClick]);
+
+    // 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 (displayYear !== undefined) webComponentProps['display-year'] = displayYear;
+    if (displayMonth !== undefined) webComponentProps['display-month'] = displayMonth;
+    if (locale) webComponentProps.locale = locale;
+    if (size) webComponentProps.size = size;
+    if (width) webComponentProps.width = width;
+    if (minWidth) webComponentProps['min-width'] = minWidth;
+    if (maxWidth) webComponentProps['max-width'] = maxWidth;
+
+    return React.createElement(
+      'ty-calendar-month',
+      webComponentProps
+    );
+  }
+);
+
+TyCalendarMonth.displayName = 'TyCalendarMonth';