@esri/calcite-components 1.0.0-beta.95 → 1.0.0-beta.97

package/dist/types/preact.d.ts

@@ -145,9 +145,10 @@ declare module "preact/src/jsx" {
 
       "calcite-flow": JSX.CalciteFlow & JSXInternal.HTMLAttributes<HTMLCalciteFlowElement>
 
-      "calcite-flow-item": Omit<JSX.CalciteFlowItem, "onCalciteFlowItemBack" | "onCalciteFlowItemBackClick" | "onCalciteFlowItemClose"> & JSXInternal.HTMLAttributes<HTMLCalciteFlowItemElement> & {
+      "calcite-flow-item": Omit<JSX.CalciteFlowItem, "onCalciteFlowItemBack" | "onCalciteFlowItemBackClick" | "onCalciteFlowItemScroll" | "onCalciteFlowItemClose"> & JSXInternal.HTMLAttributes<HTMLCalciteFlowItemElement> & {
         "oncalciteFlowItemBack"?: (event: CustomEvent<any>) => void;
         "oncalciteFlowItemBackClick"?: (event: CustomEvent<any>) => void;
+        "oncalciteFlowItemScroll"?: (event: CustomEvent<any>) => void;
         "oncalciteFlowItemClose"?: (event: CustomEvent<any>) => void;
       }
 

package/dist/types/stencil-public-runtime.d.ts

@@ -221,7 +221,8 @@ export declare type ErrorHandler = (err: any, element?: HTMLElement) => void;
  */
 export declare const setMode: (handler: ResolutionHandler) => void;
 /**
- * getMode
+ * `getMode()` is used for libraries which provide multiple "modes" for styles.
+ * @param ref a reference to the node to get styles for
  */
 export declare function getMode<T = string | undefined>(ref: any): T;
 export declare function setPlatformHelpers(helpers: {
@@ -234,6 +235,8 @@ export declare function setPlatformHelpers(helpers: {
 /**
  * Get the base path to where the assets can be found. Use `setAssetPath(path)`
  * if the path needs to be customized.
+ * @param path the path to use in calculating the asset path. this value will be
+ * used in conjunction with the base asset path
  */
 export declare function getAssetPath(path: string): string;
 /**
@@ -246,18 +249,22 @@ export declare function getAssetPath(path: string): string;
  * `setAssetPath(document.currentScript.src)`, or using a bundler's replace plugin to
  * dynamically set the path at build time, such as `setAssetPath(process.env.ASSET_PATH)`.
  * But do note that this configuration depends on how your script is bundled, or lack of
- * bunding, and where your assets can be loaded from. Additionally custom bundling
+ * bundling, and where your assets can be loaded from. Additionally custom bundling
  * will have to ensure the static assets are copied to its build directory.
+ * @param path the asset path to set
  */
 export declare function setAssetPath(path: string): string;
 /**
- * getElement
+ * Retrieve a Stencil element for a given reference
+ * @param ref the ref to get the Stencil element for
  */
 export declare function getElement(ref: any): HTMLStencilElement;
 /**
  * Schedules a new render of the given instance or element even if no state changed.
  *
- * Notice `forceUpdate()` is not syncronous and might perform the DOM render in the next frame.
+ * Notice `forceUpdate()` is not synchronous and might perform the DOM render in the next frame.
+ *
+ * @param ref the node/element to force the re-render of
  */
 export declare function forceUpdate(ref: any): void;
 /**
@@ -272,6 +279,8 @@ export interface HTMLStencilElement extends HTMLElement {
  * in the best moment to perform DOM mutation without causing layout thrashing.
  *
  * For further information: https://developers.google.com/web/fundamentals/performance/rendering/avoid-large-complex-layouts-and-layout-thrashing
+ *
+ * @param task the DOM-write to schedule
  */
 export declare function writeTask(task: RafCallback): void;
 /**
@@ -279,6 +288,8 @@ export declare function writeTask(task: RafCallback): void;
  * in the best moment to perform DOM reads without causing layout thrashing.
  *
  * For further information: https://developers.google.com/web/fundamentals/performance/rendering/avoid-large-complex-layouts-and-layout-thrashing
+ *
+ * @param task the DOM-read to schedule
  */
 export declare function readTask(task: RafCallback): void;
 /**

package/dist/types/utils/config.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This module helps users provide custom configuration for component internals.
+ *
+ * @internal
+ */
+declare const config: any;
+export { config };

package/dist/types/utils/date.d.ts

@@ -54,20 +54,6 @@ export declare function prevMonth(date: Date): Date;
  * @param date
  */
 export declare function nextMonth(date: Date): Date;
-/**
- * Translate a number into a given locals numeral system
- *
- * @param num
- * @param localeData
- */
-export declare function localizeNumber(num: number, localeData: DateLocaleData): string;
-/**
- * Calculate actual number from localized string
- *
- * @param str
- * @param localeData
- */
-export declare function parseNumber(str: string, localeData: DateLocaleData): number;
 /**
  * Parse numeric units for day, month, and year from a localized string
  * month starts at 0 (can pass to date constructor)
@@ -80,12 +66,6 @@ export declare function parseDateString(str: string, localeData: DateLocaleData)
   month: number;
   year: number;
 };
-/**
- * Convert eastern arbic numerals
- *
- * @param str
- */
-export declare function replaceArabicNumerals(str?: string): string;
 declare type unitOrderSignifier = "m" | "d" | "y";
 /**
  * Based on the unitOrder string, find order of month, day, and year for locale

package/dist/types/utils/dom.d.ts

@@ -30,6 +30,16 @@ export declare function queryElementRoots<T extends Element = Element>(element:
   id?: string;
 }): T | null;
 export declare function closestElementCrossShadowBoundary<T extends Element = Element>(element: Element, selector: string): T | null;
+/**
+ * This utility helps invoke a callback as it traverses a node and its ancestors until reaching the root document.
+ *
+ * Returning early or undefined in `onVisit` will continue traversing up the DOM tree. Otherwise, traversal will halt with the returned value as the result of the function
+ *
+ * @param element
+ * @param onVisit
+ */
+export declare function walkUpAncestry<T = any>(element: Element, onVisit: (node: Node) => T): T;
+export declare function containsCrossShadowBoundary(element: Element, maybeDescendant: Element): boolean;
 export interface FocusableElement extends HTMLElement {
   setFocus?: () => Promise<void>;
 }
@@ -59,4 +69,13 @@ export declare function intersects(rect1: DOMRect, rect2: DOMRect): boolean;
  * @returns {string} The string conversion of a boolean value ("true" | "false").
  */
 export declare function toAriaBoolean(value: boolean): string;
+/**
+ * This helper returns true if the pointer event fired from the primary button of the device.
+ *
+ * See https://www.w3.org/TR/pointerevents/#the-button-property.
+ *
+ * @param event
+ * @returns {boolean}
+ */
+export declare function isPrimaryPointerButton(event: PointerEvent): boolean;
 export {};

package/dist/types/utils/floating-ui/nonChromiumPlatformUtils.d.ts

@@ -0,0 +1,16 @@
+import { Strategy } from "@floating-ui/core";
+import type { ElementRects } from "@floating-ui/dom";
+import { FloatingElement, ReferenceElement } from "@floating-ui/dom/src/types";
+declare function getElementRects(_ref: {
+  reference: ReferenceElement;
+  floating: FloatingElement;
+  strategy: Strategy;
+}): ElementRects;
+export { getClippingRect, getElementRects, getOffsetParent };
+declare function getOffsetParent(element: any): any;
+declare function getClippingRect(_ref: any): {
+  width: number;
+  height: number;
+  x: any;
+  y: any;
+};

package/dist/types/utils/floating-ui.d.ts

@@ -1,4 +1,7 @@
 import { Placement, Strategy, VirtualElement } from "@floating-ui/dom";
+/**
+ * Exported for testing purposes only
+ */
 export declare const repositionDebounceTimeout = 100;
 export declare type ReferenceElement = VirtualElement | Element;
 declare type UIType = "menu" | "tooltip" | "popover";
@@ -57,8 +60,10 @@ export interface FloatingUIComponent {
   placement: LogicalPlacement;
   /**
    * Updates the position of the component.
+   *
+   * @param delayed – (internal) when true, it will reposition the component after a delay. the default is false. This is useful for components that have multiple watched properties that schedule repositioning.
    */
-  reposition(): Promise<void>;
+  reposition(delayed?: boolean): Promise<void>;
 }
 export declare const FloatingCSS: {
   animation: string;
@@ -66,9 +71,31 @@ export declare const FloatingCSS: {
 };
 export declare function filterComputedPlacements(placements: string[], el: HTMLElement): EffectivePlacement[];
 export declare function getEffectivePlacement(floatingEl: HTMLElement, placement: LogicalPlacement): EffectivePlacement;
+/**
+ * Convenience function to manage `reposition` calls for FloatingUIComponents that use `positionFloatingUI.
+ *
+ * Note: this is not needed for components that use `calcite-popover`.
+ *
+ * @param component
+ * @param options
+ * @param options.referenceEl
+ * @param options.floatingEl
+ * @param options.overlayPositioning
+ * @param options.placement
+ * @param options.disableFlip
+ * @param options.flipPlacements
+ * @param options.offsetDistance
+ * @param options.offsetSkidding
+ * @param options.arrowEl
+ * @param options.type
+ * @param delayed
+ */
+export declare function reposition(component: FloatingUIComponent, options: Parameters<typeof positionFloatingUI>[0], delayed?: boolean): Promise<void>;
 /**
  * Positions the floating element relative to the reference element.
  *
+ * **Note:** exported for testing purposes only
+ *
  * @param root0
  * @param root0.referenceEl
  * @param root0.floatingEl
@@ -80,8 +107,9 @@ export declare function getEffectivePlacement(floatingEl: HTMLElement, placement
  * @param root0.offsetSkidding
  * @param root0.arrowEl
  * @param root0.type
+ * @param root0.includeArrow
  */
-export declare function positionFloatingUI({ referenceEl, floatingEl, overlayPositioning, placement, disableFlip, flipPlacements, offsetDistance, offsetSkidding, arrowEl, type }: {
+export declare function positionFloatingUI({ referenceEl, floatingEl, overlayPositioning, placement, disableFlip, flipPlacements, offsetDistance, offsetSkidding, includeArrow, arrowEl, type }: {
   referenceEl: ReferenceElement;
   floatingEl: HTMLElement;
   overlayPositioning: Strategy;
@@ -91,8 +119,15 @@ export declare function positionFloatingUI({ referenceEl, floatingEl, overlayPos
   offsetDistance?: number;
   offsetSkidding?: number;
   arrowEl?: HTMLElement;
+  includeArrow?: boolean;
   type: UIType;
 }): Promise<void>;
+/**
+ * Exported for testing purposes only
+ *
+ * @internal
+ */
+export declare const cleanupMap: WeakMap<FloatingUIComponent, () => void>;
 /**
  * Helper to set up floating element interactions on connectedCallback.
  *
@@ -115,4 +150,12 @@ export declare function disconnectFloatingUI(component: FloatingUIComponent, ref
  * @default 6
  */
 export declare const defaultOffsetDistance: number;
+/**
+ * This utils applies floating element styles to avoid affecting layout when closed.
+ *
+ * This should be called when the closing transition will start.
+ *
+ * @param floatingEl
+ */
+export declare function updateAfterClose(floatingEl: HTMLElement): void;
 export {};

package/dist/types/utils/locale.d.ts

@@ -1,15 +1,15 @@
-import { GlobalAttrComponent } from "./globalAttributes";
+export declare const defaultLocale = "en";
 export declare const locales: string[];
-export declare function createLocaleNumberFormatter(locale: string, numberingSystem?: string): Intl.NumberFormat;
-export declare function delocalizeNumberString(numberString: string, locale: string): string;
-export declare function getGroupSeparator(locale: string): string;
-export declare function getDecimalSeparator(locale: string): string;
-export declare function getMinusSign(locale: string): string;
-export declare function localizeNumberString(numberString: string, locale: string, displayGroupSeparator?: boolean, numberingSystem?: string): string;
+export declare const numberingSystems: readonly ["arab", "arabext", "bali", "beng", "deva", "fullwide", "gujr", "guru", "hanidec", "khmr", "knda", "laoo", "latn", "limb", "mlym", "mong", "mymr", "orya", "tamldec", "telu", "thai", "tibt"];
+export declare type NumberingSystem = typeof numberingSystems[number];
+export declare const defaultNumberingSystem: "arab" | "arabext" | "bali" | "beng" | "deva" | "fullwide" | "gujr" | "guru" | "hanidec" | "khmr" | "knda" | "laoo" | "latn" | "limb" | "mlym" | "mong" | "mymr" | "orya" | "tamldec" | "telu" | "thai" | "tibt";
+export declare const getSupportedNumberingSystem: (numberingSystem: string) => NumberingSystem;
+export declare function getSupportedLocale(locale: string): string;
 /**
  * This interface is for components that need to determine locale from the lang attribute.
  */
-export interface LangComponent extends GlobalAttrComponent {
+export interface LocalizedComponent {
+  el: HTMLElement;
   /**
    * BCP 47 language tag for desired language and country format
    *
@@ -19,11 +19,81 @@ export interface LangComponent extends GlobalAttrComponent {
    * @mdn [lang](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang)
    */
   locale?: string;
+  /**
+   * Used to store the effective locale to avoid multiple lookups.
+   *
+   * This is an internal property and should:
+   *
+   * - use the `@State` decorator
+   * - be initialized to ""
+   *
+   * Components should watch this prop to ensure messages are updated.
+   *
+   * @Watch("effectiveLocale")
+   * effectiveLocaleChange(): void {
+   *   updateMessages(this, this.effectiveLocale);
+   * }
+   */
+  effectiveLocale: string;
 }
 /**
- * This util helps resolve a component's locale.
- * It will also fall back on the deprecated `locale` if a component implemented this previously.
+ * This utility sets up internals for messages support.
+ *
+ * It needs to be called in `connectedCallback` before any logic that depends on locale
  *
  * @param component
  */
-export declare function getLocale(component: LangComponent): string;
+export declare function connectLocalized(component: LocalizedComponent): void;
+/**
+ * This is only exported for components that implemented the now deprecated `locale` prop.
+ *
+ * Do not use this utils for new components.
+ *
+ * @param component
+ */
+export declare function updateEffectiveLocale(component: LocalizedComponent): void;
+/**
+ * This utility tears down internals for messages support.
+ *
+ * It needs to be called in `disconnectedCallback`
+ *
+ * @param component
+ */
+export declare function disconnectLocalized(component: LocalizedComponent): void;
+export interface NumberStringFormatOptions extends Intl.NumberFormatOptions {
+  numberingSystem: NumberingSystem;
+  locale: string;
+}
+/**
+ * This util formats and parses numbers for localization
+ */
+declare class NumberStringFormat {
+  /**
+   * The actual group separator for the specified locale.
+   * Some white space group separators don't render correctly in the browser,
+   * so we replace them with a normal <SPACE>.
+   */
+  private _actualGroup;
+  /** the corrected group separator */
+  private _group;
+  get group(): string;
+  private _decimal;
+  get decimal(): string;
+  private _minusSign;
+  get minusSign(): string;
+  private _digits;
+  get digits(): Array<string>;
+  private _getDigitIndex;
+  private _numberFormatter;
+  get numberFormatter(): Intl.NumberFormat;
+  private _numberFormatOptions;
+  get numberFormatOptions(): NumberStringFormatOptions;
+  /**
+   * numberFormatOptions needs to be set before localize/delocalize is called to ensure the options are up to date
+   */
+  set numberFormatOptions(options: NumberStringFormatOptions);
+  delocalize: (numberString: string) => string;
+  localize: (numberString: string) => string;
+}
+export declare const numberStringFormatter: NumberStringFormat;
+export {};

package/dist/types/utils/number.d.ts

@@ -8,7 +8,8 @@ export declare class BigDecimal {
   static _divRound(dividend: bigint, divisor: bigint): bigint;
   static fromBigInt(bigint: bigint): bigint;
   toString(): string;
-  formatToParts(locale: string, numberingSystem?: string): Intl.NumberFormatPart[];
+  formatToParts(formatter: Intl.NumberFormat): Intl.NumberFormatPart[];
+  format(formatter: Intl.NumberFormat): string;
   add(num: string): bigint;
   subtract(num: string): bigint;
   multiply(num: string): bigint;
@@ -16,8 +17,5 @@ export declare class BigDecimal {
 }
 export declare function isValidNumber(numberString: string): boolean;
 export declare function parseNumberString(numberString?: string): string;
-export declare function sanitizeDecimalString(decimalString: string): string;
-export declare function sanitizeNegativeString(negativeString: string): string;
-export declare function sanitizeLeadingZeroString(zeroString: string): string;
-export declare function sanitizeNumberString(numberString: string): string;
+export declare const sanitizeNumberString: (numberString: string) => string;
 export declare function sanitizeExponentialNumberString(numberString: string, func: (s: string) => string): string;

package/dist/types/utils/observers.d.ts

@@ -1,7 +1,11 @@
+export interface ExtendedMutationObserver extends MutationObserver {
+  new: () => ExtendedMutationObserver;
+  unobserve(target: Node): void;
+}
 declare type ObserverType = "mutation" | "intersection" | "resize";
 declare type ObserverCallbackType<T extends ObserverType> = T extends "mutation" ? MutationCallback : T extends "intersection" ? IntersectionObserverCallback : T extends "resize" ? ResizeObserverCallback : never;
 declare type ObserverOptions<T extends ObserverType> = T extends "mutation" ? MutationObserverInit : T extends "intersection" ? IntersectionObserverInit : T extends "resize" ? never : never;
-declare type ObserverInstanceType<T extends ObserverType> = T extends "mutation" ? MutationObserver : T extends "intersection" ? IntersectionObserver : T extends "resize" ? ResizeObserver : never;
+declare type ObserverInstanceType<T extends ObserverType> = T extends "mutation" ? ExtendedMutationObserver : T extends "intersection" ? IntersectionObserver : T extends "resize" ? ResizeObserver : never;
 /**
  * This utility ensures observers are created only for browser contexts.
  *

package/dist/types/utils/t9n.d.ts

@@ -0,0 +1,88 @@
+import { LocalizedComponent } from "./locale";
+export declare type MessageBundle = Record<string, string>;
+export declare const componentLangToMessageBundleCache: Record<string, Promise<MessageBundle>>;
+/**
+ * This util helps preserve existing intlProp usage when they have not been replaced by overrides.
+ *
+ * @param component
+ */
+export declare function overridesFromIntlProps(component: T9nComponent): MessageBundle;
+/**
+ * This utility sets up the messages used by the component. It should be awaited in the `componentWillLoad` lifecycle hook.
+ *
+ * @param component
+ */
+export declare function setUpMessages(component: T9nComponent): Promise<void>;
+/**
+ * This utility must be set up for the component to update its default message bundle if the locale changes.
+ *
+ * It can be set up in **either** of the following ways:
+ *
+ * 1. called from `LocalizedComponent`'s `onLocaleChange` method or
+ * 2. called from a watcher configured to watch `LocalizedComponent`'s `effectiveLocale` prop
+ *
+ * @param component
+ * @param lang
+ */
+export declare function updateMessages(component: T9nComponent, lang: string): Promise<void>;
+/**
+ * This utility sets up internals for messages support.
+ *
+ * It needs to be called in `connectedCallback`
+ *
+ * **Note**: this must be called after `LocalizedComponent`'s `connectLocalized` method.
+ *
+ * @param component
+ */
+export declare function connectMessages(component: T9nComponent): void;
+/**
+ * This utility tears down internals for messages support.
+ *
+ * It needs to be called in `disconnectedCallback`
+ *
+ * @param component
+ */
+export declare function disconnectMessages(component: T9nComponent): void;
+/**
+ * This interface enables components to support built-in translation strings.
+ *
+ * **Notes**:
+ *
+ * This requires `LocalizedComponent` to be implemented.
+ * To avoid unnecessary lookups, composite components should set `lang` on internal t9n components.
+ */
+export interface T9nComponent extends LocalizedComponent {
+  el: HTMLElement;
+  /**
+   * This property holds all messages used by the component's rendering.
+   *
+   * This prop should use the `@State` decorator.
+   */
+  messages: MessageBundle;
+  /**
+   * This property holds the component's default messages.
+   *
+   * This prop should use the `@State` decorator.
+   */
+  defaultMessages: MessageBundle;
+  /**
+   * This property holds all user message overrides.
+   *
+   * This prop should use the `@Prop` decorator.
+   */
+  messageOverrides: Partial<MessageBundle>;
+  /**
+   * This private method ensures messages are kept in sync.
+   *
+   * This method should be empty and configured to watch for changes on `defaultMessages`, `messageOverrides` and any associated Intl prop.
+   *
+   * @Watch("intlMyPropA")
+   * @Watch("intlMyPropZ")
+   * @Watch("defaultMessages")
+   * @Watch("messageOverrides")
+   * onMessagesChange(): void {
+   *  \/* wired up by t9n util *\/
+   * }
+   */
+  onMessagesChange(): void;
+}

package/dist/types/utils/time.d.ts

@@ -1,3 +1,4 @@
+import { NumberingSystem } from "./locale";
 export declare type HourCycle = "12" | "24";
 export interface LocalizedTime {
   localizedHour: string;
@@ -19,11 +20,34 @@ export declare type TimePart = "hour" | "hourSuffix" | "minute" | "minuteSuffix"
 export declare const maxTenthForMinuteAndSecond = 5;
 export declare function formatTimePart(number: number): string;
 export declare function formatTimeString(value: string): string;
-export declare function getLocaleHourCycle(locale: string): HourCycle;
+export declare function getLocaleHourCycle(locale: string, numberingSystem: NumberingSystem): HourCycle;
 export declare function getMeridiem(hour: string): Meridiem;
 export declare function isValidTime(value: string): boolean;
-export declare function localizeTimePart(value: string, part: TimePart, locale: string): string;
-export declare function localizeTimeString(value: string, locale?: string, includeSeconds?: boolean): string;
-export declare function localizeTimeStringToParts(value: string, locale?: string): LocalizedTime;
-export declare function getTimeParts(value: string, locale?: string): Intl.DateTimeFormatPart[];
+interface LocalizeTimePartParameters {
+  value: string;
+  part: TimePart;
+  locale: string;
+  numberingSystem: NumberingSystem;
+}
+export declare function localizeTimePart({ value, part, locale, numberingSystem }: LocalizeTimePartParameters): string;
+interface LocalizeTimeStringParameters {
+  value: string;
+  includeSeconds?: boolean;
+  locale: string;
+  numberingSystem: NumberingSystem;
+}
+export declare function localizeTimeString({ value, locale, numberingSystem, includeSeconds }: LocalizeTimeStringParameters): string;
+interface LocalizeTimeStringToPartsParameters {
+  value: string;
+  locale: string;
+  numberingSystem: NumberingSystem;
+}
+export declare function localizeTimeStringToParts({ value, locale, numberingSystem }: LocalizeTimeStringToPartsParameters): LocalizedTime;
+interface GetTimePartsParameters {
+  value: string;
+  locale: string;
+  numberingSystem: NumberingSystem;
+}
+export declare function getTimeParts({ value, locale, numberingSystem }: GetTimePartsParameters): Intl.DateTimeFormatPart[];
 export declare function parseTimeString(value: string): Time;
+export {};

package/hydrate/index.d.ts

@@ -1,4 +1,4 @@
-// Generated by dts-bundle-generator v5.3.0
+// Generated by dts-bundle-generator v6.12.0
 
 export declare function createWindowFromHtml(templateHtml: string, uniqueId: string): any;
 export interface HydrateDocumentOptions {