tyrell-react 1.0.0-RC10 → 1.0.0-RC12

package/src/components/TyCopy.tsx

@@ -26,6 +26,12 @@ export interface TyCopyProps extends Omit<React.HTMLAttributes<HTMLElement>, 'on
   
   /** Required field */
   required?: boolean;
+
+  /** Fired after the value is copied to the clipboard */
+  onCopySuccess?: (event: CustomEvent) => void;
+
+  /** Fired when copying to the clipboard fails */
+  onCopyError?: (event: CustomEvent) => void;
 }
 
 // React wrapper for ty-copy web component
@@ -39,7 +45,9 @@ export const TyCopy = React.forwardRef<HTMLElement, TyCopyProps>(
     multiline,
     disabled,
     required,
-    ...props 
+    onCopySuccess,
+    onCopyError,
+    ...props
   }, ref) => {
     const elementRef = useRef<HTMLElement>(null);
 
@@ -54,6 +62,22 @@ export const TyCopy = React.forwardRef<HTMLElement, TyCopyProps>(
       }
     }, [ref]);
 
+    // Custom events → React callbacks
+    useEffect(() => {
+      const el = elementRef.current;
+      if (!el) return;
+      const bound: Array<[string, EventListener]> = [];
+      if (onCopySuccess) {
+        const h = (e: Event) => onCopySuccess(e as CustomEvent);
+        el.addEventListener('copy-success', h); bound.push(['copy-success', h]);
+      }
+      if (onCopyError) {
+        const h = (e: Event) => onCopyError(e as CustomEvent);
+        el.addEventListener('copy-error', h); bound.push(['copy-error', h]);
+      }
+      return () => bound.forEach(([n, h]) => el.removeEventListener(n, h));
+    }, [onCopySuccess, onCopyError]);
+
     const isMultiline = useBooleanProperty(elementRef, 'multiline', multiline);
     const isDisabled = useBooleanProperty(elementRef, 'disabled', disabled);
     const isRequired = useBooleanProperty(elementRef, 'required', required);

package/src/components/TyDatePicker.tsx

@@ -50,6 +50,12 @@ export interface TyDatePickerProps extends Omit<React.HTMLAttributes<HTMLElement
   
   /** Whether to include time selection */
   withTime?: boolean;
+
+  /** Earliest selectable date (ISO "YYYY-MM-DD") */
+  min?: string;
+
+  /** Latest selectable date (ISO "YYYY-MM-DD") */
+  max?: string;
   
   /** Callback when the date value changes */
   onChange?: (event: CustomEvent<TyDatePickerEventDetail>) => void;
@@ -76,6 +82,8 @@ export const TyDatePicker = React.forwardRef<HTMLElement, TyDatePickerProps>(
     format,
     locale,
     withTime,
+    min,
+    max,
     onChange,
     onOpen,
     onClose,
@@ -208,6 +216,14 @@ export const TyDatePicker = React.forwardRef<HTMLElement, TyDatePickerProps>(
       webComponentProps['with-time'] = '';  // Convert camelCase to kebab-case
     }
 
+    if (min) {
+      webComponentProps.min = min;
+    }
+
+    if (max) {
+      webComponentProps.max = max;
+    }
+
     return React.createElement('ty-date-picker', webComponentProps);
   }
 );

package/src/components/TyOption.tsx

@@ -4,6 +4,17 @@ import { useBooleanProperty } from '../utils/use-boolean-prop';
 // Type definitions for Ty Option component
 export interface TyOptionProps extends React.HTMLAttributes<HTMLElement> {
   value?: string;
+
+  /**
+   * Clean display text (native <option label> semantics) — used by ty-select
+   * for field summaries and by ty-selected-tags chips when the option's
+   * children are rich HTML. data-* attributes feed chip templates.
+   */
+  label?: string;
+
+  /** Semantic flavor — carried onto ty-selected-tags chips */
+  flavor?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'neutral' | 'info';
+
   disabled?: boolean;
   selected?: boolean;
   hidden?: boolean;
@@ -12,7 +23,7 @@ export interface TyOptionProps extends React.HTMLAttributes<HTMLElement> {
 
 // React wrapper for ty-option web component
 export const TyOption = React.forwardRef<HTMLElement, TyOptionProps>(
-  ({ children, disabled, selected, hidden, ...props }, ref) => {
+  ({ children, label, flavor, disabled, selected, hidden, ...props }, ref) => {
     const elementRef = useRef<HTMLElement>(null);
 
     // Handle ref forwarding
@@ -34,6 +45,8 @@ export const TyOption = React.forwardRef<HTMLElement, TyOptionProps>(
       'ty-option',
       {
         ...props,
+        ...(label && { label }),
+        ...(flavor && { flavor }),
         ...(isDisabled && { disabled: "" }),
         ...(isSelected && { selected: "" }),
         ...(isHidden && { hidden: "" }),

package/src/components/TyScrollContainer.tsx

@@ -2,6 +2,14 @@ import React, { useEffect, useRef, useImperativeHandle } from 'react';
 import { needsPropertyBridge } from '../utils/react-version';
 import { useBooleanProperty, coerceBool } from '../utils/use-boolean-prop';
 
+/** Detail payload for nearstart / nearend events. */
+export interface TyScrollNearEdgeDetail {
+  distance: number;
+  scrollTop: number;
+  scrollHeight: number;
+  clientHeight: number;
+}
+
 // Type definitions for Ty ScrollContainer component
 export interface TyScrollContainerProps extends React.HTMLAttributes<HTMLElement> {
   /** Maximum height of the scroll container */
@@ -10,9 +18,27 @@ export interface TyScrollContainerProps extends React.HTMLAttributes<HTMLElement
   /** Enable/disable scroll shadows (default: true) */
   shadow?: boolean;
 
-  /** Hide native scrollbar */
+  /** Hide native scrollbar (no custom scrollbar) */
   hideScrollbar?: boolean;
 
+  /** Use the styled custom scrollbar */
+  customScrollbar?: boolean;
+
+  /** Enable horizontal scrolling */
+  overflowX?: boolean;
+
+  /** Preserve visual position when content is prepended above the viewport */
+  scrollAnchoring?: boolean;
+
+  /** Distance (px) from an edge at which nearstart/nearend fire (default 100) */
+  nearEdgeThreshold?: number;
+
+  /** Fired once when scrolled within the threshold of the bottom */
+  onNearEnd?: (event: CustomEvent<TyScrollNearEdgeDetail>) => void;
+
+  /** Fired once when scrolled within the threshold of the top */
+  onNearStart?: (event: CustomEvent<TyScrollNearEdgeDetail>) => void;
+
   /** Content to scroll */
   children?: React.ReactNode;
 }
@@ -25,6 +51,12 @@ export interface TyScrollContainerRef {
   scrollToTop: (smooth?: boolean) => void;
   /** Scroll to bottom */
   scrollToBottom: (smooth?: boolean) => void;
+  /** Scroll to far left */
+  scrollToLeft: (smooth?: boolean) => void;
+  /** Scroll to far right */
+  scrollToRight: (smooth?: boolean) => void;
+  /** Scroll a descendant (element or CSS selector) into view */
+  scrollToElement: (target: Element | string, smooth?: boolean) => void;
   /** Get the underlying scroll element */
   scrollElement: HTMLElement | null;
   /** Get the native element */
@@ -38,35 +70,29 @@ export const TyScrollContainer = React.forwardRef<TyScrollContainerRef, TyScroll
     maxHeight,
     shadow,
     hideScrollbar,
+    customScrollbar,
+    overflowX,
+    scrollAnchoring,
+    nearEdgeThreshold,
+    onNearEnd,
+    onNearStart,
     ...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;
-      }
+      updateShadows: () => { (elementRef.current as any)?.updateShadows?.(); },
+      scrollToTop: (smooth = true) => { (elementRef.current as any)?.scrollToTop?.(smooth); },
+      scrollToBottom: (smooth = true) => { (elementRef.current as any)?.scrollToBottom?.(smooth); },
+      scrollToLeft: (smooth = true) => { (elementRef.current as any)?.scrollToLeft?.(smooth); },
+      scrollToRight: (smooth = true) => { (elementRef.current as any)?.scrollToRight?.(smooth); },
+      scrollToElement: (target, smooth = true) => { (elementRef.current as any)?.scrollToElement?.(target, smooth); },
+      get scrollElement() { return (elementRef.current as any)?.scrollElement ?? null; },
+      get element() { return elementRef.current; }
     }), []);
 
-    // shadow defaults to true; only the explicit-false case matters at the
-    // attribute level. Bridge it imperatively so flipping back to true
+    // shadow defaults to true; bridge it imperatively so flipping back to true
     // propagates on React 18.
     useEffect(() => {
       if (!needsPropertyBridge) return;
@@ -76,7 +102,27 @@ export const TyScrollContainer = React.forwardRef<TyScrollContainerRef, TyScroll
       const next = coerceBool(shadow);
       if (Boolean(el.shadow) !== next) el.shadow = next;
     }, [shadow]);
+
     const isHideScrollbar = useBooleanProperty(elementRef, 'hideScrollbar', hideScrollbar);
+    const isCustomScrollbar = useBooleanProperty(elementRef, 'customScrollbar', customScrollbar);
+    const isOverflowX = useBooleanProperty(elementRef, 'overflowX', overflowX);
+    const isScrollAnchoring = useBooleanProperty(elementRef, 'scrollAnchoring', scrollAnchoring);
+
+    // Custom events → React callbacks
+    useEffect(() => {
+      const el = elementRef.current;
+      if (!el) return;
+      const bound: Array<[string, EventListener]> = [];
+      if (onNearEnd) {
+        const h = (e: Event) => onNearEnd(e as CustomEvent<TyScrollNearEdgeDetail>);
+        el.addEventListener('nearend', h); bound.push(['nearend', h]);
+      }
+      if (onNearStart) {
+        const h = (e: Event) => onNearStart(e as CustomEvent<TyScrollNearEdgeDetail>);
+        el.addEventListener('nearstart', h); bound.push(['nearstart', h]);
+      }
+      return () => bound.forEach(([n, h]) => el.removeEventListener(n, h));
+    }, [onNearEnd, onNearStart]);
 
     // Convert React props to web component attributes
     const webComponentProps: Record<string, any> = {
@@ -84,12 +130,16 @@ export const TyScrollContainer = React.forwardRef<TyScrollContainerRef, TyScroll
       ref: elementRef,
     };
 
-    // Add string attributes
+    // String attributes
     if (maxHeight) webComponentProps['max-height'] = maxHeight;
+    if (nearEdgeThreshold != null) webComponentProps['near-edge-threshold'] = String(nearEdgeThreshold);
 
-    // Add boolean attributes
+    // Boolean attributes
     if (shadow !== undefined && !coerceBool(shadow)) webComponentProps.shadow = 'false';
     if (isHideScrollbar) webComponentProps['hide-scrollbar'] = '';
+    if (isCustomScrollbar) webComponentProps['custom-scrollbar'] = '';
+    if (isOverflowX) webComponentProps['overflow-x'] = '';
+    if (isScrollAnchoring) webComponentProps['scroll-anchoring'] = '';
 
     return React.createElement(
       'ty-scroll-container',

package/src/components/TySelect.tsx

@@ -0,0 +1,240 @@
+import React, { useEffect, useRef, useCallback } from 'react';
+import { needsPropertyBridge } from '../utils/react-version';
+import { useBooleanProperty } from '../utils/use-boolean-prop';
+
+// Type definitions for Ty Select component
+export interface TySelectItem {
+  value: string;
+  label: string;
+  flavor: string | null;
+}
+
+export interface TySelectEventDetail {
+  /** Scalar for single select, array when `multiple` */
+  value: string | string[] | null;
+  /** Always the array form of the selection */
+  values: string[];
+  /** Rich info per selected value — enough to render chips out-of-band */
+  items: TySelectItem[];
+  /** Action that triggered the change */
+  action: 'add' | 'remove' | 'clear' | 'set';
+  /** The specific value that changed */
+  item: string | null;
+}
+
+export interface TySelectProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange' | 'style'> {
+  style?: import('./TyInput').TyInputCSSProperties;
+
+  /** Selected value(s) — string, comma-separated string, or array */
+  value?: string | string[];
+
+  /** Multi select (native <select multiple> semantics). Default: single. */
+  multiple?: boolean;
+
+  /** Compact content-hugging trigger (toolbars, filter bars) instead of the full-width field look */
+  compact?: boolean;
+
+  /** Placeholder shown while nothing is selected */
+  placeholder?: string;
+
+  /** Label text above the field */
+  label?: string;
+
+  /** Form field name — single submits one entry, multiple submits repeated entries */
+  name?: string;
+
+  /** Disable the select */
+  disabled?: boolean;
+
+  /** Read-only */
+  readonly?: boolean;
+
+  /** Mark the field as required */
+  required?: boolean;
+
+  /**
+   * Search row visibility: 'auto' (default) shows it only for 8+ options,
+   * 'always' / 'never' force it. external-search always shows it.
+   */
+  searchable?: 'auto' | 'always' | 'never' | boolean;
+
+  /**
+   * External (remote) search mode — the component stops filtering and emits
+   * debounced `search` events; replace the option children in response.
+   */
+  externalSearch?: boolean;
+
+  /** Debounce for the search event in ms (0-5000) */
+  debounce?: number;
+
+  /** Loading state — shows a spinner in the options area (external search in flight) */
+  loading?: boolean;
+
+  /** Size variant */
+  size?: 'sm' | 'md' | 'lg';
+
+  /** Callback when selection changes */
+  onChange?: (event: CustomEvent<TySelectEventDetail>) => void;
+
+  /** Callback fired on each search input change (debounced). Use for external/server-side filtering. */
+  onSearch?: (event: CustomEvent<{ query: string; element: HTMLElement }>) => void;
+  onOpen?: (event: CustomEvent) => void;
+  onClose?: (event: CustomEvent) => void;
+
+  /** TyOption children (plus optional slot="trigger" / slot="start" / slot="end" elements) */
+  children?: React.ReactNode;
+}
+
+// React wrapper for ty-select web component
+export const TySelect = React.forwardRef<HTMLElement, TySelectProps>(
+  ({
+    value,
+    multiple,
+    compact,
+    placeholder,
+    label,
+    name,
+    disabled,
+    readonly,
+    required,
+    searchable,
+    externalSearch,
+    debounce,
+    loading,
+    size,
+    onChange,
+    onSearch,
+    onOpen,
+    onClose,
+    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]);
+
+    // Imperatively sync `value` so resets ('' or null) reliably clear the
+    // visible selection. React 18 workaround; React 19+ handles this natively.
+    useEffect(() => {
+      if (!needsPropertyBridge) return;
+      const element = elementRef.current as any;
+      if (!element) return;
+      const next = Array.isArray(value) ? value.join(',') : (value ?? '');
+      if (element.value !== next) {
+        element.value = next;
+      }
+    }, [value]);
+
+    // Handle events
+    const handleChange = useCallback((event: Event) => {
+      if (onChange) onChange(event as CustomEvent<TySelectEventDetail>);
+    }, [onChange]);
+
+    const handleSearch = useCallback((event: Event) => {
+      if (onSearch) onSearch(event as CustomEvent<{ query: string; element: HTMLElement }>);
+    }, [onSearch]);
+
+    const handleOpen = useCallback((event: Event) => { if (onOpen) onOpen(event as CustomEvent); }, [onOpen]);
+    const handleClose = useCallback((event: Event) => { if (onClose) onClose(event as CustomEvent); }, [onClose]);
+
+    // Set up event listeners
+    useEffect(() => {
+      const element = elementRef.current;
+      if (!element) return;
+
+      if (onChange) element.addEventListener('change', handleChange);
+      if (onSearch) element.addEventListener('search', handleSearch);
+      if (onOpen) element.addEventListener('open', handleOpen);
+      if (onClose) element.addEventListener('close', handleClose);
+
+      return () => {
+        if (onChange) element.removeEventListener('change', handleChange);
+        if (onSearch) element.removeEventListener('search', handleSearch);
+        if (onOpen) element.removeEventListener('open', handleOpen);
+        if (onClose) element.removeEventListener('close', handleClose);
+      };
+    }, [handleChange, handleSearch, handleOpen, handleClose, onChange, onSearch, onOpen, onClose]);
+
+    // Imperative property sync for boolean props (see use-boolean-prop.ts).
+    const isMultiple = useBooleanProperty(elementRef, 'multiple', multiple);
+    const isCompact = useBooleanProperty(elementRef, 'compact', compact);
+    const isDisabled = useBooleanProperty(elementRef, 'disabled', disabled);
+    const isReadonly = useBooleanProperty(elementRef, 'readonly', readonly);
+    const isRequired = useBooleanProperty(elementRef, 'required', required);
+    const isLoading = useBooleanProperty(elementRef, 'loading', loading);
+    const isExternalSearch = useBooleanProperty(elementRef, 'externalSearch', externalSearch);
+
+    // 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) {
+      webComponentProps.value = Array.isArray(value) ? value.join(',') : value;
+    }
+
+    if (isMultiple) webComponentProps.multiple = '';
+    if (isCompact) webComponentProps.compact = '';
+    if (isDisabled) webComponentProps.disabled = '';
+    if (isReadonly) webComponentProps.readonly = '';
+    if (isRequired) webComponentProps.required = '';
+    if (isLoading) webComponentProps.loading = '';
+    if (isExternalSearch) webComponentProps['external-search'] = '';
+
+    if (placeholder) webComponentProps.placeholder = placeholder;
+    if (label) webComponentProps.label = label;
+    if (name) webComponentProps.name = name;
+    if (size) webComponentProps.size = size;
+    if (debounce !== undefined) webComponentProps.debounce = debounce.toString();
+    if (searchable === 'always' || searchable === true) webComponentProps.searchable = 'true';
+    else if (searchable === 'never' || searchable === false) webComponentProps.searchable = 'false';
+    // 'auto' / undefined → omit (component default)
+
+    return React.createElement('ty-select', webComponentProps, children);
+  }
+);
+
+TySelect.displayName = 'TySelect';
+
+// ============================================================================
+// TySelectedTags — out-of-band chip display for a TySelect
+// ============================================================================
+
+export interface TySelectedTagsProps extends React.HTMLAttributes<HTMLElement> {
+  /** id of the ty-select to display. Falls back to the previous element sibling. */
+  htmlFor?: string;
+  /** Optional <template> child as chip blueprint ({value}/{label}/{flavor}/{data-*} placeholders) */
+  children?: React.ReactNode;
+}
+
+// React wrapper for ty-selected-tags web component
+export const TySelectedTags = React.forwardRef<HTMLElement, TySelectedTagsProps>(
+  ({ htmlFor, children, ...props }, ref) => {
+    const elementRef = useRef<HTMLElement>(null);
+
+    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 (htmlFor) webComponentProps.for = htmlFor;
+
+    return React.createElement('ty-selected-tags', webComponentProps, children);
+  }
+);
+
+TySelectedTags.displayName = 'TySelectedTags';

package/src/components/index.ts

@@ -44,9 +44,6 @@ export type { TyInputProps, TyInputEventDetail, TyInputCSSProperties } from './T
 export { TyTextarea } from './TyTextarea';
 export type { TyTextareaProps, TyTextareaEventDetail } from './TyTextarea';
 
-export { TyDropdown } from './TyDropdown';
-export type { TyDropdownProps, TyDropdownEventDetail } from './TyDropdown';
-
 export { TyOption } from './TyOption';
 export type { TyOptionProps } from './TyOption';
 
@@ -55,12 +52,15 @@ export type { TyIconProps } from './TyIcon';
 
 export { TyModal } from './TyModal';
 export type { TyModalProps, TyModalEventDetail, TyModalRef } from './TyModal';
+// Platform/ARIA name alias (the element is also registered as ty-dialog)
+export { TyModal as TyDialog } from './TyModal';
+export type { TyModalProps as TyDialogProps, TyModalEventDetail as TyDialogEventDetail, TyModalRef as TyDialogRef } from './TyModal';
 
 export { TyTooltip } from './TyTooltip';
 export type { TyTooltipProps } from './TyTooltip';
 
-export { TyMultiselect } from './TyMultiselect';
-export type { TyMultiselectProps, TyMultiselectEventDetail } from './TyMultiselect';
+export { TySelect, TySelectedTags } from './TySelect';
+export type { TySelectProps, TySelectEventDetail, TySelectItem, TySelectedTagsProps } from './TySelect';
 
 export { TyCalendar } from './TyCalendar';
 export type { TyCalendarProps, TyCalendarChangeEventDetail, TyCalendarNavigateEventDetail } from './TyCalendar';
@@ -85,6 +85,9 @@ export type { TyRadioGroupProps, TyRadioGroupEventDetail } from './TyRadioGroup'
 
 export { TyCopy } from './TyCopy';
 export type { TyCopyProps } from './TyCopy';
+// Descriptive name alias (the element is also registered as ty-copy-field)
+export { TyCopy as TyCopyField } from './TyCopy';
+export type { TyCopyProps as TyCopyFieldProps } from './TyCopy';
 
 export { TyFileUpload } from './TyFileUpload';
 export type { TyFileUploadProps, TyFileUploadEventDetail } from './TyFileUpload';
@@ -122,12 +125,10 @@ export { TyButton as Button } from './TyButton';
 export { TyTag as Tag } from './TyTag';
 export { TyInput as Input } from './TyInput';
 export { TyTextarea as Textarea } from './TyTextarea';
-export { TyDropdown as Dropdown } from './TyDropdown';
 export { TyOption as Option } from './TyOption';
 export { TyIcon as Icon } from './TyIcon';
 export { TyModal as Modal } from './TyModal';
 export { TyTooltip as Tooltip } from './TyTooltip';
-export { TyMultiselect as Multiselect } from './TyMultiselect';
 export { TyCalendar as Calendar } from './TyCalendar';
 export { TyDatePicker as DatePicker } from './TyDatePicker';
 export { TyPopup as Popup } from './TyPopup';
@@ -162,9 +163,6 @@ export type { TyInputProps as InputProps, TyInputEventDetail as InputEventDetail
 // Textarea types
 export type { TyTextareaProps as TextareaProps, TyTextareaEventDetail as TextareaEventDetail } from './TyTextarea';
 
-// Dropdown types
-export type { TyDropdownProps as DropdownProps, TyDropdownEventDetail as DropdownEventDetail, OptionData } from './TyDropdown';
-
 // Option types
 export type { TyOptionProps as OptionProps } from './TyOption';
 
@@ -177,9 +175,6 @@ export type { TyModalProps as ModalProps, TyModalEventDetail as ModalEventDetail
 // Tooltip types
 export type { TyTooltipProps as TooltipProps } from './TyTooltip';
 
-// Multiselect types
-export type { TyMultiselectProps as MultiselectProps, TyMultiselectEventDetail as MultiselectEventDetail } from './TyMultiselect';
-
 // Calendar types
 export type { TyCalendarProps as CalendarProps, TyCalendarChangeEventDetail as CalendarChangeEventDetail, TyCalendarNavigateEventDetail as CalendarNavigateEventDetail } from './TyCalendar';
 

package/src/version.ts

@@ -3,4 +3,4 @@
 // Run 'npm run generate:version' to regenerate.
 
 /** Current version of tyrell-react. Synced with package.json on build. */
-export const VERSION = '1.0.0-RC10'
+export const VERSION = '1.0.0-RC12'

package/dist/components/TyDropdown.d.ts

@@ -1,62 +0,0 @@
-import React from 'react';
-export interface OptionData {
-    value: string;
-    text: string;
-    disabled?: boolean;
-}
-export interface TyDropdownEventDetail {
-    option: HTMLElement;
-}
-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;
-    /**
-     * Loading state — replaces the open popup options list with a centered
-     * spinner. Search input stays usable. Pair with `externalSearch` while
-     * fetching results from a parent-owned data source.
-     */
-    loading?: boolean;
-    /** Make dropdown readonly */
-    readonly?: boolean;
-    /** Required field */
-    required?: boolean;
-    /** Show clear button */
-    clearable?: boolean;
-    /** Disable clear button (alias for clearable={false}) */
-    notClearable?: boolean;
-    /** Debounce in milliseconds (0-5000) */
-    debounce?: number;
-    /**
-     * Switch to external (remote) search mode. Default is `false` — the dropdown
-     * filters its options locally. When `true`, the dropdown stops filtering and
-     * dispatches `search` events on each keystroke; the parent owns filtering
-     * and updates the children.
-     */
-    externalSearch?: boolean;
-    /** @deprecated Use `externalSearch` instead. */
-    notSearchable?: boolean;
-    /** @deprecated Use `externalSearch` instead. Pass `searchable={false}` was equivalent to `externalSearch={true}`. */
-    searchable?: boolean;
-    /** Form field name for form submission */
-    name?: string;
-    options?: OptionData[];
-    onChange?: (event: CustomEvent<TyDropdownEventDetail>) => void;
-    onSearch?: (event: CustomEvent<{
-        query: string;
-        element: HTMLElement;
-    }>) => void;
-    children?: React.ReactNode;
-}
-export declare const TyDropdown: React.ForwardRefExoticComponent<TyDropdownProps & React.RefAttributes<HTMLElement>>;
-//# sourceMappingURL=TyDropdown.d.ts.map

package/dist/components/TyDropdown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TyDropdown.d.ts","sourceRoot":"","sources":["../../src/components/TyDropdown.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAyC,MAAM,OAAO,CAAC;AAK9D,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAGD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,WAAW,CAAC;CACrB;AAGD,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;IACpG,KAAK,CAAC,EAAE,OAAO,WAAW,EAAE,oBAAoB,CAAC;IACjD,+BAA+B;IAC/B,MAAM,CAAC,EAAE,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;IAEhF,oBAAoB;IACpB,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAExC,qBAAqB;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,qBAAqB;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,qBAAqB;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,wBAAwB;IACxB,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,yDAAyD;IACzD,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB,gDAAgD;IAChD,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB,qHAAqH;IACrH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;IAGd,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IAGvB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,qBAAqB,CAAC,KAAK,IAAI,CAAC;IAC/D,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,WAAW,CAAA;KAAE,CAAC,KAAK,IAAI,CAAC;IAGjF,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAGD,eAAO,MAAM,UAAU,qFAqJtB,CAAC"}