@nasa-terra/components 0.0.0

package/dist/events/events.d.ts

@@ -0,0 +1,7 @@
+export type { TerraDateRangeChangeEvent } from './terra-date-range-change.js';
+export type { TerraLoadEvent } from './terra-load.js';
+export type { TerraChangeEvent } from './terra-change.js';
+export type { TerraComboboxChangeEvent } from './terra-combobox-change.js';
+export type { TerraErrorEvent } from './terra-error.js';
+export type { TerraMapEvent } from './terra-map-change.js';
+export type { TerraRemoveEvent } from './terra-remove.js';

package/dist/events/terra-change.d.ts

@@ -0,0 +1,6 @@
+export type TerraChangeEvent = CustomEvent<Record<PropertyKey, never>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'terra-change': TerraChangeEvent;
+    }
+}

package/dist/events/terra-combobox-change.d.ts

@@ -0,0 +1,7 @@
+import type { ListItem } from '../components/variable-combobox/variable-combobox.controller.js';
+export type TerraComboboxChangeEvent = CustomEvent<Partial<Exclude<ListItem, 'collectionLongName' | 'eventDetail' | 'units'>>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'terra-combobox-change': TerraComboboxChangeEvent;
+    }
+}

package/dist/events/terra-date-range-change.d.ts

@@ -0,0 +1,9 @@
+export type TerraDateRangeChangeEvent = CustomEvent<{
+    startDate: string;
+    endDate: string;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'terra-date-range-change': TerraDateRangeChangeEvent;
+    }
+}

package/dist/events/terra-error.d.ts

@@ -0,0 +1,8 @@
+export type TerraErrorEvent = CustomEvent<{
+    status?: number;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'terra-error': TerraErrorEvent;
+    }
+}

package/dist/events/terra-load.d.ts

@@ -0,0 +1,6 @@
+export type TerraLoadEvent = CustomEvent<Record<PropertyKey, never>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'terra-load': TerraLoadEvent;
+    }
+}

package/dist/events/terra-map-change.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventDetail } from '../components/map/type.js';
+export type TerraMapEvent = CustomEvent<MapEventDetail>;
+export type TerraSpatialPickerDrawDeletedEvent = CustomEvent<any>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'terra-map-change': TerraMapEvent;
+    }
+}

package/dist/events/terra-remove.d.ts

@@ -0,0 +1,6 @@
+export type TerraRemoveEvent = CustomEvent<Record<PropertyKey, never>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'terra-remove': TerraRemoveEvent;
+    }
+}

package/dist/internal/active-elements.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Use a generator so we can iterate and possibly break early.
+ * @example
+ *   // to operate like a regular array. This kinda nullifies generator benefits, but worth knowing if you need the whole array.
+ *   const allActiveElements = [...activeElements()]
+ *
+ *   // Early return
+ *   for (const activeElement of activeElements()) {
+ *     if (<cond>) {
+ *       break; // Break the loop, dont need to iterate over the whole array or store an array in memory!
+ *     }
+ *   }
+ */
+export declare function activeElements(activeElement?: Element | null): Generator<Element>;
+export declare function getDeepestActiveElement(): Element | undefined;

package/dist/internal/animate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Animates an element using keyframes. Returns a promise that resolves after the animation completes or gets canceled.
+ */
+export declare function animateTo(el: HTMLElement, keyframes: Keyframe[], options?: KeyframeAnimationOptions): Promise<unknown>;
+/** Parses a CSS duration and returns the number of milliseconds. */
+export declare function parseDuration(delay: number | string): number;
+/** Tells if the user has enabled the "reduced motion" setting in their browser or OS. */
+export declare function prefersReducedMotion(): boolean;
+/**
+ * Stops all active animations on the target element. Returns a promise that resolves after all animations are canceled.
+ */
+export declare function stopAnimations(el: HTMLElement): Promise<unknown[]>;
+/**
+ * We can't animate `height: auto`, but we can calculate the height and shim keyframes by replacing it with the
+ * element's scrollHeight before the animation.
+ */
+export declare function shimKeyframesHeightAuto(keyframes: Keyframe[], calculatedHeight: number): {
+    height: string | number | null | undefined;
+    composite?: CompositeOperationOrAuto | undefined;
+    easing?: string | undefined;
+    offset?: number | null | undefined;
+}[];

package/dist/internal/debounce.d.ts

@@ -0,0 +1 @@
+export declare const debounce: (delay: number) => <T>(_target: T, _propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/internal/default-value.d.ts

@@ -0,0 +1,2 @@
+import type { ReactiveElement } from 'lit';
+export declare const defaultValue: (propertyName?: string) => (proto: ReactiveElement, key: string) => void;

package/dist/internal/drag.d.ts

@@ -0,0 +1,15 @@
+interface DragOptions {
+    /** Callback that runs as dragging occurs. */
+    onMove: (x: number, y: number) => void;
+    /** Callback that runs when dragging stops. */
+    onStop: () => void;
+    /**
+     * When an initial event is passed, the first drag will be triggered immediately using the coordinates therein. This
+     * is useful when the drag is initiated by a mousedown/touchstart event but you want the initial "click" to activate
+     * a drag (e.g. positioning a handle initially at the click target).
+     */
+    initialEvent: PointerEvent;
+}
+/** Begins listening for dragging. */
+export declare function drag(container: HTMLElement, options?: Partial<DragOptions>): void;
+export {};

package/dist/internal/event.d.ts

@@ -0,0 +1,2 @@
+/** Waits for a specific event to be emitted from an element. Ignores events that bubble up from child elements. */
+export declare function waitForEvent(el: HTMLElement, eventName: string): Promise<void>;

package/dist/internal/form.d.ts

@@ -0,0 +1,78 @@
+import type { TerraFormControl } from '../internal/terra-element.js';
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+export declare const formCollections: WeakMap<HTMLFormElement, Set<TerraFormControl>>;
+export interface FormControlControllerOptions {
+    /** A function that returns the form containing the form control. */
+    form: (input: TerraFormControl) => HTMLFormElement | null;
+    /** A function that returns the form control's name, which will be submitted with the form data. */
+    name: (input: TerraFormControl) => string;
+    /** A function that returns the form control's current value. */
+    value: (input: TerraFormControl) => unknown | unknown[];
+    /** A function that returns the form control's default value. */
+    defaultValue: (input: TerraFormControl) => unknown | unknown[];
+    /** A function that returns the form control's current disabled state. If disabled, the value won't be submitted. */
+    disabled: (input: TerraFormControl) => boolean;
+    /**
+     * A function that maps to the form control's reportValidity() function. When the control is invalid, this will
+     * prevent submission and trigger the browser's constraint violation warning.
+     */
+    reportValidity: (input: TerraFormControl) => boolean;
+    /**
+     * A function that maps to the form control's `checkValidity()` function. When the control is invalid, this will return false.
+     *   this is helpful is you want to check validation without triggering the native browser constraint violation warning.
+     */
+    checkValidity: (input: TerraFormControl) => boolean;
+    /** A function that sets the form control's value */
+    setValue: (input: TerraFormControl, value: unknown) => void;
+    /**
+     * An array of event names to listen to. When all events in the list are emitted, the control will receive validity
+     * states such as user-valid and user-invalid.user interacted validity states. */
+    assumeInteractionOn: string[];
+}
+/** A reactive controller to allow form controls to participate in form submission, validation, etc. */
+export declare class FormControlController implements ReactiveController {
+    host: TerraFormControl & ReactiveControllerHost;
+    form?: HTMLFormElement | null;
+    options: FormControlControllerOptions;
+    constructor(host: ReactiveControllerHost & TerraFormControl, options?: Partial<FormControlControllerOptions>);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    hostUpdated(): void;
+    private attachForm;
+    private detachForm;
+    private handleFormData;
+    private handleFormSubmit;
+    private handleFormReset;
+    private handleInteraction;
+    private checkFormValidity;
+    private reportFormValidity;
+    private setUserInteracted;
+    private doAction;
+    /** Returns the associated `<form>` element, if one exists. */
+    getForm(): HTMLFormElement | null;
+    /** Resets the form, restoring all the control to their default value */
+    reset(submitter?: HTMLInputElement): void;
+    /** Submits the form, triggering validation and form data injection. */
+    submit(submitter?: HTMLInputElement): void;
+    /**
+     * Synchronously sets the form control's validity. Call this when you know the future validity but need to update
+     * the host element immediately, i.e. before Lit updates the component in the next update.
+     */
+    setValidity(isValid: boolean): void;
+    /**
+     * Updates the form control's validity based on the current value of `host.validity.valid`. Call this when anything
+     * that affects constraint validation changes so the component receives the correct validity states.
+     */
+    updateValidity(): void;
+    /**
+     * Dispatches a non-bubbling, cancelable custom event of type `terra-invalid`.
+     * If the `terra-invalid` event will be cancelled then the original `invalid`
+     * event (which may have been passed as argument) will also be cancelled.
+     * If no original `invalid` event has been passed then the `terra-invalid`
+     * event will be cancelled before being dispatched.
+     */
+    emitInvalidEvent(originalInvalidEvent?: Event): void;
+}
+export declare const validValidityState: ValidityState;
+export declare const valueMissingValidityState: ValidityState;
+export declare const customErrorValidityState: ValidityState;

package/dist/internal/indexeddb.d.ts

@@ -0,0 +1,15 @@
+import { type IDBPDatabase } from 'idb';
+export declare enum IndexedDbStores {
+    TIME_SERIES = "time-series"
+}
+/**
+ * Get the indexedDB database
+ */
+export declare function getDb(): Promise<IDBPDatabase<unknown>>;
+/**
+ * a helper for wrapping code that depends on an active database connection
+ * this function will open the database, run the callback, and then cleanly close the database
+ */
+export declare function withDb<T>(callback: (db: IDBPDatabase) => Promise<T>): Promise<T>;
+export declare function getDataByKey<T>(store: IndexedDbStores, key: string): Promise<T>;
+export declare function storeDataByKey<T>(store: IndexedDbStores, key: string, data: T): Promise<void>;

package/dist/internal/math.d.ts

@@ -0,0 +1,2 @@
+/** Ensures a number stays within a minimum and maximum value */
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/internal/modal.d.ts

@@ -0,0 +1,24 @@
+export default class Modal {
+    element: HTMLElement;
+    isExternalActivated: boolean;
+    tabDirection: 'forward' | 'backward';
+    currentFocus: HTMLElement | null;
+    previousFocus: HTMLElement | null;
+    elementsWithTabbableControls: string[];
+    constructor(element: HTMLElement);
+    /** Activates focus trapping. */
+    activate(): void;
+    /** Deactivates focus trapping. */
+    deactivate(): void;
+    /** Determines if this modal element is currently active or not. */
+    isActive(): boolean;
+    /** Activates external modal behavior and temporarily disables focus trapping. */
+    activateExternal(): void;
+    /** Deactivates external modal behavior and re-enables focus trapping. */
+    deactivateExternal(): void;
+    private checkFocus;
+    private handleFocusIn;
+    private possiblyHasTabbableChildren;
+    private handleKeyDown;
+    private handleKeyUp;
+}

package/dist/internal/offset.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns an element's offset relative to its parent. Similar to element.offsetTop and element.offsetLeft, except the
+ * parent doesn't have to be positioned relative or absolute.
+ *
+ * NOTE: This was created to work around what appears to be a bug in Chrome where a slotted element's offsetParent seems
+ * to ignore elements inside the surrounding shadow DOM: https://bugs.chromium.org/p/chromium/issues/detail?id=920069
+ */
+export declare function getOffset(element: HTMLElement, parent: HTMLElement): {
+    top: number;
+    left: number;
+};

package/dist/internal/scroll.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Prevents body scrolling. Keeps track of which elements requested a lock so multiple levels of locking are possible
+ * without premature unlocking.
+ */
+export declare function lockBodyScrolling(lockingEl: HTMLElement): void;
+/**
+ * Unlocks body scrolling. Scrolling will only be unlocked once all elements that requested a lock call this method.
+ */
+export declare function unlockBodyScrolling(lockingEl: HTMLElement): void;
+/** Scrolls an element into view of its container. If the element is already in view, nothing will happen. */
+export declare function scrollIntoView(element: HTMLElement, container: HTMLElement, direction?: 'horizontal' | 'vertical' | 'both', behavior?: 'smooth' | 'auto'): void;

package/dist/internal/scrollend-polyfill.d.ts

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

package/dist/internal/slot.d.ts

@@ -0,0 +1,23 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/** A reactive controller that determines when slots exist. */
+export declare class HasSlotController implements ReactiveController {
+    host: ReactiveControllerHost & Element;
+    slotNames: string[];
+    constructor(host: ReactiveControllerHost & Element, ...slotNames: string[]);
+    private hasDefaultSlot;
+    private hasNamedSlot;
+    test(slotName: string): boolean;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private handleSlotChange;
+}
+/**
+ * Given a slot, this function iterates over all of its assigned element and text nodes and returns the concatenated
+ * HTML as a string. This is useful because we can't use slot.innerHTML as an alternative.
+ */
+export declare function getInnerHTML(slot: HTMLSlotElement): string;
+/**
+ * Given a slot, this function iterates over all of its assigned text nodes and returns the concatenated text as a
+ * string. This is useful because we can't use slot.textContent as an alternative.
+ */
+export declare function getTextContent(slot: HTMLSlotElement | undefined | null): string;

package/dist/internal/string.d.ts

@@ -0,0 +1,2 @@
+/** Converts the first letter of a string to uppercase */
+export declare function uppercaseFirstLetter(string: string): string;

package/dist/internal/tabbable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns the first and last bounding elements that are tabbable. This is more performant than checking every single
+ * element because it short-circuits after finding the first and last ones.
+ */
+export declare function getTabbableBoundary(root: HTMLElement | ShadowRoot): {
+    start: HTMLElement;
+    end: HTMLElement;
+};
+export declare function getTabbableElements(root: HTMLElement | ShadowRoot): HTMLElement[];

package/dist/internal/terra-element.d.ts

@@ -0,0 +1,47 @@
+import { LitElement } from 'lit';
+type EventTypeRequiresDetail<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, unknown>> ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, never>> ? never : Partial<GlobalEventHandlersEventMap[T]['detail']> extends GlobalEventHandlersEventMap[T]['detail'] ? never : T : never : never;
+type EventTypeDoesNotRequireDetail<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, unknown>> ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, never>> ? T : Partial<GlobalEventHandlersEventMap[T]['detail']> extends GlobalEventHandlersEventMap[T]['detail'] ? T : never : T : T;
+type EventTypesWithRequiredDetail = {
+    [EventType in keyof GlobalEventHandlersEventMap as EventTypeRequiresDetail<EventType>]: true;
+};
+type EventTypesWithoutRequiredDetail = {
+    [EventType in keyof GlobalEventHandlersEventMap as EventTypeDoesNotRequireDetail<EventType>]: true;
+};
+type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+type SlEventInit<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, unknown>> ? GlobalEventHandlersEventMap[T] extends CustomEvent<Record<PropertyKey, never>> ? CustomEventInit<GlobalEventHandlersEventMap[T]['detail']> : Partial<GlobalEventHandlersEventMap[T]['detail']> extends GlobalEventHandlersEventMap[T]['detail'] ? CustomEventInit<GlobalEventHandlersEventMap[T]['detail']> : WithRequired<CustomEventInit<GlobalEventHandlersEventMap[T]['detail']>, 'detail'> : CustomEventInit : CustomEventInit;
+type GetCustomEventType<T> = T extends keyof GlobalEventHandlersEventMap ? GlobalEventHandlersEventMap[T] extends CustomEvent<unknown> ? GlobalEventHandlersEventMap[T] : CustomEvent<unknown> : CustomEvent<unknown>;
+export default class TerraElement extends LitElement {
+    dir: string;
+    lang: string;
+    /** Emits a custom event with more convenient defaults. */
+    emit<T extends string & keyof EventTypesWithoutRequiredDetail>(name: EventTypeDoesNotRequireDetail<T>, options?: SlEventInit<T> | undefined): GetCustomEventType<T>;
+    emit<T extends string & keyof EventTypesWithRequiredDetail>(name: EventTypeRequiresDetail<T>, options: SlEventInit<T>): GetCustomEventType<T>;
+    static version: any;
+    static define(name: string, elementConstructor?: typeof TerraElement, options?: ElementDefinitionOptions): void;
+    static dependencies: Record<string, typeof TerraElement>;
+    constructor();
+}
+export interface TerraFormControl extends TerraElement {
+    name: string;
+    value: unknown;
+    disabled?: boolean;
+    defaultValue?: unknown;
+    defaultChecked?: boolean;
+    form?: string;
+    pattern?: string;
+    min?: number | string | Date;
+    max?: number | string | Date;
+    step?: number | 'any';
+    required?: boolean;
+    minlength?: number;
+    maxlength?: number;
+    readonly validity: ValidityState;
+    readonly validationMessage: string;
+    checkValidity: () => boolean;
+    getForm: () => HTMLFormElement | null;
+    reportValidity: () => boolean;
+    setCustomValidity: (message: string) => void;
+}
+export {};

package/dist/internal/test/data-testid-helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Allows you to find a DOM element based on the value of its `data-testid` attribute.
+ * This attribute can be used to decouple identifying dom elements for testing from
+ * styling (which is typically done via class selectors) or other ids which serve
+ * different purposes.
+ * See also https://kentcdodds.com/blog/making-your-ui-tests-resilient-to-change
+ * Inspired by https://testing-library.com/docs/queries/bytestid/
+ * @param {HTMLElement} container - A parent element of the DOM element to find
+ * @param {string} testId - The value of the `data-testid` attribute of the component to find.
+ * @returns The found element or null if there was no such element
+ */
+export declare const queryByTestId: <T extends Element>(container: HTMLElement, testId: string) => T | null;

package/dist/internal/test/element-visible-overflow.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Given a parent element featuring `overflow: hidden` and a child element inside the parent, this
+ * function determines whether the child will be visible taking only the overflow of the parent into account
+ * Id does NOT check whether it is hidden or overlapped by another element
+ * It basically checks whether the bounding rects of the parent and the child overlap
+ *
+ * @param {HTMLElement} outerElement - The parent element
+ * @param {HTMLElement} innerElement - the child element
+ * @returns {Boolean} whether the two elements overlap
+ */
+export declare const isElementVisibleFromOverflow: (outerElement: Element, innerElement: Element) => boolean;

package/dist/internal/test/form-control-base-tests.d.ts

@@ -0,0 +1,7 @@
+import type { TerraFormControl } from '../terra-element.js';
+/** Runs a set of generic tests for Shoelace form controls */
+export declare function runFormControlBaseTests<T extends TerraFormControl = TerraFormControl>(tagNameOrConfig: string | {
+    tagName: string;
+    init?: (control: T) => void;
+    variantName: string;
+}): void;

package/dist/internal/test/wait-for-scrolling.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Wait until an element has stopped scrolling
+ * This considers the element to have stopped scrolling, as soon as it did not change its
+ * scroll position for 20 successive animation frames
+ * @param {HTMLElement} element - The element which is scrolled
+ * @param {numeric} timeoutInMs - A timeout in ms. If the timeout has elapsed, the promise rejects
+ * @returns A promise which resolves after the scrolling has stopped
+ */
+export declare const waitForScrollingToEnd: (element: Element, timeoutInMs?: number) => Promise<void>;

package/dist/internal/test.d.ts

@@ -0,0 +1,31 @@
+/** A testing utility that measures an element's position and clicks on it. */
+export declare function clickOnElement(
+/** The element to click */
+el: Element, 
+/** The location of the element to click */
+position?: 'top' | 'right' | 'bottom' | 'left' | 'center', 
+/** The horizontal offset to apply to the position when clicking */
+offsetX?: number, 
+/** The vertical offset to apply to the position when clicking */
+offsetY?: number): Promise<void>;
+/** A testing utility that moves the mouse onto an element. */
+export declare function moveMouseOnElement(
+/** The element to click */
+el: Element, 
+/** The location of the element to click */
+position?: 'top' | 'right' | 'bottom' | 'left' | 'center', 
+/** The horizontal offset to apply to the position when clicking */
+offsetX?: number, 
+/** The vertical offset to apply to the position when clicking */
+offsetY?: number): Promise<void>;
+/** A testing utility that drags an element with the mouse. */
+export declare function dragElement(
+/** The element to drag */
+el: Element, 
+/** The horizontal distance to drag in pixels */
+deltaX?: number, 
+/** The vertical distance to drag in pixels */
+deltaY?: number, callbacks?: {
+    afterMouseDown?: () => void | Promise<void>;
+    afterMouseMove?: () => void | Promise<void>;
+}): Promise<void>;

package/dist/internal/watch.d.ts

@@ -0,0 +1,26 @@
+import type { LitElement } from 'lit';
+type UpdateHandler = (prev?: unknown, next?: unknown) => void;
+type NonUndefined<A> = A extends undefined ? never : A;
+type UpdateHandlerFunctionKeys<T extends object> = {
+    [K in keyof T]-?: NonUndefined<T[K]> extends UpdateHandler ? K : never;
+}[keyof T];
+interface WatchOptions {
+    /**
+     * If true, will only start watching after the initial update/render
+     */
+    waitUntilFirstUpdate?: boolean;
+}
+/**
+ * Runs when observed properties change, e.g. @property or @state, but before the component updates. To wait for an
+ * update to complete after a change occurs, use `await this.updateComplete` in the handler. To start watching after the
+ * initial update/render, use `{ waitUntilFirstUpdate: true }` or `this.hasUpdated` in the handler.
+ *
+ * Usage:
+ *
+ * @watch('propName')
+ * handlePropChange(oldValue, newValue) {
+ *   ...
+ * }
+ */
+export declare function watch(propertyName: string | string[], options?: WatchOptions): <ElemClass extends LitElement>(proto: ElemClass, decoratedFnName: UpdateHandlerFunctionKeys<ElemClass>) => void;
+export {};

package/dist/react/button/index.d.ts

@@ -0,0 +1,20 @@
+import Component from '../../components/button/button.component.js';
+/**
+ * @summary Buttons represent actions that are available to the user.
+ * @documentation https://shoelace.style/components/button
+ * @status stable
+ * @since 2.0
+ *
+ * @slot - The button's label.
+ * @slot prefix - A presentational prefix icon or similar element.
+ * @slot suffix - A presentational suffix icon or similar element.
+ *
+ * @csspart base - The component's base wrapper.
+ * @csspart prefix - The container that wraps the prefix.
+ * @csspart label - The button's label.
+ * @csspart suffix - The container that wraps the suffix.
+ * @csspart caret - The button's caret icon, an `<sl-icon>` element.
+ * @csspart spinner - The spinner that shows when the button is in the loading state.
+ */
+declare const reactWrapper: import("@lit/react").ReactWebComponent<Component, {}>;
+export default reactWrapper;

package/dist/react/button/index.js

@@ -0,0 +1,12 @@
+import {
+  button_default
+} from "../../chunks/chunk.A2U7NITY.js";
+import "../../chunks/chunk.OSC7AN4C.js";
+import "../../chunks/chunk.NYBJ252W.js";
+import "../../chunks/chunk.SHS42OAD.js";
+import "../../chunks/chunk.ZK7QVWBI.js";
+import "../../chunks/chunk.PJXIJK2G.js";
+import "../../chunks/chunk.RYPAZDXE.js";
+export {
+  button_default as default
+};

package/dist/react/chip/index.d.ts

@@ -0,0 +1,11 @@
+import Component from '../../components/chip/chip.component.js';
+/**
+ * @summary Used for contacts and tags
+ * @documentation https://disc.gsfc.nasa.gov/components/chip
+ * @status stable
+ * @since 1.0
+ *
+ * @slot - The chip's label.
+ */
+declare const reactWrapper: import("@lit/react").ReactWebComponent<Component, {}>;
+export default reactWrapper;

package/dist/react/chip/index.js

@@ -0,0 +1,10 @@
+import {
+  chip_default
+} from "../../chunks/chunk.WNRL2JWN.js";
+import "../../chunks/chunk.WGFD2LHA.js";
+import "../../chunks/chunk.N2DS7NLI.js";
+import "../../chunks/chunk.PJXIJK2G.js";
+import "../../chunks/chunk.RYPAZDXE.js";
+export {
+  chip_default as default
+};

package/dist/react/combobox/index.d.ts

@@ -0,0 +1,18 @@
+import Component from '../../components/combobox/combobox.component.js';
+/**
+ * @summary Fuzzy-search for combobox with list autocomplete.
+ * @documentation https://disc.gsfc.nasa.gov/components/combobox
+ * @status experimental
+ * @since 1.0
+ *
+ * @csspart base - A `search` element, the component's base.
+ * @csspart combobox - An `input` element used for searching.
+ * @csspart button - A `button` used for toggling the listbox's visibility.
+ * @csspart listbox - A `ul` that holds the clickable options.
+ *
+ * @cssproperty --host-height - The height of the host element.
+ * @cssproperty --help-height - The height of the search help element.
+ * @cssproperty --label-height - The height of the input's label element.
+ */
+declare const reactWrapper: import("@lit/react").ReactWebComponent<Component, {}>;
+export default reactWrapper;

package/dist/react/combobox/index.js

@@ -0,0 +1,13 @@
+import {
+  combobox_default
+} from "../../chunks/chunk.VIV3TUJX.js";
+import "../../chunks/chunk.I7ZPL3IO.js";
+import "../../chunks/chunk.LMGJJIIS.js";
+import "../../chunks/chunk.UVHPNM6M.js";
+import "../../chunks/chunk.ZK7QVWBI.js";
+import "../../chunks/chunk.PJXIJK2G.js";
+import "../../chunks/chunk.JFU3ZCDL.js";
+import "../../chunks/chunk.RYPAZDXE.js";
+export {
+  combobox_default as default
+};

package/dist/react/date-range-slider/index.d.ts

@@ -0,0 +1,16 @@
+import Component from '../../components/date-range-slider/date-range-slider.component.js';
+/**
+ * @summary Short summary of the component's intended use.
+ * @documentation https://disc.gsfc.nasa.gov/components/date-range-slider
+ * @status experimental
+ * @since 1.0
+ *
+ * @slot - The default slot.
+ * @slot example - An example slot.
+ *
+ * @csspart base - The component's base wrapper.
+ *
+ * @cssproperty --example - An example CSS custom property.
+ */
+declare const reactWrapper: import("@lit/react").ReactWebComponent<Component, {}>;
+export default reactWrapper;

package/dist/react/date-range-slider/index.js

@@ -0,0 +1,13 @@
+import {
+  date_range_slider_default
+} from "../../chunks/chunk.TCOEMJRS.js";
+import "../../chunks/chunk.KRXFJQUH.js";
+import "../../chunks/chunk.OIDMX5LU.js";
+import "../../chunks/chunk.OU4UPMYR.js";
+import "../../chunks/chunk.KW4TJM4C.js";
+import "../../chunks/chunk.ZK7QVWBI.js";
+import "../../chunks/chunk.PJXIJK2G.js";
+import "../../chunks/chunk.RYPAZDXE.js";
+export {
+  date_range_slider_default as default
+};

package/dist/react/icon/index.d.ts

@@ -0,0 +1,22 @@
+import Component from '../../components/icon/icon.component.js';
+import { type EventName } from '@lit/react';
+import type { TerraLoadEvent } from '../../events/events.js';
+import type { TerraErrorEvent } from '../../events/events.js';
+export type { TerraLoadEvent } from '../../events/events.js';
+export type { TerraErrorEvent } from '../../events/events.js';
+/**
+ * @summary Icons are symbols that can be used to represent various options within an application.
+ * @documentation https://disc.gsfc.nasa.gov/components/icon
+ * @status experimental
+ * @since 1.0
+ *
+ * @event terra-load - Emitted when the icon has loaded.
+ * @event terra-error - Emitted when the icon fails to load due to an error.
+ *
+ * @csspart svg - The internal SVG element.
+ */
+declare const reactWrapper: import("@lit/react").ReactWebComponent<Component, {
+    onTerraLoad: EventName<TerraLoadEvent>;
+    onTerraError: EventName<TerraErrorEvent>;
+}>;
+export default reactWrapper;