wabtec-internal-volt-extended-components-react 1.0.0

package/dist/basic-components.d.ts

@@ -0,0 +1,56 @@
+import type { JSX } from '@volt/volt-basic-components';
+export declare const VdsAvatar: import("react").ForwardRefExoticComponent<JSX.VdsAvatar & Omit<import("react").HTMLAttributes<HTMLVdsAvatarElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsAvatarElement>>;
+export declare const VdsBadgeDot: import("react").ForwardRefExoticComponent<JSX.VdsBadgeDot & Omit<import("react").HTMLAttributes<HTMLVdsBadgeDotElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsBadgeDotElement>>;
+export declare const VdsBadgePill: import("react").ForwardRefExoticComponent<JSX.VdsBadgePill & Omit<import("react").HTMLAttributes<HTMLVdsBadgePillElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsBadgePillElement>>;
+export declare const VdsBasicAccordion: import("react").ForwardRefExoticComponent<JSX.VdsBasicAccordion & Omit<import("react").HTMLAttributes<HTMLVdsBasicAccordionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsBasicAccordionElement>>;
+export declare const VdsBasicDropdown: import("react").ForwardRefExoticComponent<JSX.VdsBasicDropdown & Omit<import("react").HTMLAttributes<HTMLVdsBasicDropdownElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsBasicDropdownElement>>;
+export declare const VdsBasicDropdownMultiselect: import("react").ForwardRefExoticComponent<JSX.VdsBasicDropdownMultiselect & Omit<import("react").HTMLAttributes<HTMLVdsBasicDropdownMultiselectElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsBasicDropdownMultiselectElement>>;
+export declare const VdsBasicInput: import("react").ForwardRefExoticComponent<JSX.VdsBasicInput & Omit<import("react").HTMLAttributes<HTMLVdsBasicInputElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsBasicInputElement>>;
+export declare const VdsBasicSliderContinuous: import("react").ForwardRefExoticComponent<JSX.VdsBasicSliderContinuous & Omit<import("react").HTMLAttributes<HTMLVdsBasicSliderContinuousElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsBasicSliderContinuousElement>>;
+export declare const VdsBasicTextarea: import("react").ForwardRefExoticComponent<JSX.VdsBasicTextarea & Omit<import("react").HTMLAttributes<HTMLVdsBasicTextareaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsBasicTextareaElement>>;
+export declare const VdsButton: import("react").ForwardRefExoticComponent<JSX.VdsButton & Omit<import("react").HTMLAttributes<HTMLVdsButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsButtonElement>>;
+export declare const VdsCard: import("react").ForwardRefExoticComponent<JSX.VdsCard & Omit<import("react").HTMLAttributes<HTMLVdsCardElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsCardElement>>;
+export declare const VdsCheckbox: import("react").ForwardRefExoticComponent<JSX.VdsCheckbox & Omit<import("react").HTMLAttributes<HTMLVdsCheckboxElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsCheckboxElement>>;
+export declare const VdsChip: import("react").ForwardRefExoticComponent<JSX.VdsChip & Omit<import("react").HTMLAttributes<HTMLVdsChipElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsChipElement>>;
+export declare const VdsDialog: import("react").ForwardRefExoticComponent<JSX.VdsDialog & Omit<import("react").HTMLAttributes<HTMLVdsDialogElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDialogElement>>;
+export declare const VdsDialogActionFooter: import("react").ForwardRefExoticComponent<JSX.VdsDialogActionFooter & Omit<import("react").HTMLAttributes<HTMLVdsDialogActionFooterElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDialogActionFooterElement>>;
+export declare const VdsDialogBody: import("react").ForwardRefExoticComponent<JSX.VdsDialogBody & Omit<import("react").HTMLAttributes<HTMLVdsDialogBodyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDialogBodyElement>>;
+export declare const VdsDialogHeader: import("react").ForwardRefExoticComponent<JSX.VdsDialogHeader & Omit<import("react").HTMLAttributes<HTMLVdsDialogHeaderElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDialogHeaderElement>>;
+export declare const VdsDialogModal: import("react").ForwardRefExoticComponent<JSX.VdsDialogModal & Omit<import("react").HTMLAttributes<HTMLVdsDialogModalElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDialogModalElement>>;
+export declare const VdsDivider: import("react").ForwardRefExoticComponent<JSX.VdsDivider & Omit<import("react").HTMLAttributes<HTMLVdsDividerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDividerElement>>;
+export declare const VdsDrawer: import("react").ForwardRefExoticComponent<JSX.VdsDrawer & Omit<import("react").HTMLAttributes<HTMLVdsDrawerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDrawerElement>>;
+export declare const VdsDropdownGroupHeader: import("react").ForwardRefExoticComponent<JSX.VdsDropdownGroupHeader & Omit<import("react").HTMLAttributes<HTMLVdsDropdownGroupHeaderElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDropdownGroupHeaderElement>>;
+export declare const VdsDropdownItem: import("react").ForwardRefExoticComponent<JSX.VdsDropdownItem & Omit<import("react").HTMLAttributes<HTMLVdsDropdownItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDropdownItemElement>>;
+export declare const VdsField: import("react").ForwardRefExoticComponent<JSX.VdsField & Omit<import("react").HTMLAttributes<HTMLVdsFieldElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsFieldElement>>;
+export declare const VdsFooter: import("react").ForwardRefExoticComponent<JSX.VdsFooter & Omit<import("react").HTMLAttributes<HTMLVdsFooterElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsFooterElement>>;
+export declare const VdsHeader: import("react").ForwardRefExoticComponent<JSX.VdsHeader & Omit<import("react").HTMLAttributes<HTMLVdsHeaderElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsHeaderElement>>;
+export declare const VdsIcon: import("react").ForwardRefExoticComponent<JSX.VdsIcon & Omit<import("react").HTMLAttributes<HTMLVdsIconElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsIconElement>>;
+export declare const VdsIconButton: import("react").ForwardRefExoticComponent<JSX.VdsIconButton & Omit<import("react").HTMLAttributes<HTMLVdsIconButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsIconButtonElement>>;
+export declare const VdsLabel: import("react").ForwardRefExoticComponent<JSX.VdsLabel & Omit<import("react").HTMLAttributes<HTMLVdsLabelElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsLabelElement>>;
+export declare const VdsLink: import("react").ForwardRefExoticComponent<JSX.VdsLink & Omit<import("react").HTMLAttributes<HTMLVdsLinkElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsLinkElement>>;
+export declare const VdsMenu: import("react").ForwardRefExoticComponent<JSX.VdsMenu & Omit<import("react").HTMLAttributes<HTMLVdsMenuElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsMenuElement>>;
+export declare const VdsMenuGroupHeader: import("react").ForwardRefExoticComponent<JSX.VdsMenuGroupHeader & Omit<import("react").HTMLAttributes<HTMLVdsMenuGroupHeaderElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsMenuGroupHeaderElement>>;
+export declare const VdsMenuItem: import("react").ForwardRefExoticComponent<JSX.VdsMenuItem & Omit<import("react").HTMLAttributes<HTMLVdsMenuItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsMenuItemElement>>;
+export declare const VdsMenuList: import("react").ForwardRefExoticComponent<JSX.VdsMenuList & Omit<import("react").HTMLAttributes<HTMLVdsMenuListElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsMenuListElement>>;
+export declare const VdsNotification: import("react").ForwardRefExoticComponent<JSX.VdsNotification & Omit<import("react").HTMLAttributes<HTMLVdsNotificationElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsNotificationElement>>;
+export declare const VdsPopover: import("react").ForwardRefExoticComponent<JSX.VdsPopover & Omit<import("react").HTMLAttributes<HTMLVdsPopoverElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsPopoverElement>>;
+export declare const VdsProgressLinear: import("react").ForwardRefExoticComponent<JSX.VdsProgressLinear & Omit<import("react").HTMLAttributes<HTMLVdsProgressLinearElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsProgressLinearElement>>;
+export declare const VdsRadioButton: import("react").ForwardRefExoticComponent<JSX.VdsRadioButton & Omit<import("react").HTMLAttributes<HTMLVdsRadioButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsRadioButtonElement>>;
+export declare const VdsSidenavItem: import("react").ForwardRefExoticComponent<JSX.VdsSidenavItem & Omit<import("react").HTMLAttributes<HTMLVdsSidenavItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSidenavItemElement>>;
+export declare const VdsSidenavItemApp: import("react").ForwardRefExoticComponent<JSX.VdsSidenavItemApp & Omit<import("react").HTMLAttributes<HTMLVdsSidenavItemAppElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSidenavItemAppElement>>;
+export declare const VdsSidenavItemButton: import("react").ForwardRefExoticComponent<JSX.VdsSidenavItemButton & Omit<import("react").HTMLAttributes<HTMLVdsSidenavItemButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSidenavItemButtonElement>>;
+export declare const VdsSidenavItemCategory: import("react").ForwardRefExoticComponent<JSX.VdsSidenavItemCategory & Omit<import("react").HTMLAttributes<HTMLVdsSidenavItemCategoryElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSidenavItemCategoryElement>>;
+export declare const VdsSidenavItemInput: import("react").ForwardRefExoticComponent<JSX.VdsSidenavItemInput & Omit<import("react").HTMLAttributes<HTMLVdsSidenavItemInputElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSidenavItemInputElement>>;
+export declare const VdsSwitch: import("react").ForwardRefExoticComponent<JSX.VdsSwitch & Omit<import("react").HTMLAttributes<HTMLVdsSwitchElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSwitchElement>>;
+export declare const VdsTab: import("react").ForwardRefExoticComponent<JSX.VdsTab & Omit<import("react").HTMLAttributes<HTMLVdsTabElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsTabElement>>;
+export declare const VdsTabsGroup: import("react").ForwardRefExoticComponent<JSX.VdsTabsGroup & Omit<import("react").HTMLAttributes<HTMLVdsTabsGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsTabsGroupElement>>;
+export declare const VdsTooltip: import("react").ForwardRefExoticComponent<JSX.VdsTooltip & Omit<import("react").HTMLAttributes<HTMLVdsTooltipElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsTooltipElement>>;
+export declare const VdsProgressCircular: import("react").ForwardRefExoticComponent<JSX.VdsProgressCircular & Omit<import("react").HTMLAttributes<HTMLVdsProgressCircularElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsProgressCircularElement>>;
+export declare const VdsAutocompleteItem: import("react").ForwardRefExoticComponent<JSX.VdsAutocompleteItem & Omit<import("react").HTMLAttributes<HTMLVdsAutocompleteItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsAutocompleteItemElement>>;
+export declare const VdsBasicAutocomplete: import("react").ForwardRefExoticComponent<JSX.VdsBasicAutocomplete & Omit<import("react").HTMLAttributes<HTMLVdsBasicAutocompleteElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsBasicAutocompleteElement>>;
+export declare const VdsBasicSliderRangeContinuous: import("react").ForwardRefExoticComponent<JSX.VdsBasicSliderRangeContinuous & Omit<import("react").HTMLAttributes<HTMLVdsBasicSliderRangeContinuousElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsBasicSliderRangeContinuousElement>>;
+export declare const VdsSegmentedButton: import("react").ForwardRefExoticComponent<JSX.VdsSegmentedButton & Omit<import("react").HTMLAttributes<HTMLVdsSegmentedButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSegmentedButtonElement>>;
+export declare const VdsKeyValuePair: import("react").ForwardRefExoticComponent<JSX.VdsKeyValuePair & Omit<import("react").HTMLAttributes<HTMLVdsKeyValuePairElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsKeyValuePairElement>>;
+export declare const VdsUploadItem: import("react").ForwardRefExoticComponent<JSX.VdsUploadItem & Omit<import("react").HTMLAttributes<HTMLVdsUploadItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsUploadItemElement>>;
+export declare const VdsSkeletonLoading: import("react").ForwardRefExoticComponent<JSX.VdsSkeletonLoading & Omit<import("react").HTMLAttributes<HTMLVdsSkeletonLoadingElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSkeletonLoadingElement>>;
+export declare const VdsUploadDrag: import("react").ForwardRefExoticComponent<JSX.VdsUploadDrag & Omit<import("react").HTMLAttributes<HTMLVdsUploadDragElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsUploadDragElement>>;

package/dist/basic-components.js

@@ -0,0 +1,59 @@
+/* eslint-disable */
+/* tslint:disable */
+/* auto-generated react proxies */
+import { createReactComponent } from './react-component-lib';
+export const VdsAvatar = /*@__PURE__*/ createReactComponent('vds-avatar');
+export const VdsBadgeDot = /*@__PURE__*/ createReactComponent('vds-badge-dot');
+export const VdsBadgePill = /*@__PURE__*/ createReactComponent('vds-badge-pill');
+export const VdsBasicAccordion = /*@__PURE__*/ createReactComponent('vds-basic-accordion');
+export const VdsBasicDropdown = /*@__PURE__*/ createReactComponent('vds-basic-dropdown');
+export const VdsBasicDropdownMultiselect = /*@__PURE__*/ createReactComponent('vds-basic-dropdown-multiselect');
+export const VdsBasicInput = /*@__PURE__*/ createReactComponent('vds-basic-input');
+export const VdsBasicSliderContinuous = /*@__PURE__*/ createReactComponent('vds-basic-slider-continuous');
+export const VdsBasicTextarea = /*@__PURE__*/ createReactComponent('vds-basic-textarea');
+export const VdsButton = /*@__PURE__*/ createReactComponent('vds-button');
+export const VdsCard = /*@__PURE__*/ createReactComponent('vds-card');
+export const VdsCheckbox = /*@__PURE__*/ createReactComponent('vds-checkbox');
+export const VdsChip = /*@__PURE__*/ createReactComponent('vds-chip');
+export const VdsDialog = /*@__PURE__*/ createReactComponent('vds-dialog');
+export const VdsDialogActionFooter = /*@__PURE__*/ createReactComponent('vds-dialog-action-footer');
+export const VdsDialogBody = /*@__PURE__*/ createReactComponent('vds-dialog-body');
+export const VdsDialogHeader = /*@__PURE__*/ createReactComponent('vds-dialog-header');
+export const VdsDialogModal = /*@__PURE__*/ createReactComponent('vds-dialog-modal');
+export const VdsDivider = /*@__PURE__*/ createReactComponent('vds-divider');
+export const VdsDrawer = /*@__PURE__*/ createReactComponent('vds-drawer');
+export const VdsDropdownGroupHeader = /*@__PURE__*/ createReactComponent('vds-dropdown-group-header');
+export const VdsDropdownItem = /*@__PURE__*/ createReactComponent('vds-dropdown-item');
+export const VdsField = /*@__PURE__*/ createReactComponent('vds-field');
+export const VdsFooter = /*@__PURE__*/ createReactComponent('vds-footer');
+export const VdsHeader = /*@__PURE__*/ createReactComponent('vds-header');
+export const VdsIcon = /*@__PURE__*/ createReactComponent('vds-icon');
+export const VdsIconButton = /*@__PURE__*/ createReactComponent('vds-icon-button');
+export const VdsLabel = /*@__PURE__*/ createReactComponent('vds-label');
+export const VdsLink = /*@__PURE__*/ createReactComponent('vds-link');
+export const VdsMenu = /*@__PURE__*/ createReactComponent('vds-menu');
+export const VdsMenuGroupHeader = /*@__PURE__*/ createReactComponent('vds-menu-group-header');
+export const VdsMenuItem = /*@__PURE__*/ createReactComponent('vds-menu-item');
+export const VdsMenuList = /*@__PURE__*/ createReactComponent('vds-menu-list');
+export const VdsNotification = /*@__PURE__*/ createReactComponent('vds-notification');
+export const VdsPopover = /*@__PURE__*/ createReactComponent('vds-popover');
+export const VdsProgressLinear = /*@__PURE__*/ createReactComponent('vds-progress-linear');
+export const VdsRadioButton = /*@__PURE__*/ createReactComponent('vds-radio-button');
+export const VdsSidenavItem = /*@__PURE__*/ createReactComponent('vds-sidenav-item');
+export const VdsSidenavItemApp = /*@__PURE__*/ createReactComponent('vds-sidenav-item-app');
+export const VdsSidenavItemButton = /*@__PURE__*/ createReactComponent('vds-sidenav-item-button');
+export const VdsSidenavItemCategory = /*@__PURE__*/ createReactComponent('vds-sidenav-item-category');
+export const VdsSidenavItemInput = /*@__PURE__*/ createReactComponent('vds-sidenav-item-input');
+export const VdsSwitch = /*@__PURE__*/ createReactComponent('vds-switch');
+export const VdsTab = /*@__PURE__*/ createReactComponent('vds-tab');
+export const VdsTabsGroup = /*@__PURE__*/ createReactComponent('vds-tabs-group');
+export const VdsTooltip = /*@__PURE__*/ createReactComponent('vds-tooltip');
+export const VdsProgressCircular = /*@__PURE__*/ createReactComponent('vds-progress-circular');
+export const VdsAutocompleteItem = /*@__PURE__*/ createReactComponent('vds-autocomplete-item');
+export const VdsBasicAutocomplete = /*@__PURE__*/ createReactComponent('vds-basic-autocomplete');
+export const VdsBasicSliderRangeContinuous = /*@__PURE__*/ createReactComponent('vds-basic-slider-range-continuous');
+export const VdsSegmentedButton = /*@__PURE__*/ createReactComponent('vds-segmented-button');
+export const VdsKeyValuePair = /*@__PURE__*/ createReactComponent('vds-key-value-pair');
+export const VdsUploadItem = /*@__PURE__*/ createReactComponent('vds-upload-item');
+export const VdsSkeletonLoading = /*@__PURE__*/ createReactComponent('vds-skeleton-loading');
+export const VdsUploadDrag = /*@__PURE__*/ createReactComponent('vds-upload-drag');

package/dist/components.d.ts

@@ -0,0 +1,22 @@
+import type { JSX } from '@volt/volt-extended-components';
+export declare const VdsAccordionGroup: import("react").ForwardRefExoticComponent<JSX.VdsAccordionGroup & Omit<import("react").HTMLAttributes<HTMLVdsAccordionGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsAccordionGroupElement>>;
+export declare const VdsAutocomplete: import("react").ForwardRefExoticComponent<JSX.VdsAutocomplete & Omit<import("react").HTMLAttributes<HTMLVdsAutocompleteElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsAutocompleteElement>>;
+export declare const VdsAvatarGroup: import("react").ForwardRefExoticComponent<JSX.VdsAvatarGroup & Omit<import("react").HTMLAttributes<HTMLVdsAvatarGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsAvatarGroupElement>>;
+export declare const VdsCalendar: import("react").ForwardRefExoticComponent<JSX.VdsCalendar & Omit<import("react").HTMLAttributes<HTMLVdsCalendarElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsCalendarElement>>;
+export declare const VdsCalendarDayCell: import("react").ForwardRefExoticComponent<JSX.VdsCalendarDayCell & Omit<import("react").HTMLAttributes<HTMLVdsCalendarDayCellElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsCalendarDayCellElement>>;
+export declare const VdsCheckboxGroup: import("react").ForwardRefExoticComponent<JSX.VdsCheckboxGroup & Omit<import("react").HTMLAttributes<HTMLVdsCheckboxGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsCheckboxGroupElement>>;
+export declare const VdsDatePicker: import("react").ForwardRefExoticComponent<JSX.VdsDatePicker & Omit<import("react").HTMLAttributes<HTMLVdsDatePickerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDatePickerElement>>;
+export declare const VdsDropdown: import("react").ForwardRefExoticComponent<JSX.VdsDropdown & Omit<import("react").HTMLAttributes<HTMLVdsDropdownElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsDropdownElement>>;
+export declare const VdsInput: import("react").ForwardRefExoticComponent<JSX.VdsInput & Omit<import("react").HTMLAttributes<HTMLVdsInputElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsInputElement>>;
+export declare const VdsInputDate: import("react").ForwardRefExoticComponent<JSX.VdsInputDate & Omit<import("react").HTMLAttributes<HTMLVdsInputDateElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsInputDateElement>>;
+export declare const VdsInputDateTime: import("react").ForwardRefExoticComponent<JSX.VdsInputDateTime & Omit<import("react").HTMLAttributes<HTMLVdsInputDateTimeElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsInputDateTimeElement>>;
+export declare const VdsInputTime: import("react").ForwardRefExoticComponent<JSX.VdsInputTime & Omit<import("react").HTMLAttributes<HTMLVdsInputTimeElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsInputTimeElement>>;
+export declare const VdsNotificationToast: import("react").ForwardRefExoticComponent<JSX.VdsNotificationToast & Omit<import("react").HTMLAttributes<HTMLVdsNotificationToastElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsNotificationToastElement>>;
+export declare const VdsRadioGroup: import("react").ForwardRefExoticComponent<JSX.VdsRadioGroup & Omit<import("react").HTMLAttributes<HTMLVdsRadioGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsRadioGroupElement>>;
+export declare const VdsSegmentedGroup: import("react").ForwardRefExoticComponent<JSX.VdsSegmentedGroup & Omit<import("react").HTMLAttributes<HTMLVdsSegmentedGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSegmentedGroupElement>>;
+export declare const VdsSidenav: import("react").ForwardRefExoticComponent<JSX.VdsSidenav & Omit<import("react").HTMLAttributes<HTMLVdsSidenavElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSidenavElement>>;
+export declare const VdsSwitchGroup: import("react").ForwardRefExoticComponent<JSX.VdsSwitchGroup & Omit<import("react").HTMLAttributes<HTMLVdsSwitchGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsSwitchGroupElement>>;
+export declare const VdsTextarea: import("react").ForwardRefExoticComponent<JSX.VdsTextarea & Omit<import("react").HTMLAttributes<HTMLVdsTextareaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsTextareaElement>>;
+export declare const VdsTimePanel: import("react").ForwardRefExoticComponent<JSX.VdsTimePanel & Omit<import("react").HTMLAttributes<HTMLVdsTimePanelElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsTimePanelElement>>;
+export declare const VdsTimePicker: import("react").ForwardRefExoticComponent<JSX.VdsTimePicker & Omit<import("react").HTMLAttributes<HTMLVdsTimePickerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsTimePickerElement>>;
+export declare const VdsUpload: import("react").ForwardRefExoticComponent<JSX.VdsUpload & Omit<import("react").HTMLAttributes<HTMLVdsUploadElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVdsUploadElement>>;

package/dist/components.js

@@ -0,0 +1,25 @@
+/* eslint-disable */
+/* tslint:disable */
+/* auto-generated react proxies */
+import { createReactComponent } from './react-component-lib';
+export const VdsAccordionGroup = /*@__PURE__*/ createReactComponent('vds-accordion-group');
+export const VdsAutocomplete = /*@__PURE__*/ createReactComponent('vds-autocomplete');
+export const VdsAvatarGroup = /*@__PURE__*/ createReactComponent('vds-avatar-group');
+export const VdsCalendar = /*@__PURE__*/ createReactComponent('vds-calendar');
+export const VdsCalendarDayCell = /*@__PURE__*/ createReactComponent('vds-calendar-day-cell');
+export const VdsCheckboxGroup = /*@__PURE__*/ createReactComponent('vds-checkbox-group');
+export const VdsDatePicker = /*@__PURE__*/ createReactComponent('vds-date-picker');
+export const VdsDropdown = /*@__PURE__*/ createReactComponent('vds-dropdown');
+export const VdsInput = /*@__PURE__*/ createReactComponent('vds-input');
+export const VdsInputDate = /*@__PURE__*/ createReactComponent('vds-input-date');
+export const VdsInputDateTime = /*@__PURE__*/ createReactComponent('vds-input-date-time');
+export const VdsInputTime = /*@__PURE__*/ createReactComponent('vds-input-time');
+export const VdsNotificationToast = /*@__PURE__*/ createReactComponent('vds-notification-toast');
+export const VdsRadioGroup = /*@__PURE__*/ createReactComponent('vds-radio-group');
+export const VdsSegmentedGroup = /*@__PURE__*/ createReactComponent('vds-segmented-group');
+export const VdsSidenav = /*@__PURE__*/ createReactComponent('vds-sidenav');
+export const VdsSwitchGroup = /*@__PURE__*/ createReactComponent('vds-switch-group');
+export const VdsTextarea = /*@__PURE__*/ createReactComponent('vds-textarea');
+export const VdsTimePanel = /*@__PURE__*/ createReactComponent('vds-time-panel');
+export const VdsTimePicker = /*@__PURE__*/ createReactComponent('vds-time-picker');
+export const VdsUpload = /*@__PURE__*/ createReactComponent('vds-upload');

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./components";
+export * from "./basic-components";

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./components";
+export * from "./basic-components";

package/dist/react-component-lib/createComponent.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface HTMLStencilElement extends HTMLElement {
+    componentOnReady(): Promise<this>;
+}
+interface StencilReactInternalProps<ElementType> extends React.HTMLAttributes<ElementType> {
+    forwardedRef: React.RefObject<ElementType>;
+    ref?: React.Ref<any>;
+}
+export declare const createReactComponent: <PropType, ElementType extends HTMLStencilElement, ContextStateType = {}, ExpandedPropsTypes = {}>(tagName: string, ReactComponentContext?: React.Context<ContextStateType>, manipulatePropsFunction?: (originalProps: StencilReactInternalProps<ElementType>, propsToPass: any) => ExpandedPropsTypes, defineCustomElement?: () => void) => React.ForwardRefExoticComponent<React.PropsWithoutRef<import("./utils").StencilReactExternalProps<PropType, ElementType>> & React.RefAttributes<ElementType>>;
+export {};

package/dist/react-component-lib/createComponent.js

@@ -0,0 +1,74 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { createElement } from 'react';
+import { attachProps, camelToDashCase, createForwardRef, dashToPascalCase, isCoveredByReact, mergeRefs, } from './utils';
+export const createReactComponent = (tagName, ReactComponentContext, manipulatePropsFunction, defineCustomElement) => {
+    if (defineCustomElement !== undefined) {
+        defineCustomElement();
+    }
+    const displayName = dashToPascalCase(tagName);
+    const ReactComponent = class extends React.Component {
+        constructor(props) {
+            super(props);
+            this.setComponentElRef = (element) => {
+                this.componentEl = element;
+            };
+        }
+        componentDidMount() {
+            this.componentDidUpdate(this.props);
+        }
+        componentDidUpdate(prevProps) {
+            attachProps(this.componentEl, this.props, prevProps);
+        }
+        render() {
+            const _a = this.props, { children, forwardedRef, style, className, ref } = _a, cProps = __rest(_a, ["children", "forwardedRef", "style", "className", "ref"]);
+            let propsToPass = Object.keys(cProps).reduce((acc, name) => {
+                const value = cProps[name];
+                if (name.indexOf('on') === 0 && name[2] === name[2].toUpperCase()) {
+                    const eventName = name.substring(2).toLowerCase();
+                    if (typeof document !== 'undefined' && isCoveredByReact(eventName)) {
+                        acc[name] = value;
+                    }
+                }
+                else {
+                    // we should only render strings, booleans, and numbers as attrs in html.
+                    // objects, functions, arrays etc get synced via properties on mount.
+                    const type = typeof value;
+                    if (type === 'string' || type === 'boolean' || type === 'number') {
+                        acc[camelToDashCase(name)] = value;
+                    }
+                }
+                return acc;
+            }, {});
+            if (manipulatePropsFunction) {
+                propsToPass = manipulatePropsFunction(this.props, propsToPass);
+            }
+            const newProps = Object.assign(Object.assign({}, propsToPass), { ref: mergeRefs(forwardedRef, this.setComponentElRef), style });
+            /**
+             * We use createElement here instead of
+             * React.createElement to work around a
+             * bug in Vite (https://github.com/vitejs/vite/issues/6104).
+             * React.createElement causes all elements to be rendered
+             * as <tagname> instead of the actual Web Component.
+             */
+            return createElement(tagName, newProps, children);
+        }
+        static get displayName() {
+            return displayName;
+        }
+    };
+    // If context was passed to createReactComponent then conditionally add it to the Component Class
+    if (ReactComponentContext) {
+        ReactComponent.contextType = ReactComponentContext;
+    }
+    return createForwardRef(ReactComponent, displayName);
+};

package/dist/react-component-lib/createControllerComponent.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+interface LoadingElement {
+    present: () => any;
+    dismiss: () => any;
+}
+interface ReactControllerProps<E> {
+    isOpen: boolean;
+    onDidDismiss: (event: CustomEvent<E>) => void;
+}
+export declare function createControllerComponent<OptionsType extends object, LoadingElementType extends LoadingElement, OverlayEventDetail>(displayName: string, controller: {
+    create: (options: any) => Promise<LoadingElementType>;
+}): {
+    new (props: OptionsType & ReactControllerProps<OverlayEventDetail>): {
+        controller?: LoadingElementType;
+        componentDidMount(): Promise<void>;
+        componentDidUpdate(prevProps: OptionsType & ReactControllerProps<OverlayEventDetail>): Promise<void>;
+        present(prevProps?: OptionsType & ReactControllerProps<OverlayEventDetail>): Promise<void>;
+        render(): null;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<OptionsType & ReactControllerProps<OverlayEventDetail>>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<OptionsType & ReactControllerProps<OverlayEventDetail>>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<OptionsType & ReactControllerProps<OverlayEventDetail>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<OptionsType & ReactControllerProps<OverlayEventDetail>>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<OptionsType & ReactControllerProps<OverlayEventDetail>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<OptionsType & ReactControllerProps<OverlayEventDetail>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<OptionsType & ReactControllerProps<OverlayEventDetail>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<OptionsType & ReactControllerProps<OverlayEventDetail>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    readonly displayName: string;
+    contextType?: React.Context<any>;
+};
+export {};

package/dist/react-component-lib/createControllerComponent.js

@@ -0,0 +1,65 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React from 'react';
+import { attachEventProps } from './utils/attachEventProps';
+export function createControllerComponent(displayName, controller) {
+    const dismissEventName = `on${displayName}DidDismiss`;
+    return class ReactControllerComponent extends React.Component {
+        constructor(props) {
+            super(props);
+        }
+        static get displayName() {
+            return displayName;
+        }
+        componentDidMount() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { isOpen } = this.props;
+                if (isOpen) {
+                    this.present();
+                }
+            });
+        }
+        componentDidUpdate(prevProps) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (prevProps.isOpen !== this.props.isOpen && this.props.isOpen === true) {
+                    this.present(prevProps);
+                }
+                if (this.controller &&
+                    prevProps.isOpen !== this.props.isOpen &&
+                    this.props.isOpen === false) {
+                    yield this.controller.dismiss();
+                }
+            });
+        }
+        present(prevProps) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const _a = this.props, { isOpen, onDidDismiss } = _a, cProps = __rest(_a, ["isOpen", "onDidDismiss"]);
+                const elementProps = Object.assign(Object.assign({}, cProps), { [dismissEventName]: onDidDismiss });
+                this.controller = yield controller.create(Object.assign({}, elementProps));
+                attachEventProps(this.controller, elementProps, prevProps);
+                this.controller.present();
+            });
+        }
+        render() {
+            return null;
+        }
+    };
+}

package/dist/react-component-lib/createOverlayComponent.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { OverlayEventDetail } from './interfaces';
+import { StencilReactForwardedRef } from './utils';
+interface OverlayElement extends HTMLElement {
+    present: () => Promise<void>;
+    dismiss: (data?: any, role?: string | undefined) => Promise<boolean>;
+}
+export interface ReactOverlayProps {
+    children?: React.ReactNode;
+    isOpen: boolean;
+    onDidDismiss?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onDidPresent?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onWillDismiss?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onWillPresent?: (event: CustomEvent<OverlayEventDetail>) => void;
+}
+export declare const createOverlayComponent: <OverlayComponent extends object, OverlayType extends OverlayElement>(tagName: string, controller: {
+    create: (options: any) => Promise<OverlayType>;
+}, customElement?: any) => React.ForwardRefExoticComponent<React.PropsWithoutRef<OverlayComponent & ReactOverlayProps & {
+    forwardedRef?: StencilReactForwardedRef<OverlayType>;
+}> & React.RefAttributes<OverlayType>>;
+export {};

package/dist/react-component-lib/createOverlayComponent.js

@@ -0,0 +1,108 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React from 'react';
+import ReactDOM from 'react-dom';
+import { attachProps, dashToPascalCase, defineCustomElement, setRef, } from './utils';
+export const createOverlayComponent = (tagName, controller, customElement) => {
+    defineCustomElement(tagName, customElement);
+    const displayName = dashToPascalCase(tagName);
+    const didDismissEventName = `on${displayName}DidDismiss`;
+    const didPresentEventName = `on${displayName}DidPresent`;
+    const willDismissEventName = `on${displayName}WillDismiss`;
+    const willPresentEventName = `on${displayName}WillPresent`;
+    let isDismissing = false;
+    class Overlay extends React.Component {
+        constructor(props) {
+            super(props);
+            if (typeof document !== 'undefined') {
+                this.el = document.createElement('div');
+            }
+            this.handleDismiss = this.handleDismiss.bind(this);
+        }
+        static get displayName() {
+            return displayName;
+        }
+        componentDidMount() {
+            if (this.props.isOpen) {
+                this.present();
+            }
+        }
+        componentWillUnmount() {
+            if (this.overlay) {
+                this.overlay.dismiss();
+            }
+        }
+        handleDismiss(event) {
+            if (this.props.onDidDismiss) {
+                this.props.onDidDismiss(event);
+            }
+            setRef(this.props.forwardedRef, null);
+        }
+        shouldComponentUpdate(nextProps) {
+            // Check if the overlay component is about to dismiss
+            if (this.overlay && nextProps.isOpen !== this.props.isOpen && nextProps.isOpen === false) {
+                isDismissing = true;
+            }
+            return true;
+        }
+        componentDidUpdate(prevProps) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.overlay) {
+                    attachProps(this.overlay, this.props, prevProps);
+                }
+                if (prevProps.isOpen !== this.props.isOpen && this.props.isOpen === true) {
+                    this.present(prevProps);
+                }
+                if (this.overlay && prevProps.isOpen !== this.props.isOpen && this.props.isOpen === false) {
+                    yield this.overlay.dismiss();
+                    isDismissing = false;
+                    /**
+                     * Now that the overlay is dismissed
+                     * we need to render again so that any
+                     * inner components will be unmounted
+                     */
+                    this.forceUpdate();
+                }
+            });
+        }
+        present(prevProps) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const _a = this.props, { children, isOpen, onDidDismiss, onDidPresent, onWillDismiss, onWillPresent } = _a, cProps = __rest(_a, ["children", "isOpen", "onDidDismiss", "onDidPresent", "onWillDismiss", "onWillPresent"]);
+                const elementProps = Object.assign(Object.assign({}, cProps), { ref: this.props.forwardedRef, [didDismissEventName]: this.handleDismiss, [didPresentEventName]: (e) => this.props.onDidPresent && this.props.onDidPresent(e), [willDismissEventName]: (e) => this.props.onWillDismiss && this.props.onWillDismiss(e), [willPresentEventName]: (e) => this.props.onWillPresent && this.props.onWillPresent(e) });
+                this.overlay = yield controller.create(Object.assign(Object.assign({}, elementProps), { component: this.el, componentProps: {} }));
+                setRef(this.props.forwardedRef, this.overlay);
+                attachProps(this.overlay, elementProps, prevProps);
+                yield this.overlay.present();
+            });
+        }
+        render() {
+            /**
+             * Continue to render the component even when
+             * overlay is dismissing otherwise component
+             * will be hidden before animation is done.
+             */
+            return ReactDOM.createPortal(this.props.isOpen || isDismissing ? this.props.children : null, this.el);
+        }
+    }
+    return React.forwardRef((props, ref) => {
+        return React.createElement(Overlay, Object.assign({}, props, { forwardedRef: ref }));
+    });
+};

package/dist/react-component-lib/index.d.ts

@@ -0,0 +1,2 @@
+export { createReactComponent } from './createComponent';
+export { createOverlayComponent } from './createOverlayComponent';

package/dist/react-component-lib/index.js

@@ -0,0 +1,2 @@
+export { createReactComponent } from './createComponent';
+export { createOverlayComponent } from './createOverlayComponent';

package/dist/react-component-lib/interfaces.d.ts

@@ -0,0 +1,29 @@
+export interface EventEmitter<T = any> {
+    emit: (data?: T) => CustomEvent<T>;
+}
+export interface StyleReactProps {
+    class?: string;
+    className?: string;
+    style?: {
+        [key: string]: any;
+    };
+}
+export interface OverlayEventDetail<T = any> {
+    data?: T;
+    role?: string;
+}
+export interface OverlayInterface {
+    el: HTMLElement;
+    animated: boolean;
+    keyboardClose: boolean;
+    overlayIndex: number;
+    presented: boolean;
+    enterAnimation?: any;
+    leaveAnimation?: any;
+    didPresent: EventEmitter<void>;
+    willPresent: EventEmitter<void>;
+    willDismiss: EventEmitter<OverlayEventDetail>;
+    didDismiss: EventEmitter<OverlayEventDetail>;
+    present(): Promise<void>;
+    dismiss(data?: any, role?: string): Promise<boolean>;
+}

package/dist/react-component-lib/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/react-component-lib/utils/attachEventProps.d.ts

@@ -0,0 +1,8 @@
+export declare function attachEventProps(node: HTMLElement, newProps: any, oldProps?: any): void;
+export declare function getClassName(classList: DOMTokenList, newProps: any, oldProps: any): string;
+/**
+ * Checks if an event is supported in the current execution environment.
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+export declare function isCoveredByReact(eventNameSuffix: string, doc?: Document): boolean;
+export declare function syncEvent(node: Element, eventName: string, newEventHandler: (e: Event) => any): void;

package/dist/react-component-lib/utils/attachEventProps.js

@@ -0,0 +1,76 @@
+export function attachEventProps(node, newProps, oldProps = {}) {
+    const className = getClassName(node.classList, newProps, oldProps);
+    if (className) {
+        node.className = className;
+    }
+    Object.keys(newProps).forEach(name => {
+        if (name === 'children' || name === 'style' || name === 'ref' || name === 'className') {
+            return;
+        }
+        if (name.indexOf('on') === 0 && name[2] === name[2].toUpperCase()) {
+            const eventName = name.substring(2);
+            const eventNameLc = eventName[0].toLowerCase() + eventName.substring(1);
+            if (!isCoveredByReact(eventNameLc)) {
+                syncEvent(node, eventNameLc, newProps[name]);
+            }
+        }
+        else {
+            node[name] = newProps[name];
+        }
+    });
+}
+export function getClassName(classList, newProps, oldProps) {
+    // map the classes to Maps for performance
+    const currentClasses = arrayToMap(classList);
+    const incomingPropClasses = arrayToMap(newProps.className ? newProps.className.split(' ') : []);
+    const oldPropClasses = arrayToMap(oldProps.className ? oldProps.className.split(' ') : []);
+    const finalClassNames = [];
+    // loop through each of the current classes on the component
+    // to see if it should be a part of the classNames added
+    currentClasses.forEach(currentClass => {
+        if (incomingPropClasses.has(currentClass)) {
+            // add it as its already included in classnames coming in from newProps
+            finalClassNames.push(currentClass);
+            incomingPropClasses.delete(currentClass);
+        }
+        else if (!oldPropClasses.has(currentClass)) {
+            // add it as it has NOT been removed by user
+            finalClassNames.push(currentClass);
+        }
+    });
+    incomingPropClasses.forEach(s => finalClassNames.push(s));
+    return finalClassNames.join(' ');
+}
+/**
+ * Checks if an event is supported in the current execution environment.
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+export function isCoveredByReact(eventNameSuffix, doc = document) {
+    const eventName = 'on' + eventNameSuffix;
+    let isSupported = eventName in doc;
+    if (!isSupported) {
+        const element = doc.createElement('div');
+        element.setAttribute(eventName, 'return;');
+        isSupported = typeof element[eventName] === 'function';
+    }
+    return isSupported;
+}
+export function syncEvent(node, eventName, newEventHandler) {
+    const eventStore = node.__events || (node.__events = {});
+    const oldEventHandler = eventStore[eventName];
+    // Remove old listener so they don't double up.
+    if (oldEventHandler) {
+        node.removeEventListener(eventName, oldEventHandler);
+    }
+    if (newEventHandler != null) {
+        // Bind new listener.
+        node.addEventListener(eventName, (eventStore[eventName] = function handler(e) {
+            newEventHandler.call(this, e);
+        }));
+    }
+}
+function arrayToMap(arr) {
+    const map = new Map();
+    arr.forEach((s) => map.set(s, s));
+    return map;
+}

package/dist/react-component-lib/utils/attachProps.d.ts

@@ -0,0 +1,12 @@
+export declare const attachProps: (node: HTMLElement, newProps: any, oldProps?: any) => void;
+export declare const getClassName: (classList: DOMTokenList, newProps: any, oldProps: any) => string;
+/**
+ * Checks if an event is supported in the current execution environment.
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+export declare const isCoveredByReact: (eventNameSuffix: string) => boolean;
+export declare const syncEvent: (node: Element & {
+    __events?: {
+        [key: string]: (e: Event) => any;
+    };
+}, eventName: string, newEventHandler?: (e: Event) => any) => void;

package/dist/react-component-lib/utils/attachProps.js

@@ -0,0 +1,97 @@
+import { camelToDashCase } from './case';
+export const attachProps = (node, newProps, oldProps = {}) => {
+    // some test frameworks don't render DOM elements, so we test here to make sure we are dealing with DOM first
+    if (node instanceof Element) {
+        // add any classes in className to the class list
+        const className = getClassName(node.classList, newProps, oldProps);
+        if (className !== '') {
+            node.className = className;
+        }
+        Object.keys(newProps).forEach((name) => {
+            if (name === 'children' ||
+                name === 'style' ||
+                name === 'ref' ||
+                name === 'class' ||
+                name === 'className' ||
+                name === 'forwardedRef') {
+                return;
+            }
+            if (name.indexOf('on') === 0 && name[2] === name[2].toUpperCase()) {
+                const eventName = name.substring(2);
+                const eventNameLc = eventName[0].toLowerCase() + eventName.substring(1);
+                if (!isCoveredByReact(eventNameLc)) {
+                    syncEvent(node, eventNameLc, newProps[name]);
+                }
+            }
+            else {
+                node[name] = newProps[name];
+                const propType = typeof newProps[name];
+                if (propType === 'string') {
+                    node.setAttribute(camelToDashCase(name), newProps[name]);
+                }
+            }
+        });
+    }
+};
+export const getClassName = (classList, newProps, oldProps) => {
+    const newClassProp = newProps.className || newProps.class;
+    const oldClassProp = oldProps.className || oldProps.class;
+    // map the classes to Maps for performance
+    const currentClasses = arrayToMap(classList);
+    const incomingPropClasses = arrayToMap(newClassProp ? newClassProp.split(' ') : []);
+    const oldPropClasses = arrayToMap(oldClassProp ? oldClassProp.split(' ') : []);
+    const finalClassNames = [];
+    // loop through each of the current classes on the component
+    // to see if it should be a part of the classNames added
+    currentClasses.forEach((currentClass) => {
+        if (incomingPropClasses.has(currentClass)) {
+            // add it as its already included in classnames coming in from newProps
+            finalClassNames.push(currentClass);
+            incomingPropClasses.delete(currentClass);
+        }
+        else if (!oldPropClasses.has(currentClass)) {
+            // add it as it has NOT been removed by user
+            finalClassNames.push(currentClass);
+        }
+    });
+    incomingPropClasses.forEach((s) => finalClassNames.push(s));
+    return finalClassNames.join(' ');
+};
+/**
+ * Checks if an event is supported in the current execution environment.
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+export const isCoveredByReact = (eventNameSuffix) => {
+    if (typeof document === 'undefined') {
+        return true;
+    }
+    else {
+        const eventName = 'on' + eventNameSuffix;
+        let isSupported = eventName in document;
+        if (!isSupported) {
+            const element = document.createElement('div');
+            element.setAttribute(eventName, 'return;');
+            isSupported = typeof element[eventName] === 'function';
+        }
+        return isSupported;
+    }
+};
+export const syncEvent = (node, eventName, newEventHandler) => {
+    const eventStore = node.__events || (node.__events = {});
+    const oldEventHandler = eventStore[eventName];
+    // Remove old listener so they don't double up.
+    if (oldEventHandler) {
+        node.removeEventListener(eventName, oldEventHandler);
+    }
+    // Bind new listener.
+    node.addEventListener(eventName, (eventStore[eventName] = function handler(e) {
+        if (newEventHandler) {
+            newEventHandler.call(this, e);
+        }
+    }));
+};
+const arrayToMap = (arr) => {
+    const map = new Map();
+    arr.forEach((s) => map.set(s, s));
+    return map;
+};

package/dist/react-component-lib/utils/case.d.ts

@@ -0,0 +1,2 @@
+export declare const dashToPascalCase: (str: string) => string;
+export declare const camelToDashCase: (str: string) => string;

package/dist/react-component-lib/utils/case.js

@@ -0,0 +1,6 @@
+export const dashToPascalCase = (str) => str
+    .toLowerCase()
+    .split('-')
+    .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+    .join('');
+export const camelToDashCase = (str) => str.replace(/([A-Z])/g, (m) => `-${m[0].toLowerCase()}`);

package/dist/react-component-lib/utils/dev.d.ts

@@ -0,0 +1,2 @@
+export declare const isDevMode: () => boolean;
+export declare const deprecationWarning: (key: string, message: string) => void;

package/dist/react-component-lib/utils/dev.js

@@ -0,0 +1,12 @@
+export const isDevMode = () => {
+    return process && process.env && process.env.NODE_ENV === 'development';
+};
+const warnings = {};
+export const deprecationWarning = (key, message) => {
+    if (isDevMode()) {
+        if (!warnings[key]) {
+            console.warn(message);
+            warnings[key] = true;
+        }
+    }
+};

package/dist/react-component-lib/utils/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { StyleReactProps } from '../interfaces';
+export declare type StencilReactExternalProps<PropType, ElementType> = PropType & Omit<React.HTMLAttributes<ElementType>, 'style'> & StyleReactProps;
+export declare type StencilReactForwardedRef<T> = ((instance: T | null) => void) | React.MutableRefObject<T | null> | null;
+export declare const setRef: (ref: StencilReactForwardedRef<any> | React.Ref<any> | undefined, value: any) => void;
+export declare const mergeRefs: (...refs: (StencilReactForwardedRef<any> | React.Ref<any> | undefined)[]) => React.RefCallback<any>;
+export declare const createForwardRef: <PropType, ElementType>(ReactComponent: any, displayName: string) => React.ForwardRefExoticComponent<React.PropsWithoutRef<StencilReactExternalProps<PropType, ElementType>> & React.RefAttributes<ElementType>>;
+export declare const defineCustomElement: (tagName: string, customElement: any) => void;
+export * from './attachProps';
+export * from './case';

package/dist/react-component-lib/utils/index.js

@@ -0,0 +1,33 @@
+import React from 'react';
+export const setRef = (ref, value) => {
+    if (typeof ref === 'function') {
+        ref(value);
+    }
+    else if (ref != null) {
+        // Cast as a MutableRef so we can assign current
+        ref.current = value;
+    }
+};
+export const mergeRefs = (...refs) => {
+    return (value) => {
+        refs.forEach(ref => {
+            setRef(ref, value);
+        });
+    };
+};
+export const createForwardRef = (ReactComponent, displayName) => {
+    const forwardRef = (props, ref) => {
+        return React.createElement(ReactComponent, Object.assign({}, props, { forwardedRef: ref }));
+    };
+    forwardRef.displayName = displayName;
+    return React.forwardRef(forwardRef);
+};
+export const defineCustomElement = (tagName, customElement) => {
+    if (customElement !== undefined &&
+        typeof customElements !== 'undefined' &&
+        !customElements.get(tagName)) {
+        customElements.define(tagName, customElement);
+    }
+};
+export * from './attachProps';
+export * from './case';

package/package.json

@@ -0,0 +1,53 @@
+{
+	"name": "wabtec-internal-volt-extended-components-react",
+	"sideEffects": false,
+	"version": "1.0.0",
+	"description": "React component library for the Volt Extended components",
+	"repository": {},
+	"author": "Wilmer Contreras <wilmer.contreras@wabtec.com>",
+	"license": "MIT",
+	"scripts": {
+		"build": "npm run clean && npm run compile",
+		"clean": "rm -rf dist",
+		"compile": "npm run tsc",
+		"tsc": "tsc -p ."
+	},
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist/"
+	],
+	"devDependencies": {
+		"@types/jest": "^23.3.9",
+		"@types/node": "^13.5.0",
+		"@types/react": "^18.0.9",
+		"@types/react-dom": "^18.0.4",
+		"jest": "^25.1.0",
+		"jest-dom": "^3.0.2",
+		"prettier": "1.19.1",
+		"react": "^16.12.0",
+		"react-dom": "^16.12.0",
+		"rollup": "^1.21.2",
+		"rollup-plugin-node-resolve": "^5.2.0",
+		"typescript": "^4.4.4"
+	},
+	"dependencies": {
+		"wabtec-internal-volt-extended-components": "1.0.0",
+		"react": "^16.12.0",
+		"react-dom": "^16.12.0"
+	},
+	"peerDependencies": {
+		"wabtec-internal-volt-extended-components": "1.0.0",
+		"react": "^16.7.0",
+		"react-dom": "^16.7.0"
+	},
+	"jest": {
+		"preset": "ts-jest",
+		"setupTestFrameworkScriptFile": "<rootDir>/jest.setup.js",
+		"testPathIgnorePatterns": [
+			"node_modules",
+			"dist"
+		]
+	}
+}