@heartlandone/vega-react-sandbox-pr-2081-87a135a2ff0e4c723a3194f140abab0e3106a715 2.49.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Ionic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,4 @@
+# Vega React
+> React specific wrapper for [@heartlandone/vega](https://www.npmjs.com/package/@heartlandone/vega)
+
+For installation guidance, please refer to https://vega.hlprd.com/guides/getting-started-developers#react

package/dist/components.d.ts

@@ -0,0 +1,110 @@
+/// <reference types="react" />
+import type { JSX } from '@heartlandone/vega-sandbox-pr-2081-87a135a2ff0e4c723a3194f140abab0e3106a715';
+export declare const VegaAccordion: import("react").ForwardRefExoticComponent<JSX.VegaAccordion & Omit<import("react").HTMLAttributes<HTMLVegaAccordionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaAccordionElement>>;
+export declare const VegaAppFooter: import("react").ForwardRefExoticComponent<JSX.VegaAppFooter & Omit<import("react").HTMLAttributes<HTMLVegaAppFooterElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaAppFooterElement>>;
+export declare const VegaAppHeaderButton: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaAppHeaderButton, Omit<import("react").HTMLAttributes<HTMLVegaAppHeaderButtonElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaAppHeaderButtonElement>>;
+export declare const VegaBackdrop: import("react").ForwardRefExoticComponent<JSX.VegaBackdrop & Omit<import("react").HTMLAttributes<HTMLVegaBackdropElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaBackdropElement>>;
+export declare const VegaBanner: import("react").ForwardRefExoticComponent<JSX.VegaBanner & Omit<import("react").HTMLAttributes<HTMLVegaBannerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaBannerElement>>;
+export declare const VegaBarChart: import("react").ForwardRefExoticComponent<JSX.VegaBarChart & Omit<import("react").HTMLAttributes<HTMLVegaBarChartElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaBarChartElement>>;
+export declare const VegaBox: import("react").ForwardRefExoticComponent<JSX.VegaBox & Omit<import("react").HTMLAttributes<HTMLVegaBoxElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaBoxElement>>;
+export declare const VegaBrandLogo: import("react").ForwardRefExoticComponent<JSX.VegaBrandLogo & Omit<import("react").HTMLAttributes<HTMLVegaBrandLogoElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaBrandLogoElement>>;
+export declare const VegaBreadcrumb: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaBreadcrumb, Omit<import("react").HTMLAttributes<HTMLVegaBreadcrumbElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaBreadcrumbElement>>;
+export declare const VegaButton: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaButton, Omit<import("react").HTMLAttributes<HTMLVegaButtonElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaButtonElement>>;
+export declare const VegaButtonCircle: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaButtonCircle, Omit<import("react").HTMLAttributes<HTMLVegaButtonCircleElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaButtonCircleElement>>;
+export declare const VegaButtonGroup: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaButtonGroup, Omit<import("react").HTMLAttributes<HTMLVegaButtonGroupElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaButtonGroupElement>>;
+export declare const VegaButtonGroupItem: import("react").ForwardRefExoticComponent<JSX.VegaButtonGroupItem & Omit<import("react").HTMLAttributes<HTMLVegaButtonGroupItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaButtonGroupItemElement>>;
+export declare const VegaButtonLink: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaButtonLink, Omit<import("react").HTMLAttributes<HTMLVegaButtonLinkElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaButtonLinkElement>>;
+export declare const VegaCalendar: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaCalendar, Omit<import("react").HTMLAttributes<HTMLVegaCalendarElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaCalendarElement>>;
+export declare const VegaCalendarEvent: import("react").ForwardRefExoticComponent<JSX.VegaCalendarEvent & Omit<import("react").HTMLAttributes<HTMLVegaCalendarEventElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaCalendarEventElement>>;
+export declare const VegaCalendarEventSlot: import("react").ForwardRefExoticComponent<JSX.VegaCalendarEventSlot & Omit<import("react").HTMLAttributes<HTMLVegaCalendarEventSlotElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaCalendarEventSlotElement>>;
+export declare const VegaCard: import("react").ForwardRefExoticComponent<JSX.VegaCard & Omit<import("react").HTMLAttributes<HTMLVegaCardElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaCardElement>>;
+export declare const VegaCarousel: import("react").ForwardRefExoticComponent<JSX.VegaCarousel & Omit<import("react").HTMLAttributes<HTMLVegaCarouselElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaCarouselElement>>;
+export declare const VegaCheckbox: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaCheckbox, Omit<import("react").HTMLAttributes<HTMLVegaCheckboxElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaCheckboxElement>>;
+export declare const VegaCheckboxGroup: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaCheckboxGroup, Omit<import("react").HTMLAttributes<HTMLVegaCheckboxGroupElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaCheckboxGroupElement>>;
+export declare const VegaChip: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaChip, Omit<import("react").HTMLAttributes<HTMLVegaChipElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaChipElement>>;
+export declare const VegaCodeBlock: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaCodeBlock, Omit<import("react").HTMLAttributes<HTMLVegaCodeBlockElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaCodeBlockElement>>;
+export declare const VegaColorPicker: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaColorPicker, Omit<import("react").HTMLAttributes<HTMLVegaColorPickerElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaColorPickerElement>>;
+export declare const VegaComboBox: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaComboBox, Omit<import("react").HTMLAttributes<HTMLVegaComboBoxElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaComboBoxElement>>;
+export declare const VegaCounterBadge: import("react").ForwardRefExoticComponent<JSX.VegaCounterBadge & Omit<import("react").HTMLAttributes<HTMLVegaCounterBadgeElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaCounterBadgeElement>>;
+export declare const VegaDatePicker: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaDatePicker, Omit<import("react").HTMLAttributes<HTMLVegaDatePickerElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaDatePickerElement>>;
+export declare const VegaDatePickerCalendar: import("react").ForwardRefExoticComponent<JSX.VegaDatePickerCalendar & Omit<import("react").HTMLAttributes<HTMLVegaDatePickerCalendarElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaDatePickerCalendarElement>>;
+export declare const VegaDialog: import("react").ForwardRefExoticComponent<JSX.VegaDialog & Omit<import("react").HTMLAttributes<HTMLVegaDialogElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaDialogElement>>;
+export declare const VegaDivider: import("react").ForwardRefExoticComponent<JSX.VegaDivider & Omit<import("react").HTMLAttributes<HTMLVegaDividerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaDividerElement>>;
+export declare const VegaDropdown: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaDropdown, Omit<import("react").HTMLAttributes<HTMLVegaDropdownElement>, "style">, "onReset"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaDropdownElement>>;
+export declare const VegaDropdownContentBox: import("react").ForwardRefExoticComponent<JSX.VegaDropdownContentBox & Omit<import("react").HTMLAttributes<HTMLVegaDropdownContentBoxElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaDropdownContentBoxElement>>;
+export declare const VegaDropdownGroup: import("react").ForwardRefExoticComponent<JSX.VegaDropdownGroup & Omit<import("react").HTMLAttributes<HTMLVegaDropdownGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaDropdownGroupElement>>;
+export declare const VegaDropdownItem: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaDropdownItem, Omit<import("react").HTMLAttributes<HTMLVegaDropdownItemElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaDropdownItemElement>>;
+export declare const VegaFieldError: import("react").ForwardRefExoticComponent<JSX.VegaFieldError & Omit<import("react").HTMLAttributes<HTMLVegaFieldErrorElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaFieldErrorElement>>;
+export declare const VegaFieldLabel: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaFieldLabel, Omit<import("react").HTMLAttributes<HTMLVegaFieldLabelElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaFieldLabelElement>>;
+export declare const VegaFileUploader: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaFileUploader, Omit<import("react").HTMLAttributes<HTMLVegaFileUploaderElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaFileUploaderElement>>;
+export declare const VegaFlagIcon: import("react").ForwardRefExoticComponent<JSX.VegaFlagIcon & Omit<import("react").HTMLAttributes<HTMLVegaFlagIconElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaFlagIconElement>>;
+export declare const VegaFlex: import("react").ForwardRefExoticComponent<JSX.VegaFlex & Omit<import("react").HTMLAttributes<HTMLVegaFlexElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaFlexElement>>;
+export declare const VegaFont: import("react").ForwardRefExoticComponent<JSX.VegaFont & Omit<import("react").HTMLAttributes<HTMLVegaFontElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaFontElement>>;
+export declare const VegaForm: import("react").ForwardRefExoticComponent<JSX.VegaForm & Omit<import("react").HTMLAttributes<HTMLVegaFormElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaFormElement>>;
+export declare const VegaGrid: import("react").ForwardRefExoticComponent<JSX.VegaGrid & Omit<import("react").HTMLAttributes<HTMLVegaGridElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaGridElement>>;
+export declare const VegaHint: import("react").ForwardRefExoticComponent<JSX.VegaHint & Omit<import("react").HTMLAttributes<HTMLVegaHintElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaHintElement>>;
+export declare const VegaIcon: import("react").ForwardRefExoticComponent<JSX.VegaIcon & Omit<import("react").HTMLAttributes<HTMLVegaIconElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaIconElement>>;
+export declare const VegaImageUploader: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaImageUploader, Omit<import("react").HTMLAttributes<HTMLVegaImageUploaderElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaImageUploaderElement>>;
+export declare const VegaInput: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaInput, Omit<import("react").HTMLAttributes<HTMLVegaInputElement>, "style">, "onChange"|"onFocus"|"onBlur"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaInputElement>>;
+export declare const VegaInputCreditCard: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaInputCreditCard, Omit<import("react").HTMLAttributes<HTMLVegaInputCreditCardElement>, "style">, "onChange"|"onBlur"|"onFocus"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaInputCreditCardElement>>;
+export declare const VegaInputNumeric: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaInputNumeric, Omit<import("react").HTMLAttributes<HTMLVegaInputNumericElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaInputNumericElement>>;
+export declare const VegaInputPhoneNumber: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaInputPhoneNumber, Omit<import("react").HTMLAttributes<HTMLVegaInputPhoneNumberElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaInputPhoneNumberElement>>;
+export declare const VegaInputRange: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaInputRange, Omit<import("react").HTMLAttributes<HTMLVegaInputRangeElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaInputRangeElement>>;
+export declare const VegaInputSelect: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaInputSelect, Omit<import("react").HTMLAttributes<HTMLVegaInputSelectElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaInputSelectElement>>;
+export declare const VegaItemToggle: import("react").ForwardRefExoticComponent<JSX.VegaItemToggle & Omit<import("react").HTMLAttributes<HTMLVegaItemToggleElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaItemToggleElement>>;
+export declare const VegaLeftNav: import("react").ForwardRefExoticComponent<JSX.VegaLeftNav & Omit<import("react").HTMLAttributes<HTMLVegaLeftNavElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaLeftNavElement>>;
+export declare const VegaLeftNavGroup: import("react").ForwardRefExoticComponent<JSX.VegaLeftNavGroup & Omit<import("react").HTMLAttributes<HTMLVegaLeftNavGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaLeftNavGroupElement>>;
+export declare const VegaLeftNavLink: import("react").ForwardRefExoticComponent<JSX.VegaLeftNavLink & Omit<import("react").HTMLAttributes<HTMLVegaLeftNavLinkElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaLeftNavLinkElement>>;
+export declare const VegaLeftNavSection: import("react").ForwardRefExoticComponent<JSX.VegaLeftNavSection & Omit<import("react").HTMLAttributes<HTMLVegaLeftNavSectionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaLeftNavSectionElement>>;
+export declare const VegaLineChart: import("react").ForwardRefExoticComponent<JSX.VegaLineChart & Omit<import("react").HTMLAttributes<HTMLVegaLineChartElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaLineChartElement>>;
+export declare const VegaLoaderWrapper: import("react").ForwardRefExoticComponent<JSX.VegaLoaderWrapper & Omit<import("react").HTMLAttributes<HTMLVegaLoaderWrapperElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaLoaderWrapperElement>>;
+export declare const VegaLoadingIndicator: import("react").ForwardRefExoticComponent<JSX.VegaLoadingIndicator & Omit<import("react").HTMLAttributes<HTMLVegaLoadingIndicatorElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaLoadingIndicatorElement>>;
+export declare const VegaModal: import("react").ForwardRefExoticComponent<JSX.VegaModal & Omit<import("react").HTMLAttributes<HTMLVegaModalElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaModalElement>>;
+export declare const VegaNavCard: import("react").ForwardRefExoticComponent<JSX.VegaNavCard & Omit<import("react").HTMLAttributes<HTMLVegaNavCardElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaNavCardElement>>;
+export declare const VegaPageNotification: import("react").ForwardRefExoticComponent<JSX.VegaPageNotification & Omit<import("react").HTMLAttributes<HTMLVegaPageNotificationElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaPageNotificationElement>>;
+export declare const VegaPageNotificationList: import("react").ForwardRefExoticComponent<JSX.VegaPageNotificationList & Omit<import("react").HTMLAttributes<HTMLVegaPageNotificationListElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaPageNotificationListElement>>;
+export declare const VegaPagination: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaPagination, Omit<import("react").HTMLAttributes<HTMLVegaPaginationElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaPaginationElement>>;
+export declare const VegaPaginationPageSelectorMobile: import("react").ForwardRefExoticComponent<JSX.VegaPaginationPageSelectorMobile & Omit<import("react").HTMLAttributes<HTMLVegaPaginationPageSelectorMobileElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaPaginationPageSelectorMobileElement>>;
+export declare const VegaPaginationPageSizeSelectorMobile: import("react").ForwardRefExoticComponent<JSX.VegaPaginationPageSizeSelectorMobile & Omit<import("react").HTMLAttributes<HTMLVegaPaginationPageSizeSelectorMobileElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaPaginationPageSizeSelectorMobileElement>>;
+export declare const VegaPieChart: import("react").ForwardRefExoticComponent<JSX.VegaPieChart & Omit<import("react").HTMLAttributes<HTMLVegaPieChartElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaPieChartElement>>;
+export declare const VegaPopover: import("react").ForwardRefExoticComponent<JSX.VegaPopover & Omit<import("react").HTMLAttributes<HTMLVegaPopoverElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaPopoverElement>>;
+export declare const VegaPopoverContentBox: import("react").ForwardRefExoticComponent<JSX.VegaPopoverContentBox & Omit<import("react").HTMLAttributes<HTMLVegaPopoverContentBoxElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaPopoverContentBoxElement>>;
+export declare const VegaProgressTracker: import("react").ForwardRefExoticComponent<JSX.VegaProgressTracker & Omit<import("react").HTMLAttributes<HTMLVegaProgressTrackerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaProgressTrackerElement>>;
+export declare const VegaRadio: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaRadio, Omit<import("react").HTMLAttributes<HTMLVegaRadioElement>, "style">, "onChange"|"onFocus"|"onBlur"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaRadioElement>>;
+export declare const VegaRadioGroup: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaRadioGroup, Omit<import("react").HTMLAttributes<HTMLVegaRadioGroupElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaRadioGroupElement>>;
+export declare const VegaRichTextContent: import("react").ForwardRefExoticComponent<JSX.VegaRichTextContent & Omit<import("react").HTMLAttributes<HTMLVegaRichTextContentElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaRichTextContentElement>>;
+export declare const VegaRichTextEditor: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaRichTextEditor, Omit<import("react").HTMLAttributes<HTMLVegaRichTextEditorElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaRichTextEditorElement>>;
+export declare const VegaRichTextEditorToolbarButton: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaRichTextEditorToolbarButton, Omit<import("react").HTMLAttributes<HTMLVegaRichTextEditorToolbarButtonElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaRichTextEditorToolbarButtonElement>>;
+export declare const VegaRichTextImageEditor: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaRichTextImageEditor, Omit<import("react").HTMLAttributes<HTMLVegaRichTextImageEditorElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaRichTextImageEditorElement>>;
+export declare const VegaRichTextLinkEditor: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaRichTextLinkEditor, Omit<import("react").HTMLAttributes<HTMLVegaRichTextLinkEditorElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaRichTextLinkEditorElement>>;
+export declare const VegaSectionTitle: import("react").ForwardRefExoticComponent<JSX.VegaSectionTitle & Omit<import("react").HTMLAttributes<HTMLVegaSectionTitleElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSectionTitleElement>>;
+export declare const VegaSegmentControl: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaSegmentControl, Omit<import("react").HTMLAttributes<HTMLVegaSegmentControlElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSegmentControlElement>>;
+export declare const VegaSelectionChip: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaSelectionChip, Omit<import("react").HTMLAttributes<HTMLVegaSelectionChipElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSelectionChipElement>>;
+export declare const VegaSelectionChipGroup: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaSelectionChipGroup, Omit<import("react").HTMLAttributes<HTMLVegaSelectionChipGroupElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSelectionChipGroupElement>>;
+export declare const VegaSelectionTile: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaSelectionTile, Omit<import("react").HTMLAttributes<HTMLVegaSelectionTileElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSelectionTileElement>>;
+export declare const VegaSelectionTileGroup: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaSelectionTileGroup, Omit<import("react").HTMLAttributes<HTMLVegaSelectionTileGroupElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSelectionTileGroupElement>>;
+export declare const VegaSidenav: import("react").ForwardRefExoticComponent<JSX.VegaSidenav & Omit<import("react").HTMLAttributes<HTMLVegaSidenavElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSidenavElement>>;
+export declare const VegaSidenavGroup: import("react").ForwardRefExoticComponent<JSX.VegaSidenavGroup & Omit<import("react").HTMLAttributes<HTMLVegaSidenavGroupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSidenavGroupElement>>;
+export declare const VegaSidenavLink: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaSidenavLink, Omit<import("react").HTMLAttributes<HTMLVegaSidenavLinkElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSidenavLinkElement>>;
+export declare const VegaSignatureCapture: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaSignatureCapture, Omit<import("react").HTMLAttributes<HTMLVegaSignatureCaptureElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSignatureCaptureElement>>;
+export declare const VegaSkeleton: import("react").ForwardRefExoticComponent<JSX.VegaSkeleton & Omit<import("react").HTMLAttributes<HTMLVegaSkeletonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSkeletonElement>>;
+export declare const VegaSlotContainer: import("react").ForwardRefExoticComponent<JSX.VegaSlotContainer & Omit<import("react").HTMLAttributes<HTMLVegaSlotContainerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaSlotContainerElement>>;
+export declare const VegaStepper: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaStepper, Omit<import("react").HTMLAttributes<HTMLVegaStepperElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaStepperElement>>;
+export declare const VegaTabGroup: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaTabGroup, Omit<import("react").HTMLAttributes<HTMLVegaTabGroupElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTabGroupElement>>;
+export declare const VegaTabGroupPanel: import("react").ForwardRefExoticComponent<JSX.VegaTabGroupPanel & Omit<import("react").HTMLAttributes<HTMLVegaTabGroupPanelElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTabGroupPanelElement>>;
+export declare const VegaTable: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaTable, Omit<import("react").HTMLAttributes<HTMLVegaTableElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTableElement>>;
+export declare const VegaTableBody: import("react").ForwardRefExoticComponent<JSX.VegaTableBody & Omit<import("react").HTMLAttributes<HTMLVegaTableBodyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTableBodyElement>>;
+export declare const VegaTableCell: import("react").ForwardRefExoticComponent<JSX.VegaTableCell & Omit<import("react").HTMLAttributes<HTMLVegaTableCellElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTableCellElement>>;
+export declare const VegaTableExpandRow: import("react").ForwardRefExoticComponent<JSX.VegaTableExpandRow & Omit<import("react").HTMLAttributes<HTMLVegaTableExpandRowElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTableExpandRowElement>>;
+export declare const VegaTableHead: import("react").ForwardRefExoticComponent<JSX.VegaTableHead & Omit<import("react").HTMLAttributes<HTMLVegaTableHeadElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTableHeadElement>>;
+export declare const VegaTableHeadCell: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaTableHeadCell, Omit<import("react").HTMLAttributes<HTMLVegaTableHeadCellElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTableHeadCellElement>>;
+export declare const VegaTableHeadRow: import("react").ForwardRefExoticComponent<JSX.VegaTableHeadRow & Omit<import("react").HTMLAttributes<HTMLVegaTableHeadRowElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTableHeadRowElement>>;
+export declare const VegaTableRow: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaTableRow, Omit<import("react").HTMLAttributes<HTMLVegaTableRowElement>, "style">, "onClick"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTableRowElement>>;
+export declare const VegaText: import("react").ForwardRefExoticComponent<JSX.VegaText & Omit<import("react").HTMLAttributes<HTMLVegaTextElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTextElement>>;
+export declare const VegaTextarea: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaTextarea, Omit<import("react").HTMLAttributes<HTMLVegaTextareaElement>, "style">, "onChange"|"onBlur"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTextareaElement>>;
+export declare const VegaTimePicker: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaTimePicker, Omit<import("react").HTMLAttributes<HTMLVegaTimePickerElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTimePickerElement>>;
+export declare const VegaTimePickerDropdown: import("react").ForwardRefExoticComponent<JSX.VegaTimePickerDropdown & Omit<import("react").HTMLAttributes<HTMLVegaTimePickerDropdownElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTimePickerDropdownElement>>;
+export declare const VegaToggleSwitch: import("react").ForwardRefExoticComponent<VegaReactComponentWithNativeEvent<JSX.VegaToggleSwitch, Omit<import("react").HTMLAttributes<HTMLVegaToggleSwitchElement>, "style">, "onChange"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaToggleSwitchElement>>;
+export declare const VegaTooltip: import("react").ForwardRefExoticComponent<JSX.VegaTooltip & Omit<import("react").HTMLAttributes<HTMLVegaTooltipElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTooltipElement>>;
+export declare const VegaTooltipContentBox: import("react").ForwardRefExoticComponent<JSX.VegaTooltipContentBox & Omit<import("react").HTMLAttributes<HTMLVegaTooltipContentBoxElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaTooltipContentBoxElement>>;
+export declare const VegaVirtualScroll: import("react").ForwardRefExoticComponent<JSX.VegaVirtualScroll & Omit<import("react").HTMLAttributes<HTMLVegaVirtualScrollElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLVegaVirtualScrollElement>>;

package/dist/components.js

@@ -0,0 +1,116 @@
+/* eslint-disable */
+/* tslint:disable */
+/* auto-generated react proxies */
+import { createReactComponent } from './react-component-lib';
+import { defineCustomElements } from '@heartlandone/vega-sandbox-pr-2081-87a135a2ff0e4c723a3194f140abab0e3106a715/loader';
+import { VegaEnvManager, FrameworkEnum } from '@heartlandone/vega-sandbox-pr-2081-87a135a2ff0e4c723a3194f140abab0e3106a715';
+VegaEnvManager.setVegaFramework(FrameworkEnum.React);
+defineCustomElements();
+export const VegaAccordion = /*@__PURE__*/ createReactComponent('vega-accordion');
+export const VegaAppFooter = /*@__PURE__*/ createReactComponent('vega-app-footer');
+export const VegaAppHeaderButton = /*@__PURE__*/ createReactComponent('vega-app-header-button');
+export const VegaBackdrop = /*@__PURE__*/ createReactComponent('vega-backdrop');
+export const VegaBanner = /*@__PURE__*/ createReactComponent('vega-banner');
+export const VegaBarChart = /*@__PURE__*/ createReactComponent('vega-bar-chart');
+export const VegaBox = /*@__PURE__*/ createReactComponent('vega-box');
+export const VegaBrandLogo = /*@__PURE__*/ createReactComponent('vega-brand-logo');
+export const VegaBreadcrumb = /*@__PURE__*/ createReactComponent('vega-breadcrumb');
+export const VegaButton = /*@__PURE__*/ createReactComponent('vega-button');
+export const VegaButtonCircle = /*@__PURE__*/ createReactComponent('vega-button-circle');
+export const VegaButtonGroup = /*@__PURE__*/ createReactComponent('vega-button-group');
+export const VegaButtonGroupItem = /*@__PURE__*/ createReactComponent('vega-button-group-item');
+export const VegaButtonLink = /*@__PURE__*/ createReactComponent('vega-button-link');
+export const VegaCalendar = /*@__PURE__*/ createReactComponent('vega-calendar');
+export const VegaCalendarEvent = /*@__PURE__*/ createReactComponent('vega-calendar-event');
+export const VegaCalendarEventSlot = /*@__PURE__*/ createReactComponent('vega-calendar-event-slot');
+export const VegaCard = /*@__PURE__*/ createReactComponent('vega-card');
+export const VegaCarousel = /*@__PURE__*/ createReactComponent('vega-carousel');
+export const VegaCheckbox = /*@__PURE__*/ createReactComponent('vega-checkbox');
+export const VegaCheckboxGroup = /*@__PURE__*/ createReactComponent('vega-checkbox-group');
+export const VegaChip = /*@__PURE__*/ createReactComponent('vega-chip');
+export const VegaCodeBlock = /*@__PURE__*/ createReactComponent('vega-code-block');
+export const VegaColorPicker = /*@__PURE__*/ createReactComponent('vega-color-picker');
+export const VegaComboBox = /*@__PURE__*/ createReactComponent('vega-combo-box');
+export const VegaCounterBadge = /*@__PURE__*/ createReactComponent('vega-counter-badge');
+export const VegaDatePicker = /*@__PURE__*/ createReactComponent('vega-date-picker');
+export const VegaDatePickerCalendar = /*@__PURE__*/ createReactComponent('vega-date-picker-calendar');
+export const VegaDialog = /*@__PURE__*/ createReactComponent('vega-dialog');
+export const VegaDivider = /*@__PURE__*/ createReactComponent('vega-divider');
+export const VegaDropdown = /*@__PURE__*/ createReactComponent('vega-dropdown');
+export const VegaDropdownContentBox = /*@__PURE__*/ createReactComponent('vega-dropdown-content-box');
+export const VegaDropdownGroup = /*@__PURE__*/ createReactComponent('vega-dropdown-group');
+export const VegaDropdownItem = /*@__PURE__*/ createReactComponent('vega-dropdown-item');
+export const VegaFieldError = /*@__PURE__*/ createReactComponent('vega-field-error');
+export const VegaFieldLabel = /*@__PURE__*/ createReactComponent('vega-field-label');
+export const VegaFileUploader = /*@__PURE__*/ createReactComponent('vega-file-uploader');
+export const VegaFlagIcon = /*@__PURE__*/ createReactComponent('vega-flag-icon');
+export const VegaFlex = /*@__PURE__*/ createReactComponent('vega-flex');
+export const VegaFont = /*@__PURE__*/ createReactComponent('vega-font');
+export const VegaForm = /*@__PURE__*/ createReactComponent('vega-form');
+export const VegaGrid = /*@__PURE__*/ createReactComponent('vega-grid');
+export const VegaHint = /*@__PURE__*/ createReactComponent('vega-hint');
+export const VegaIcon = /*@__PURE__*/ createReactComponent('vega-icon');
+export const VegaImageUploader = /*@__PURE__*/ createReactComponent('vega-image-uploader');
+export const VegaInput = /*@__PURE__*/ createReactComponent('vega-input');
+export const VegaInputCreditCard = /*@__PURE__*/ createReactComponent('vega-input-credit-card');
+export const VegaInputNumeric = /*@__PURE__*/ createReactComponent('vega-input-numeric');
+export const VegaInputPhoneNumber = /*@__PURE__*/ createReactComponent('vega-input-phone-number');
+export const VegaInputRange = /*@__PURE__*/ createReactComponent('vega-input-range');
+export const VegaInputSelect = /*@__PURE__*/ createReactComponent('vega-input-select');
+export const VegaItemToggle = /*@__PURE__*/ createReactComponent('vega-item-toggle');
+export const VegaLeftNav = /*@__PURE__*/ createReactComponent('vega-left-nav');
+export const VegaLeftNavGroup = /*@__PURE__*/ createReactComponent('vega-left-nav-group');
+export const VegaLeftNavLink = /*@__PURE__*/ createReactComponent('vega-left-nav-link');
+export const VegaLeftNavSection = /*@__PURE__*/ createReactComponent('vega-left-nav-section');
+export const VegaLineChart = /*@__PURE__*/ createReactComponent('vega-line-chart');
+export const VegaLoaderWrapper = /*@__PURE__*/ createReactComponent('vega-loader-wrapper');
+export const VegaLoadingIndicator = /*@__PURE__*/ createReactComponent('vega-loading-indicator');
+export const VegaModal = /*@__PURE__*/ createReactComponent('vega-modal');
+export const VegaNavCard = /*@__PURE__*/ createReactComponent('vega-nav-card');
+export const VegaPageNotification = /*@__PURE__*/ createReactComponent('vega-page-notification');
+export const VegaPageNotificationList = /*@__PURE__*/ createReactComponent('vega-page-notification-list');
+export const VegaPagination = /*@__PURE__*/ createReactComponent('vega-pagination');
+export const VegaPaginationPageSelectorMobile = /*@__PURE__*/ createReactComponent('vega-pagination-page-selector-mobile');
+export const VegaPaginationPageSizeSelectorMobile = /*@__PURE__*/ createReactComponent('vega-pagination-page-size-selector-mobile');
+export const VegaPieChart = /*@__PURE__*/ createReactComponent('vega-pie-chart');
+export const VegaPopover = /*@__PURE__*/ createReactComponent('vega-popover');
+export const VegaPopoverContentBox = /*@__PURE__*/ createReactComponent('vega-popover-content-box');
+export const VegaProgressTracker = /*@__PURE__*/ createReactComponent('vega-progress-tracker');
+export const VegaRadio = /*@__PURE__*/ createReactComponent('vega-radio');
+export const VegaRadioGroup = /*@__PURE__*/ createReactComponent('vega-radio-group');
+export const VegaRichTextContent = /*@__PURE__*/ createReactComponent('vega-rich-text-content');
+export const VegaRichTextEditor = /*@__PURE__*/ createReactComponent('vega-rich-text-editor');
+export const VegaRichTextEditorToolbarButton = /*@__PURE__*/ createReactComponent('vega-rich-text-editor-toolbar-button');
+export const VegaRichTextImageEditor = /*@__PURE__*/ createReactComponent('vega-rich-text-image-editor');
+export const VegaRichTextLinkEditor = /*@__PURE__*/ createReactComponent('vega-rich-text-link-editor');
+export const VegaSectionTitle = /*@__PURE__*/ createReactComponent('vega-section-title');
+export const VegaSegmentControl = /*@__PURE__*/ createReactComponent('vega-segment-control');
+export const VegaSelectionChip = /*@__PURE__*/ createReactComponent('vega-selection-chip');
+export const VegaSelectionChipGroup = /*@__PURE__*/ createReactComponent('vega-selection-chip-group');
+export const VegaSelectionTile = /*@__PURE__*/ createReactComponent('vega-selection-tile');
+export const VegaSelectionTileGroup = /*@__PURE__*/ createReactComponent('vega-selection-tile-group');
+export const VegaSidenav = /*@__PURE__*/ createReactComponent('vega-sidenav');
+export const VegaSidenavGroup = /*@__PURE__*/ createReactComponent('vega-sidenav-group');
+export const VegaSidenavLink = /*@__PURE__*/ createReactComponent('vega-sidenav-link');
+export const VegaSignatureCapture = /*@__PURE__*/ createReactComponent('vega-signature-capture');
+export const VegaSkeleton = /*@__PURE__*/ createReactComponent('vega-skeleton');
+export const VegaSlotContainer = /*@__PURE__*/ createReactComponent('vega-slot-container');
+export const VegaStepper = /*@__PURE__*/ createReactComponent('vega-stepper');
+export const VegaTabGroup = /*@__PURE__*/ createReactComponent('vega-tab-group');
+export const VegaTabGroupPanel = /*@__PURE__*/ createReactComponent('vega-tab-group-panel');
+export const VegaTable = /*@__PURE__*/ createReactComponent('vega-table');
+export const VegaTableBody = /*@__PURE__*/ createReactComponent('vega-table-body');
+export const VegaTableCell = /*@__PURE__*/ createReactComponent('vega-table-cell');
+export const VegaTableExpandRow = /*@__PURE__*/ createReactComponent('vega-table-expand-row');
+export const VegaTableHead = /*@__PURE__*/ createReactComponent('vega-table-head');
+export const VegaTableHeadCell = /*@__PURE__*/ createReactComponent('vega-table-head-cell');
+export const VegaTableHeadRow = /*@__PURE__*/ createReactComponent('vega-table-head-row');
+export const VegaTableRow = /*@__PURE__*/ createReactComponent('vega-table-row');
+export const VegaText = /*@__PURE__*/ createReactComponent('vega-text');
+export const VegaTextarea = /*@__PURE__*/ createReactComponent('vega-textarea');
+export const VegaTimePicker = /*@__PURE__*/ createReactComponent('vega-time-picker');
+export const VegaTimePickerDropdown = /*@__PURE__*/ createReactComponent('vega-time-picker-dropdown');
+export const VegaToggleSwitch = /*@__PURE__*/ createReactComponent('vega-toggle-switch');
+export const VegaTooltip = /*@__PURE__*/ createReactComponent('vega-tooltip');
+export const VegaTooltipContentBox = /*@__PURE__*/ createReactComponent('vega-tooltip-content-box');
+export const VegaVirtualScroll = /*@__PURE__*/ createReactComponent('vega-virtual-scroll');

package/dist/global.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    type VegaReactComponentWithNativeEvent<T extends unknown, P extends unknown, V extends keyof T & keyof P> = Omit<T, V> & Omit<P, V> & {
+        [Property in V]?: T[Property] | P[Property];
+    };
+}
+export {};

package/dist/global.js

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

package/dist/hooks/use-vega-ref.d.ts

@@ -0,0 +1,16 @@
+export declare type VegaRef<T> = {
+    current: T;
+};
+/**
+ * useVegaRef returns a callback that can be used to store a reference to a DOM node.
+ * It will be overridden to type {@link VegaRef} which value is stored by the callback
+ *
+ * Note: use `useVegaRef` instead `useRef` to store the reference of the Vega components when using `FeatureFlag.enable("VEGA_REACT.PREVENT_SSR");` to disable the SSR
+ *
+ * See more info here: https://medium.com/@teh_builder/ref-objects-inside-useeffect-hooks-eb7c15198780
+ * Link issue: https://gethired.atlassian.net/browse/VD-1297
+ *
+ * @param {() => void} callback - The `callback` parameter is a function that will be called when the `vegaRef` is available.
+ * @returns {VegaRef} a callback function of type `VegaRef<T>`.
+ */
+export declare function useVegaRef<T>(callback?: (ref: T) => void): VegaRef<T>;

package/dist/hooks/use-vega-ref.js

@@ -0,0 +1,28 @@
+import { useCallback, useEffect, useState } from "react";
+/**
+ * useVegaRef returns a callback that can be used to store a reference to a DOM node.
+ * It will be overridden to type {@link VegaRef} which value is stored by the callback
+ *
+ * Note: use `useVegaRef` instead `useRef` to store the reference of the Vega components when using `FeatureFlag.enable("VEGA_REACT.PREVENT_SSR");` to disable the SSR
+ *
+ * See more info here: https://medium.com/@teh_builder/ref-objects-inside-useeffect-hooks-eb7c15198780
+ * Link issue: https://gethired.atlassian.net/browse/VD-1297
+ *
+ * @param {() => void} callback - The `callback` parameter is a function that will be called when the `vegaRef` is available.
+ * @returns {VegaRef} a callback function of type `VegaRef<T>`.
+ */
+export function useVegaRef(callback) {
+    const [refState, setRefState] = useState(undefined);
+    const refCallback = useCallback((node) => {
+        setRefState(node);
+    }, []);
+    refCallback.current = refState;
+    if (callback) {
+        useEffect(() => {
+            if (refState) {
+                callback(refState);
+            }
+        }, [refState]);
+    }
+    return refCallback;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./components";
+export * from "./hooks/use-vega-ref";
+export * from "./global";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./components";
+export * from "./hooks/use-vega-ref";
+export * from "./global";

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<PropType & Omit<React.HTMLAttributes<ElementType>, "style"> & import("./interfaces").StyleReactProps> & React.RefAttributes<ElementType>>;
+export {};

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

@@ -0,0 +1,85 @@
+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';
+import { FeatureFlag } from '@heartlandone/vega-sandbox-pr-2081-87a135a2ff0e4c723a3194f140abab0e3106a715';
+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;
+            };
+            /**
+             * While VEGA components use some keyword like `widnow` which only for browser environment, the SSR will not work as expect.
+             * To skip compare for SSR and CSR in Hydation we use same temporary dom. that will avoid Hydation failed and emit error messages.
+             * The `canRender` state is work for this, while it false we return the temporary dom for both SSR and CSR to skip Hydation check,
+             * while component did mount, we set it as true and then we can realy render the component.
+             */
+            this.state = { canRender: false };
+        }
+        componentDidMount() {
+            this.componentDidUpdate(this.props);
+            if (FeatureFlag.isEnabled('VEGA_REACT.PREVENT_SSR')) {
+                this.setState({ canRender: true });
+            }
+        }
+        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 (!FeatureFlag.isEnabled('VEGA_REACT.PREVENT_SSR') || this.state.canRender) ? createElement(tagName, newProps, children) : React.createElement(React.Fragment, null);
+        }
+        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/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/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,124 @@
+import { camelToDashCase } from './case';
+import { FeatureFlag } from '@heartlandone/vega-sandbox-pr-2081-87a135a2ff0e4c723a3194f140abab0e3106a715';
+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) || shouldAddSyncEventFallback(eventName)) {
+                    syncEvent(node, eventNameLc, newProps[name]);
+                }
+            }
+            else if (FeatureFlag.isEnabled('VEGA_REACT.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD')) {
+                attachProp(node, newProps, name);
+            }
+            else {
+                // For Next, the node have componentOnReady method in prototype of node, but no exist in React.
+                // so we attach props while componentOnReady in Next, and directly attach in React.
+                const hasOnReadyMethod = Boolean(node.componentOnReady);
+                hasOnReadyMethod ?
+                    node.componentOnReady().then(() => {
+                        attachProp(node, newProps, name);
+                    }) :
+                    attachProp(node, newProps, name);
+            }
+        });
+    }
+};
+function attachProp(node, newProps, name) {
+    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;
+};
+function shouldAddSyncEventFallback(eventName) {
+    // onChange handle not works for custom component before react 19
+    // https://github.com/facebook/react/issues/22888
+    // TODO: we should support a general method to handle those issues.
+    // https://gethired.atlassian.net/browse/VD-3818
+    if ((eventName === "Change" &&
+        FeatureFlag.isEnabled("VEGA_REACT.ENABLE_ON_CHANGE_HANDLE_UNDER_LOW_VERSION")) ||
+        (eventName === "Close" &&
+            FeatureFlag.isEnabled("VEGA_REACT.ENABLE_ON_CLOSE_HANDLE_UNDER_LOW_VERSION"))) {
+        return true;
+    }
+    return false;
+}

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<PropType & Omit<React.HTMLAttributes<ElementType>, "style"> & StyleReactProps> & 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/dist/testing/index.d.ts

@@ -0,0 +1 @@
+export * from "./utils";

package/dist/testing/index.js

@@ -0,0 +1 @@
+export * from "./utils";

package/dist/testing/utils.d.ts

@@ -0,0 +1,8 @@
+import type { RenderResult } from "@testing-library/react";
+export declare type Nullable<T> = T | undefined | null;
+export declare function waitForVegaReady(renderResult: RenderResult, delay?: number): Promise<RenderResult>;
+export declare type MockedResizeObserverController = {
+    hide: (selector: string, container?: HTMLElement) => void;
+    show: (selector: string, container?: HTMLElement) => void;
+};
+export declare function mockResizeObserver(): MockedResizeObserverController;

package/dist/testing/utils.js

@@ -0,0 +1,91 @@
+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());
+    });
+};
+import { waitForVega } from "@heartlandone/vega-sandbox-pr-2081-87a135a2ff0e4c723a3194f140abab0e3106a715";
+export function waitForVegaReady(renderResult, delay = 300) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield waitForVega();
+        /*
+           * The following code is added to load the vega component, and the attribute value is set after each component is loaded.
+           * To determine whether there is a hydrated style that cannot meet the requirements after the component is loaded,
+           * It need to set the sleep time to ensure that each attribute of the vega component is fully loaded
+           *
+           code link: ./node_modules/@heartlandone/vega-sandbox-pr-2081-87a135a2ff0e4c723a3194f140abab0e3106a715-react/dist/react-component-lib/utils/attachProps.js(line 28-33)}
+          */
+        yield sleep(delay);
+        return renderResult;
+    });
+}
+export function mockResizeObserver() {
+    const resizeObserverElementMap = new Map();
+    global.ResizeObserver = class {
+        constructor(callback) {
+            this.observedElements = [];
+            this.callback = callback;
+        }
+        observe(element) {
+            if (!this.isObserved(element)) {
+                resizeObserverElementMap.set(element, this);
+                this.observedElements.push(element);
+            }
+        }
+        unobserve(element) {
+            if (this.isObserved(element)) {
+                resizeObserverElementMap.delete(element);
+                this.observedElements = this.observedElements.filter((observedElement) => observedElement !== element);
+            }
+        }
+        disconnect() {
+            for (const element of this.observedElements) {
+                resizeObserverElementMap.delete(element);
+            }
+            this.observedElements = [];
+        }
+        show() {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.callback([{ contentRect: { height: 100 } }], this);
+        }
+        hide() {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.callback([{ contentRect: { height: 0 } }], this);
+        }
+        isObserved(element) {
+            return this.observedElements.includes(element);
+        }
+    };
+    return {
+        show: (selector, container) => {
+            (container || document)
+                .querySelectorAll(selector)
+                // eslint-disable-next-line unicorn/no-array-for-each
+                .forEach((el) => {
+                const resizeObserver = resizeObserverElementMap.get(el);
+                if (resizeObserver) {
+                    resizeObserver.show();
+                }
+            });
+        },
+        hide: (selector, container) => {
+            (container || document)
+                .querySelectorAll(selector)
+                // eslint-disable-next-line unicorn/no-array-for-each
+                .forEach((el) => {
+                const resizeObserver = resizeObserverElementMap.get(el);
+                if (resizeObserver) {
+                    resizeObserver.hide();
+                }
+            });
+        },
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@heartlandone/vega-react-sandbox-pr-2081-87a135a2ff0e4c723a3194f140abab0e3106a715",
+  "sideEffects": false,
+  "version": "2.49.1",
+  "description": "React specific wrapper for @heartlandone/vega",
+  "scripts": {
+    "stencil-postbuild": "node ./src/scripts/stencil-post-build-script.js",
+    "build": "npm run clean && npm run compile && npm run override-type",
+    "clean": "rm -rf dist",
+    "compile": "npm run tsc",
+    "tsc": "tsc -p .",
+    "rollup": "rollup -c",
+    "release": "npm run build",
+    "publish:patch": "node ../scripts/publish-version.js patch",
+    "publish:minor": "node ../scripts/publish-version.js minor",
+    "publish:major": "node ../scripts/publish-version.js major",
+    "override-type": "node ./src/scripts/override-component-native-event-type.js",
+    "pr-codesandbox-auto": "node ../scripts/pr-codesandbox-auto/change-package-name.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "publishConfig": {
+    "directory": "dist"
+  },
+  "devDependencies": {
+    "@testing-library/react": "12.1.2",
+    "@types/jest": "23.3.9",
+    "@types/node": "^15.14.9",
+    "@types/react": "^16.7.0",
+    "@types/react-dom": "^16.7.0",
+    "jest": "^23.0.0",
+    "jest-dom": "^3.0.2",
+    "np": "^3.1.0",
+    "react": "^16.7.0",
+    "react-dom": "^16.7.0",
+    "typescript": "^4.0.0"
+  },
+  "dependencies": {
+    "@heartlandone/vega-sandbox-pr-2081-87a135a2ff0e4c723a3194f140abab0e3106a715": "latest"
+  },
+  "peerDependencies": {
+    "react": ">=16.7.0",
+    "react-dom": ">=16.7.0"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "setupTestFrameworkScriptFile": "<rootDir>/jest.setup.js",
+    "testPathIgnorePatterns": [
+      "node_modules",
+      "dist"
+    ]
+  }
+}