@arcgis/instant-apps-components-react 4.34.0-next.9 → 4.34.0-next.91

package/README.md

@@ -1,43 +1,41 @@
 # Instant Apps Components React
 
-A set of React components that wrap [Instant Apps Components](https://github.com/Esri/instant-apps-components).
+A set of React components that wrap [Instant Apps Components](https://npmjs.com/package/@arcgis/instant-apps-components).
 
 ## Installation
 
 ```sh
-npm install --save @esri/instant-apps-components-react
+npm install --save @arcgis/instant-apps-components-react
 ```
 
-This package includes the compatible version of the main component library as a dependency, so no need to install `@esri/instant-apps-components` separately.
+This package includes the compatible version of the main component library as a dependency, so no need to install `@arcgis/instant-apps-components` separately.
 
 Once installed, you need to import each component you use from the standard `instant-apps-component` package's custom elements build. This will automatically define the custom elements on the window. Then import the same components from `instant-apps-components-react`.
 
 ```jsx
-import "@esri/instant-apps-components/dist/components/instant-apps-header";
-import "@esri/instant-apps-components/dist/components/instant-apps-social-share";
-import { InstantAppsHeader, InstantAppsSocialShare } from "@esri/instant-apps-components-react";
+import "@arcgis/instant-apps-components/dist/components/instant-apps-header";
+import "@arcgis/instant-apps-components/dist/components/instant-apps-social-share";
+import { InstantAppsHeader, InstantAppsSocialShare } from "@arcgis/instant-apps-components-react";
 ```
 
-## Why not just use the web components directly?
-
-Because React uses a synthetic event system, the custom events emitted from instant apps components won't work with JSX in React.
-
-If you're using TypeScript, you'll also get increased type safety for your event listeners, props, etc.
-
 ## Contributing
 
 We welcome contributions to this project. See the main [instant-apps-components CONTRIBUTING.md](https://github.com/Esri/instant-apps-components/blob/master/CONTRIBUTING.md) for an overview of contribution guidelines.
 
 ## License
 
-COPYRIGHT © 2023 Esri
+COPYRIGHT © 2025 Esri
 
 All rights reserved under the copyright laws of the United States and applicable international laws, treaties, and conventions.
 
-This material is licensed for use under the Esri Master License Agreement (MLA), and is bound by the terms of that agreement. You may redistribute and use this code without modification, provided you adhere to the terms of the MLA and include this copyright notice.
-
-See use restrictions at http://www.esri.com/legal/pdfs/mla_e204_e300/english
+This material is licensed for use under the [Esri Master License Agreement (MLA)](https://www.esri.com/content/dam/esrisites/en-us/media/legal/ma-full/ma-full.pdf), and is bound by the terms of that agreement.
+You may redistribute and use this code without modification, provided you adhere to the terms of the MLA and include this copyright notice.
 
-For additional information, contact: Environmental Systems Research Institute, Inc. Attn: Contracts and Legal Services Department 380 New York Street Redlands, California, USA 92373 USA
+For additional information, contact:
+Environmental Systems Research Institute, Inc.
+Attn: Contracts and Legal Services Department
+380 New York Street
+Redlands, California, USA 92373
+USA
 
-email: contracts@esri.com
+email: legal@esri.com

package/dist/components.d.ts

@@ -1,34 +1,137 @@
-import type { JSX } from '@arcgis/instant-apps-components';
-export declare const InstantAppsAppGuide: import("react").ForwardRefExoticComponent<JSX.InstantAppsAppGuide & Omit<import("react").HTMLAttributes<HTMLInstantAppsAppGuideElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsAppGuideElement>>;
-export declare const InstantAppsCkeditorWrapper: import("react").ForwardRefExoticComponent<JSX.InstantAppsCkeditorWrapper & Omit<import("react").HTMLAttributes<HTMLInstantAppsCkeditorWrapperElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsCkeditorWrapperElement>>;
-export declare const InstantAppsControlPanel: import("react").ForwardRefExoticComponent<JSX.InstantAppsControlPanel & Omit<import("react").HTMLAttributes<HTMLInstantAppsControlPanelElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsControlPanelElement>>;
-export declare const InstantAppsCreate: import("react").ForwardRefExoticComponent<JSX.InstantAppsCreate & Omit<import("react").HTMLAttributes<HTMLInstantAppsCreateElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsCreateElement>>;
-export declare const InstantAppsExport: import("react").ForwardRefExoticComponent<JSX.InstantAppsExport & Omit<import("react").HTMLAttributes<HTMLInstantAppsExportElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsExportElement>>;
-export declare const InstantAppsExportViews: import("react").ForwardRefExoticComponent<JSX.InstantAppsExportViews & Omit<import("react").HTMLAttributes<HTMLInstantAppsExportViewsElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsExportViewsElement>>;
-export declare const InstantAppsFilterList: import("react").ForwardRefExoticComponent<JSX.InstantAppsFilterList & Omit<import("react").HTMLAttributes<HTMLInstantAppsFilterListElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsFilterListElement>>;
-export declare const InstantAppsHeader: import("react").ForwardRefExoticComponent<JSX.InstantAppsHeader & Omit<import("react").HTMLAttributes<HTMLInstantAppsHeaderElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsHeaderElement>>;
-export declare const InstantAppsInteractiveLegend: import("react").ForwardRefExoticComponent<JSX.InstantAppsInteractiveLegend & Omit<import("react").HTMLAttributes<HTMLInstantAppsInteractiveLegendElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsInteractiveLegendElement>>;
-export declare const InstantAppsInteractiveLegendClassic: import("react").ForwardRefExoticComponent<JSX.InstantAppsInteractiveLegendClassic & Omit<import("react").HTMLAttributes<HTMLInstantAppsInteractiveLegendClassicElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsInteractiveLegendClassicElement>>;
-export declare const InstantAppsInteractiveLegendCount: import("react").ForwardRefExoticComponent<JSX.InstantAppsInteractiveLegendCount & Omit<import("react").HTMLAttributes<HTMLInstantAppsInteractiveLegendCountElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsInteractiveLegendCountElement>>;
-export declare const InstantAppsInteractiveLegendGroupLegendElement: import("react").ForwardRefExoticComponent<JSX.InstantAppsInteractiveLegendGroupLegendElement & Omit<import("react").HTMLAttributes<HTMLInstantAppsInteractiveLegendGroupLegendElementElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsInteractiveLegendGroupLegendElementElement>>;
-export declare const InstantAppsInteractiveLegendGroupLegendElementCaption: import("react").ForwardRefExoticComponent<JSX.InstantAppsInteractiveLegendGroupLegendElementCaption & Omit<import("react").HTMLAttributes<HTMLInstantAppsInteractiveLegendGroupLegendElementCaptionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsInteractiveLegendGroupLegendElementCaptionElement>>;
-export declare const InstantAppsInteractiveLegendLayerElement: import("react").ForwardRefExoticComponent<JSX.InstantAppsInteractiveLegendLayerElement & Omit<import("react").HTMLAttributes<HTMLInstantAppsInteractiveLegendLayerElementElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsInteractiveLegendLayerElementElement>>;
-export declare const InstantAppsInteractiveLegendLayerElementCaption: import("react").ForwardRefExoticComponent<JSX.InstantAppsInteractiveLegendLayerElementCaption & Omit<import("react").HTMLAttributes<HTMLInstantAppsInteractiveLegendLayerElementCaptionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsInteractiveLegendLayerElementCaptionElement>>;
-export declare const InstantAppsInteractiveLegendLegendElement: import("react").ForwardRefExoticComponent<JSX.InstantAppsInteractiveLegendLegendElement & Omit<import("react").HTMLAttributes<HTMLInstantAppsInteractiveLegendLegendElementElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsInteractiveLegendLegendElementElement>>;
-export declare const InstantAppsInteractiveLegendLegendElementCaption: import("react").ForwardRefExoticComponent<JSX.InstantAppsInteractiveLegendLegendElementCaption & Omit<import("react").HTMLAttributes<HTMLInstantAppsInteractiveLegendLegendElementCaptionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsInteractiveLegendLegendElementCaptionElement>>;
-export declare const InstantAppsInteractiveLegendRelationship: import("react").ForwardRefExoticComponent<JSX.InstantAppsInteractiveLegendRelationship & Omit<import("react").HTMLAttributes<HTMLInstantAppsInteractiveLegendRelationshipElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsInteractiveLegendRelationshipElement>>;
-export declare const InstantAppsKeyboardShortcuts: import("react").ForwardRefExoticComponent<JSX.InstantAppsKeyboardShortcuts & Omit<import("react").HTMLAttributes<HTMLInstantAppsKeyboardShortcutsElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsKeyboardShortcutsElement>>;
-export declare const InstantAppsLandingPage: import("react").ForwardRefExoticComponent<JSX.InstantAppsLandingPage & Omit<import("react").HTMLAttributes<HTMLInstantAppsLandingPageElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsLandingPageElement>>;
-export declare const InstantAppsLanguageSwitcher: import("react").ForwardRefExoticComponent<JSX.InstantAppsLanguageSwitcher & Omit<import("react").HTMLAttributes<HTMLInstantAppsLanguageSwitcherElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsLanguageSwitcherElement>>;
-export declare const InstantAppsLanguageTranslator: import("react").ForwardRefExoticComponent<JSX.InstantAppsLanguageTranslator & Omit<import("react").HTMLAttributes<HTMLInstantAppsLanguageTranslatorElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsLanguageTranslatorElement>>;
-export declare const InstantAppsLanguageTranslatorItem: import("react").ForwardRefExoticComponent<JSX.InstantAppsLanguageTranslatorItem & Omit<import("react").HTMLAttributes<HTMLInstantAppsLanguageTranslatorItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsLanguageTranslatorItemElement>>;
-export declare const InstantAppsLanguageTranslatorSearch: import("react").ForwardRefExoticComponent<JSX.InstantAppsLanguageTranslatorSearch & Omit<import("react").HTMLAttributes<HTMLInstantAppsLanguageTranslatorSearchElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsLanguageTranslatorSearchElement>>;
-export declare const InstantAppsMeasurement: import("react").ForwardRefExoticComponent<JSX.InstantAppsMeasurement & Omit<import("react").HTMLAttributes<HTMLInstantAppsMeasurementElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsMeasurementElement>>;
-export declare const InstantAppsMeasurementTool: import("react").ForwardRefExoticComponent<JSX.InstantAppsMeasurementTool & Omit<import("react").HTMLAttributes<HTMLInstantAppsMeasurementToolElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsMeasurementToolElement>>;
-export declare const InstantAppsPopover: import("react").ForwardRefExoticComponent<JSX.InstantAppsPopover & Omit<import("react").HTMLAttributes<HTMLInstantAppsPopoverElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsPopoverElement>>;
-export declare const InstantAppsPopovers: import("react").ForwardRefExoticComponent<JSX.InstantAppsPopovers & Omit<import("react").HTMLAttributes<HTMLInstantAppsPopoversElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsPopoversElement>>;
-export declare const InstantAppsScoreboard: import("react").ForwardRefExoticComponent<JSX.InstantAppsScoreboard & Omit<import("react").HTMLAttributes<HTMLInstantAppsScoreboardElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsScoreboardElement>>;
-export declare const InstantAppsSignIn: import("react").ForwardRefExoticComponent<JSX.InstantAppsSignIn & Omit<import("react").HTMLAttributes<HTMLInstantAppsSignInElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsSignInElement>>;
-export declare const InstantAppsSocialShare: import("react").ForwardRefExoticComponent<JSX.InstantAppsSocialShare & Omit<import("react").HTMLAttributes<HTMLInstantAppsSocialShareElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsSocialShareElement>>;
-export declare const InstantAppsSplash: import("react").ForwardRefExoticComponent<JSX.InstantAppsSplash & Omit<import("react").HTMLAttributes<HTMLInstantAppsSplashElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsSplashElement>>;
-export declare const InstantAppsTimeFilter: import("react").ForwardRefExoticComponent<JSX.InstantAppsTimeFilter & Omit<import("react").HTMLAttributes<HTMLInstantAppsTimeFilterElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLInstantAppsTimeFilterElement>>;
+/// <reference types="@arcgis/instant-apps-components" preserve="true" />
+import { EventName } from '@lit/react';
+export declare const InstantAppsAppGuide: import('@lit/react').ReactWebComponent<HTMLInstantAppsAppGuideElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsControlPanel: import('@lit/react').ReactWebComponent<HTMLInstantAppsControlPanelElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsCreate: import('@lit/react').ReactWebComponent<HTMLInstantAppsCreateElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsExport: import('@lit/react').ReactWebComponent<HTMLInstantAppsExportElement & {
+    class?: string;
+}, {
+    onExportOutputUpdated: EventName<HTMLInstantAppsExportElement["exportOutputUpdated"]>;
+}>;
+export declare const InstantAppsExportViews: import('@lit/react').ReactWebComponent<HTMLInstantAppsExportViewsElement & {
+    class?: string;
+}, {
+    onExportOutputUpdated: EventName<HTMLInstantAppsExportViewsElement["exportOutputUpdated"]>;
+}>;
+export declare const InstantAppsFilterList: import('@lit/react').ReactWebComponent<HTMLInstantAppsFilterListElement & {
+    class?: string;
+}, {
+    onFilterListReset: EventName<HTMLInstantAppsFilterListElement["filterListReset"]>;
+    onFilterUpdate: EventName<HTMLInstantAppsFilterListElement["filterUpdate"]>;
+}>;
+export declare const InstantAppsHeader: import('@lit/react').ReactWebComponent<HTMLInstantAppsHeaderElement & {
+    class?: string;
+}, {
+    onInfoIsOpenChanged: EventName<HTMLInstantAppsHeaderElement["infoIsOpenChanged"]>;
+}>;
+export declare const InstantAppsInteractiveLegend: import('@lit/react').ReactWebComponent<HTMLInstantAppsInteractiveLegendElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsInteractiveLegendClassic: import('@lit/react').ReactWebComponent<HTMLInstantAppsInteractiveLegendClassicElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsInteractiveLegendCount: import('@lit/react').ReactWebComponent<HTMLInstantAppsInteractiveLegendCountElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsInteractiveLegendGroupLegendElement: import('@lit/react').ReactWebComponent<HTMLInstantAppsInteractiveLegendGroupLegendElementElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsInteractiveLegendGroupLegendElementCaption: import('@lit/react').ReactWebComponent<HTMLInstantAppsInteractiveLegendGroupLegendElementCaptionElement & {
+    class?: string;
+}, {
+    onGroupLayerCaptionElementExpandUpdated: EventName<HTMLInstantAppsInteractiveLegendGroupLegendElementCaptionElement["groupLayerCaptionElementExpandUpdated"]>;
+}>;
+export declare const InstantAppsInteractiveLegendLayerElement: import('@lit/react').ReactWebComponent<HTMLInstantAppsInteractiveLegendLayerElementElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsInteractiveLegendLayerElementCaption: import('@lit/react').ReactWebComponent<HTMLInstantAppsInteractiveLegendLayerElementCaptionElement & {
+    class?: string;
+}, {
+    onLayerCaptionElementExpandUpdated: EventName<HTMLInstantAppsInteractiveLegendLayerElementCaptionElement["layerCaptionElementExpandUpdated"]>;
+}>;
+export declare const InstantAppsInteractiveLegendLegendElement: import('@lit/react').ReactWebComponent<HTMLInstantAppsInteractiveLegendLegendElementElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsInteractiveLegendLegendElementCaption: import('@lit/react').ReactWebComponent<HTMLInstantAppsInteractiveLegendLegendElementCaptionElement & {
+    class?: string;
+}, {
+    onLegendLayerExpandUpdated: EventName<HTMLInstantAppsInteractiveLegendLegendElementCaptionElement["legendLayerExpandUpdated"]>;
+    onShowAllSelected: EventName<HTMLInstantAppsInteractiveLegendLegendElementCaptionElement["showAllSelected"]>;
+}>;
+export declare const InstantAppsInteractiveLegendRelationship: import('@lit/react').ReactWebComponent<HTMLInstantAppsInteractiveLegendRelationshipElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsKeyboardShortcuts: import('@lit/react').ReactWebComponent<HTMLInstantAppsKeyboardShortcutsElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsLandingPage: import('@lit/react').ReactWebComponent<HTMLInstantAppsLandingPageElement & {
+    class?: string;
+}, {
+    onLandingPageClose: EventName<HTMLInstantAppsLandingPageElement["landingPageClose"]>;
+    onLandingPageOpen: EventName<HTMLInstantAppsLandingPageElement["landingPageOpen"]>;
+}>;
+export declare const InstantAppsLanguageSwitcher: import('@lit/react').ReactWebComponent<HTMLInstantAppsLanguageSwitcherElement & {
+    class?: string;
+}, {
+    onSelectedLanguageUpdated: EventName<HTMLInstantAppsLanguageSwitcherElement["selectedLanguageUpdated"]>;
+}>;
+export declare const InstantAppsLanguageTranslator: import('@lit/react').ReactWebComponent<HTMLInstantAppsLanguageTranslatorElement & {
+    class?: string;
+}, {
+    onTranslatorDataUpdated: EventName<HTMLInstantAppsLanguageTranslatorElement["translatorDataUpdated"]>;
+}>;
+export declare const InstantAppsCkeditorWrapper: import('@lit/react').ReactWebComponent<HTMLInstantAppsCkeditorWrapperElement & {
+    class?: string;
+}, {
+    onDataChanged: EventName<HTMLInstantAppsCkeditorWrapperElement["dataChanged"]>;
+    onIsFocused: EventName<HTMLInstantAppsCkeditorWrapperElement["isFocused"]>;
+}>;
+export declare const InstantAppsLanguageTranslatorItem: import('@lit/react').ReactWebComponent<HTMLInstantAppsLanguageTranslatorItemElement & {
+    class?: string;
+}, {
+    onTranslatorItemDataUpdated: EventName<HTMLInstantAppsLanguageTranslatorItemElement["translatorItemDataUpdated"]>;
+}>;
+export declare const InstantAppsLanguageTranslatorSearch: import('@lit/react').ReactWebComponent<HTMLInstantAppsLanguageTranslatorSearchElement & {
+    class?: string;
+}, {
+    onSuggestionSelected: EventName<HTMLInstantAppsLanguageTranslatorSearchElement["suggestionSelected"]>;
+}>;
+export declare const InstantAppsMeasurement: import('@lit/react').ReactWebComponent<HTMLInstantAppsMeasurementElement & {
+    class?: string;
+}, {
+    onMeasureActive: EventName<HTMLInstantAppsMeasurementElement["measureActive"]>;
+}>;
+export declare const InstantAppsMeasurementTool: import('@lit/react').ReactWebComponent<HTMLInstantAppsMeasurementToolElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsPopover: import('@lit/react').ReactWebComponent<HTMLInstantAppsPopoverElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsPopovers: import('@lit/react').ReactWebComponent<HTMLInstantAppsPopoversElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsScoreboard: import('@lit/react').ReactWebComponent<HTMLInstantAppsScoreboardElement & {
+    class?: string;
+}, {
+    onScoreboardItemsUpdated: EventName<HTMLInstantAppsScoreboardElement["scoreboardItemsUpdated"]>;
+}>;
+export declare const InstantAppsSignIn: import('@lit/react').ReactWebComponent<HTMLInstantAppsSignInElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsSocialShare: import('@lit/react').ReactWebComponent<HTMLInstantAppsSocialShareElement & {
+    class?: string;
+}, {}>;
+export declare const InstantAppsSplash: import('@lit/react').ReactWebComponent<HTMLInstantAppsSplashElement & {
+    class?: string;
+}, {
+    onSplashClose: EventName<HTMLInstantAppsSplashElement["splashClose"]>;
+}>;
+export declare const InstantAppsTimeFilter: import('@lit/react').ReactWebComponent<HTMLInstantAppsTimeFilterElement & {
+    class?: string;
+}, {}>;

package/dist/index.d.ts

@@ -1 +1 @@
-export * from "./components";
+export * from './components';

package/dist/index.js

@@ -1 +1,240 @@
-export * from "./components";
+import e from "react";
+import { createComponent as a } from "@lit/react";
+import { makeReactWrapperFactory as s, getReactWrapperOptions as t } from "@arcgis/lumina";
+const n = /* @__PURE__ */ s(e, a), i = /* @__PURE__ */ n(
+  t(
+    "instant-apps-app-guide",
+    {}
+  )
+), d = /* @__PURE__ */ n(
+  t(
+    "instant-apps-control-panel",
+    {}
+  )
+), c = /* @__PURE__ */ n(
+  t(
+    "instant-apps-create",
+    {}
+  )
+), l = /* @__PURE__ */ n(
+  t(
+    "instant-apps-export",
+    {
+      onExportOutputUpdated: "exportOutputUpdated"
+    }
+  )
+), g = /* @__PURE__ */ n(
+  t(
+    "instant-apps-export-views",
+    {
+      onExportOutputUpdated: "exportOutputUpdated"
+    }
+  )
+), I = /* @__PURE__ */ n(
+  t(
+    "instant-apps-filter-list",
+    {
+      onFilterListReset: "filterListReset",
+      onFilterUpdate: "filterUpdate"
+    }
+  )
+), u = /* @__PURE__ */ n(
+  t(
+    "instant-apps-header",
+    {
+      onInfoIsOpenChanged: "infoIsOpenChanged"
+    }
+  )
+), m = /* @__PURE__ */ n(
+  t(
+    "instant-apps-interactive-legend",
+    {}
+  )
+), A = /* @__PURE__ */ n(
+  t(
+    "instant-apps-interactive-legend-classic",
+    {}
+  )
+), L = /* @__PURE__ */ n(
+  t(
+    "instant-apps-interactive-legend-count",
+    {}
+  )
+), v = /* @__PURE__ */ n(
+  t(
+    "instant-apps-interactive-legend-group-legend-element",
+    {}
+  )
+), h = /* @__PURE__ */ n(
+  t(
+    "instant-apps-interactive-legend-group-legend-element-caption",
+    {
+      onGroupLayerCaptionElementExpandUpdated: "groupLayerCaptionElementExpandUpdated"
+    }
+  )
+), C = /* @__PURE__ */ n(
+  t(
+    "instant-apps-interactive-legend-layer-element",
+    {}
+  )
+), E = /* @__PURE__ */ n(
+  t(
+    "instant-apps-interactive-legend-layer-element-caption",
+    {
+      onLayerCaptionElementExpandUpdated: "layerCaptionElementExpandUpdated"
+    }
+  )
+), U = /* @__PURE__ */ n(
+  t(
+    "instant-apps-interactive-legend-legend-element",
+    {}
+  )
+), S = /* @__PURE__ */ n(
+  t(
+    "instant-apps-interactive-legend-legend-element-caption",
+    {
+      onLegendLayerExpandUpdated: "legendLayerExpandUpdated",
+      onShowAllSelected: "showAllSelected"
+    }
+  )
+), x = /* @__PURE__ */ n(
+  t(
+    "instant-apps-interactive-legend-relationship",
+    {}
+  )
+), y = /* @__PURE__ */ n(
+  t(
+    "instant-apps-keyboard-shortcuts",
+    {}
+  )
+), f = /* @__PURE__ */ n(
+  t(
+    "instant-apps-landing-page",
+    {
+      onLandingPageClose: "landingPageClose",
+      onLandingPageOpen: "landingPageOpen"
+    }
+  )
+), O = /* @__PURE__ */ n(
+  t(
+    "instant-apps-language-switcher",
+    {
+      onSelectedLanguageUpdated: "selectedLanguageUpdated"
+    }
+  )
+), P = /* @__PURE__ */ n(
+  t(
+    "instant-apps-language-translator",
+    {
+      onTranslatorDataUpdated: "translatorDataUpdated"
+    }
+  )
+), w = /* @__PURE__ */ n(
+  t(
+    "instant-apps-ckeditor-wrapper",
+    {
+      onDataChanged: "dataChanged",
+      onIsFocused: "isFocused"
+    }
+  )
+), F = /* @__PURE__ */ n(
+  t(
+    "instant-apps-language-translator-item",
+    {
+      onTranslatorItemDataUpdated: "translatorItemDataUpdated"
+    }
+  )
+), T = /* @__PURE__ */ n(
+  t(
+    "instant-apps-language-translator-search",
+    {
+      onSuggestionSelected: "suggestionSelected"
+    }
+  )
+), b = /* @__PURE__ */ n(
+  t(
+    "instant-apps-measurement",
+    {
+      onMeasureActive: "measureActive"
+    }
+  )
+), R = /* @__PURE__ */ n(
+  t(
+    "instant-apps-measurement-tool",
+    {}
+  )
+), D = /* @__PURE__ */ n(
+  t(
+    "instant-apps-popover",
+    {}
+  )
+), k = /* @__PURE__ */ n(
+  t(
+    "instant-apps-popovers",
+    {}
+  )
+), G = /* @__PURE__ */ n(
+  t(
+    "instant-apps-scoreboard",
+    {
+      onScoreboardItemsUpdated: "scoreboardItemsUpdated"
+    }
+  )
+), W = /* @__PURE__ */ n(
+  t(
+    "instant-apps-sign-in",
+    {}
+  )
+), M = /* @__PURE__ */ n(
+  t(
+    "instant-apps-social-share",
+    {}
+  )
+), H = /* @__PURE__ */ n(
+  t(
+    "instant-apps-splash",
+    {
+      onSplashClose: "splashClose"
+    }
+  )
+), K = /* @__PURE__ */ n(
+  t(
+    "instant-apps-time-filter",
+    {}
+  )
+);
+export {
+  i as InstantAppsAppGuide,
+  w as InstantAppsCkeditorWrapper,
+  d as InstantAppsControlPanel,
+  c as InstantAppsCreate,
+  l as InstantAppsExport,
+  g as InstantAppsExportViews,
+  I as InstantAppsFilterList,
+  u as InstantAppsHeader,
+  m as InstantAppsInteractiveLegend,
+  A as InstantAppsInteractiveLegendClassic,
+  L as InstantAppsInteractiveLegendCount,
+  v as InstantAppsInteractiveLegendGroupLegendElement,
+  h as InstantAppsInteractiveLegendGroupLegendElementCaption,
+  C as InstantAppsInteractiveLegendLayerElement,
+  E as InstantAppsInteractiveLegendLayerElementCaption,
+  U as InstantAppsInteractiveLegendLegendElement,
+  S as InstantAppsInteractiveLegendLegendElementCaption,
+  x as InstantAppsInteractiveLegendRelationship,
+  y as InstantAppsKeyboardShortcuts,
+  f as InstantAppsLandingPage,
+  O as InstantAppsLanguageSwitcher,
+  P as InstantAppsLanguageTranslator,
+  F as InstantAppsLanguageTranslatorItem,
+  T as InstantAppsLanguageTranslatorSearch,
+  b as InstantAppsMeasurement,
+  R as InstantAppsMeasurementTool,
+  D as InstantAppsPopover,
+  k as InstantAppsPopovers,
+  G as InstantAppsScoreboard,
+  W as InstantAppsSignIn,
+  M as InstantAppsSocialShare,
+  H as InstantAppsSplash,
+  K as InstantAppsTimeFilter
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/instant-apps-components-react",
-  "version": "4.34.0-next.9",
+  "version": "4.34.0-next.91",
   "description": "A set of React components that wrap Instant Apps components",
   "sideEffects": false,
   "type": "module",
@@ -12,11 +12,16 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@arcgis/instant-apps-components": "4.34.0-next.9",
-    "@ckeditor/ckeditor5-build-classic": "^39.0.1"
+    "@arcgis/instant-apps-components": "4.34.0-next.91",
+    "@arcgis/lumina": "4.34.0-next.91",
+    "@arcgis/map-components": "4.34.0-next.91",
+    "@ckeditor/ckeditor5-build-classic": "^39.0.1",
+    "@lit/react": "^1.0.7",
+    "lit": "^3.3.0",
+    "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@arcgis/core": ">=4.34.0-next <4.35",
+    "@arcgis/core": ">=4.34.0-next.43 <4.35",
     "react": ">=18.0.0 <19.0.0",
     "react-dom": ">=18.0.0 <19.0.0"
   }

package/dist/components.js

@@ -1,37 +0,0 @@
-/* eslint-disable */
-/* tslint:disable */
-/* auto-generated react proxies */
-import { createReactComponent } from './react-component-lib';
-export const InstantAppsAppGuide = /*@__PURE__*/ createReactComponent('instant-apps-app-guide');
-export const InstantAppsCkeditorWrapper = /*@__PURE__*/ createReactComponent('instant-apps-ckeditor-wrapper');
-export const InstantAppsControlPanel = /*@__PURE__*/ createReactComponent('instant-apps-control-panel');
-export const InstantAppsCreate = /*@__PURE__*/ createReactComponent('instant-apps-create');
-export const InstantAppsExport = /*@__PURE__*/ createReactComponent('instant-apps-export');
-export const InstantAppsExportViews = /*@__PURE__*/ createReactComponent('instant-apps-export-views');
-export const InstantAppsFilterList = /*@__PURE__*/ createReactComponent('instant-apps-filter-list');
-export const InstantAppsHeader = /*@__PURE__*/ createReactComponent('instant-apps-header');
-export const InstantAppsInteractiveLegend = /*@__PURE__*/ createReactComponent('instant-apps-interactive-legend');
-export const InstantAppsInteractiveLegendClassic = /*@__PURE__*/ createReactComponent('instant-apps-interactive-legend-classic');
-export const InstantAppsInteractiveLegendCount = /*@__PURE__*/ createReactComponent('instant-apps-interactive-legend-count');
-export const InstantAppsInteractiveLegendGroupLegendElement = /*@__PURE__*/ createReactComponent('instant-apps-interactive-legend-group-legend-element');
-export const InstantAppsInteractiveLegendGroupLegendElementCaption = /*@__PURE__*/ createReactComponent('instant-apps-interactive-legend-group-legend-element-caption');
-export const InstantAppsInteractiveLegendLayerElement = /*@__PURE__*/ createReactComponent('instant-apps-interactive-legend-layer-element');
-export const InstantAppsInteractiveLegendLayerElementCaption = /*@__PURE__*/ createReactComponent('instant-apps-interactive-legend-layer-element-caption');
-export const InstantAppsInteractiveLegendLegendElement = /*@__PURE__*/ createReactComponent('instant-apps-interactive-legend-legend-element');
-export const InstantAppsInteractiveLegendLegendElementCaption = /*@__PURE__*/ createReactComponent('instant-apps-interactive-legend-legend-element-caption');
-export const InstantAppsInteractiveLegendRelationship = /*@__PURE__*/ createReactComponent('instant-apps-interactive-legend-relationship');
-export const InstantAppsKeyboardShortcuts = /*@__PURE__*/ createReactComponent('instant-apps-keyboard-shortcuts');
-export const InstantAppsLandingPage = /*@__PURE__*/ createReactComponent('instant-apps-landing-page');
-export const InstantAppsLanguageSwitcher = /*@__PURE__*/ createReactComponent('instant-apps-language-switcher');
-export const InstantAppsLanguageTranslator = /*@__PURE__*/ createReactComponent('instant-apps-language-translator');
-export const InstantAppsLanguageTranslatorItem = /*@__PURE__*/ createReactComponent('instant-apps-language-translator-item');
-export const InstantAppsLanguageTranslatorSearch = /*@__PURE__*/ createReactComponent('instant-apps-language-translator-search');
-export const InstantAppsMeasurement = /*@__PURE__*/ createReactComponent('instant-apps-measurement');
-export const InstantAppsMeasurementTool = /*@__PURE__*/ createReactComponent('instant-apps-measurement-tool');
-export const InstantAppsPopover = /*@__PURE__*/ createReactComponent('instant-apps-popover');
-export const InstantAppsPopovers = /*@__PURE__*/ createReactComponent('instant-apps-popovers');
-export const InstantAppsScoreboard = /*@__PURE__*/ createReactComponent('instant-apps-scoreboard');
-export const InstantAppsSignIn = /*@__PURE__*/ createReactComponent('instant-apps-sign-in');
-export const InstantAppsSocialShare = /*@__PURE__*/ createReactComponent('instant-apps-social-share');
-export const InstantAppsSplash = /*@__PURE__*/ createReactComponent('instant-apps-splash');
-export const InstantAppsTimeFilter = /*@__PURE__*/ createReactComponent('instant-apps-time-filter');

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

@@ -1,10 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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 { children, forwardedRef, style, className, ref, ...cProps } = this.props;
-            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 = {
-                ...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/createOverlayComponent.d.ts

@@ -1,21 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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;
-        }
-        async componentDidUpdate(prevProps) {
-            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) {
-                await 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();
-            }
-        }
-        async present(prevProps) {
-            const { children, isOpen, onDidDismiss, onDidPresent, onWillDismiss, onWillPresent, ...cProps } = this.props;
-            const elementProps = {
-                ...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 = await controller.create({
-                ...elementProps,
-                component: this.el,
-                componentProps: {},
-            });
-            setRef(this.props.forwardedRef, this.overlay);
-            attachProps(this.overlay, elementProps, prevProps);
-            await 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, { ...props, forwardedRef: ref });
-    });
-};

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

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

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

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

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

@@ -1,29 +0,0 @@
-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

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

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

@@ -1,16 +0,0 @@
-export declare const attachProps: (node: HTMLElement, newProps: any, oldProps?: any) => void;
-export declare const getClassName: (classList: DOMTokenList, newProps: any, oldProps: any) => string;
-/**
- * Transforms a React event name to a browser event name.
- */
-export declare const transformReactEventName: (eventNameSuffix: string) => 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) | undefined;
-    };
-}, eventName: string, newEventHandler?: (e: Event) => any) => void;

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

@@ -1,107 +0,0 @@
-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(' ');
-};
-/**
- * Transforms a React event name to a browser event name.
- */
-export const transformReactEventName = (eventNameSuffix) => {
-    switch (eventNameSuffix) {
-        case 'doubleclick':
-            return 'dblclick';
-    }
-    return eventNameSuffix;
-};
-/**
- * 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' + transformReactEventName(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

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

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

@@ -1,6 +0,0 @@
-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

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

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

@@ -1,12 +0,0 @@
-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

@@ -1,10 +0,0 @@
-import React from 'react';
-import type { StyleReactProps } from '../interfaces';
-export type StencilReactExternalProps<PropType, ElementType> = PropType & Omit<React.HTMLAttributes<ElementType>, 'style'> & StyleReactProps;
-export 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

@@ -1,31 +0,0 @@
-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, { ...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';