@geoscene/map-components 4.34.9 → 5.0.20

package/dist/utils/action-utils.d.ts

@@ -1,35 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { default as ActionButton } from '@geoscene/core/support/actions/ActionButton.js';
-import { default as ActionToggle } from '@geoscene/core/support/actions/ActionToggle.js';
-import { JsxNode } from '@geoscene/lumina';
-import { GeosceneFeature } from '../components/geoscene-feature/customElement.js';
-import { nil } from '@arcgis/toolkit/type';
-export type IconName = HTMLCalciteIconElement["icon"];
-export type Action = {
-    icon?: string | undefined;
-    className?: string | undefined;
-    image?: string | undefined;
-    indicator?: boolean;
-    uid?: string;
-} & (ActionButton | ActionToggle);
-export type Actions = __geoscene.Collection<Action>;
-export type Sections = __geoscene.Collection<Actions>;
-export type VisibilityAppearance = "checkbox" | "default";
-/**
- * A convenience helper method for rendering a `calcite-action` component.
- * Commonly-changed properties such as key, title, and callback are configurable.
- *
- * @return A `calcite-action` component if the action is visible, else `null`.
- */
-export declare function renderAction(action: Action, props: Partial<HTMLCalciteActionElement>, children?: JsxNode[]): JsxNode;
-export declare function getActionIcon(action: Partial<Action>): IconName | undefined;
-export declare function getActionStyles(image: string | null): Partial<CSSStyleDeclaration>;
-export declare function substituteActionImage({ action, feature }: {
-    action: Action;
-    feature: __geoscene.Graphic | nil;
-}): string;
-export declare function getSelectedTarget(viewModel: __geoscene.PopupViewModel): __geoscene.GeometryUnion | __geoscene.Graphic | nil;
-export declare function zoomToLocation(viewModel: __geoscene.PopupViewModel, targetFeatureWidget?: HTMLGeosceneFeatureElement): Promise<void>;
-export declare function isClusterFeature(feature: __geoscene.Graphic | nil): boolean;
-export declare function zoomToClusterExtent(viewModel: __geoscene.PopupViewModel): Promise<void>;
-export declare const triggerAction: (action: __geoscene.ActionButton | __geoscene.ActionToggle, viewModel: __geoscene.PopupViewModel) => Promise<void>;

package/dist/utils/actions.d.ts

@@ -1,7 +0,0 @@
-import { default as ActionButton } from '@geoscene/core/support/actions/ActionButton.js';
-import { default as ActionToggle } from '@geoscene/core/support/actions/ActionToggle.js';
-export declare const zoomToFeature: ActionButton;
-export declare const removeSelectedFeature: ActionButton;
-export declare const zoomToClusteredFeatures: ActionButton;
-export declare const browseClusteredFeatures: ActionToggle;
-export declare const all: (ActionButton | ActionToggle)[];

package/dist/utils/async-utils.d.ts

@@ -1,86 +0,0 @@
-import { nil } from '@arcgis/toolkit/type';
-import { default as GeoSceneError } from '@geoscene/core/core/Error.js';
-export interface AbortError extends GeoSceneError {
-    name: "AbortError";
-}
-export interface AbortOptions {
-    signal?: AbortSignal | null;
-}
-export declare function createAbortError(description?: string): AbortError;
-export declare function throwIfAborted(params: AbortOptions | AbortSignal | nil, description?: string): void;
-export declare function signalFromSignalOrOptions(params: AbortOptions | AbortSignal | nil): AbortSignal | undefined;
-export declare function isAborted(params: AbortOptions | AbortSignal | nil): boolean;
-export declare function isAbortError(error: unknown): error is AbortError;
-export declare function onAbort(params: AbortOptions | AbortSignal | nil, callback: () => void): IHandle | nil;
-export interface Task<T> extends IHandle, Disposable {
-    readonly value: nil | T;
-    readonly error: unknown;
-    readonly finished: boolean;
-    readonly promise: Promise<T>;
-    abort: () => void;
-}
-type TaskFunction<T> = (signal: AbortSignal) => Promise<T>;
-type TaskOptions = AbortOptions | AbortSignal | nil;
-/**
- * Wraps an async function (or function returning a promise) in order to create an abortable task.
- * This hides the complexity of creating and managing abort controllers, etc.
- *
- * 3D: Do not use this for anything else than wrapping trivial promises/promise chains. Do use a Scheduler task
- * to perform significant work:
- *
- * ```ts
- * this._queryTask = createTask((signal) => {
- *   const data = await view.resourceController.schedule(slowTask, signal);
- *   throwIfAborted(signal);
- *   // do things with data
- * });
- * ```
- *
- * Example:
- *
- *    ```ts
- *    const task = createTask((signal) => {
- *      return promiseUtils.whenOrAbort(doSomethingAsync(), signal);
- *    });
- *
- *    // Wait for the result
- *    task.promise.then((result) => console.log(result));
- *
- *    // Or abort it when not needed anymore.
- *    task.abort();
- *    ```
- *
- * @param task
- *    The task which is to be executed and made abortable. It receives a signal which can be passed to async operations
- *    in order for them to check whether the task has been aborted.
- *
- * @param options
- *    Abort the task
- *
- * @return
- *    An object which encapsulates the state of the task.
- *
- * @ignore
- */
-export declare function createTask<T>(task: TaskFunction<T>, options?: TaskOptions): Task<T>;
-export declare function ignoreAbortErrors(promise: Promise<unknown>): Promise<unknown>;
-/**
- * Schedules a function to be called during the browser's idle periods, using `window.requestIdleCallback` if available,
- * or falling back to a `setTimeout`-based polyfill. This allows you to perform background or low-priority work without
- * impacting critical rendering or user interactions.
- *
- * @param callback - The function to execute when the browser is idle. Receives an object with `didTimeout` and `timeRemaining`.
- * @param options - Optional configuration for the idle callback, such as a timeout in milliseconds.
- * @returns A numeric handle that can be used to cancel the scheduled callback.
- */
-export declare function requestIdleCallback(callback: IdleRequestCallback, options?: IdleRequestOptions): number;
-/**
- * Cancels a previously scheduled idle callback or timeout.
- *
- * This function attempts to cancel an idle callback using `window.cancelIdleCallback` if it is available in the current
- * environment. If not, it falls back to clearing the timeout using `window.clearTimeout`.
- *
- * @param id - The identifier of the idle callback or timeout to cancel.
- */
-export declare function cancelIdleCallback(id: number): void;
-export {};

package/dist/utils/chart-utils.d.ts

@@ -1,6 +0,0 @@
-import { Root } from '@amcharts/amcharts5/index.js';
-/**
- * Returns a new `Root` instance with the locale values loaded and set.
- * @param id
- */
-export declare function createRoot(id: HTMLElement | string, locale?: string): Promise<Root>;

package/dist/utils/component-utils.d.ts

@@ -1,76 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { EventEmitter } from '@geoscene/lumina';
-import { nil } from '@arcgis/toolkit/type';
-import { GeosceneExpand } from '../components/geoscene-expand/customElement.js';
-import { GeosceneLinkChart } from '../components/geoscene-link-chart/customElement.js';
-import { GeosceneMap } from '../components/geoscene-map/customElement.js';
-import { GeoscenePlacement } from '../components/geoscene-placement/customElement.js';
-import { GeosceneScene } from '../components/geoscene-scene/customElement.js';
-export type GeosceneReferenceElement = HTMLGeosceneLinkChartElement | HTMLGeosceneMapElement | HTMLGeosceneSceneElement;
-export type GeosceneParentElement = HTMLGeosceneExpandElement | HTMLGeoscenePlacementElement | GeosceneReferenceElement;
-interface BaseComponentElement {
-    referenceElement?: GeosceneReferenceElement | string;
-    view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView | nil;
-    position?: __geoscene.UIPosition;
-}
-export interface WidgetElement extends BaseComponentElement {
-    el: HTMLElement & {
-        childElem?: HTMLElement;
-    };
-    widget: any;
-    _watchHandles: __geoscene.WatchHandle[];
-}
-/**
- * A type that represents either wrapped widget or a native map component. Used
- * in places where both need to be accepted.
- */
-export type WidgetOrMapComponent = Pick<WidgetElement, "position" | "referenceElement" | "view"> & {
-    el: HTMLElement & {
-        view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView | __geoscene.VideoView | nil;
-        parent?: GeosceneParentElement;
-        childElem?: HTMLElement & {
-            ownedBy?: HTMLElement;
-        };
-    };
-    icon?: nil | string;
-    widget?: WidgetElement["widget"];
-};
-/** @deprecated Use this.manager.onLifecycle() instead */
-export declare function addHandles(element: WidgetElement, handle: __geoscene.WatchHandle | __geoscene.WatchHandle[]): void;
-/**
- * Find applicable geoscene-map, geoscene-scene, geoscene-expand or geoscene-placement
- * for the current component and attach to it
- *
- * @remarks
- * If the view property was set by the user directly (for backwards
- * comparability with MapView/SceneView), attachToParent() will return undefined
- * as attachToParent() is looking for component parents only.
- * If the view property was provided, the developer takes over the
- * responsibility of calling view.ui.add()
- */
-export declare function attachToParent(component: WidgetOrMapComponent): GeosceneParentElement | undefined;
-/**
- * Defines a view prop on the component's el and emits geosceneReady once that
- * prop is set by attachToParent()
- *
- * @deprecated Use useWidget or useViewModel instead
- */
-export declare function defineViewProperty(component: WidgetOrMapComponent & {
-    geosceneReady: EventEmitter;
-}): void;
-export declare function isNullOrEmptyString(value: nullish | string): boolean;
-export declare function isValidInteger(value: nullish | number): boolean;
-export declare function areCamerasEqual(camera: __geoscene.Camera, camera2: __geoscene.Camera | nil): boolean;
-export declare function isNotSameViewpoint(viewpoint?: __geoscene.Viewpoint, viewpoint2?: __geoscene.Viewpoint): boolean;
-export declare function parseCenter(newValue: __geoscene.MapView["center"] | nil | number[] | string, view?: Pick<__geoscene.MapView, "center">): __geoscene.Point | undefined;
-export declare function parsePoint(currentValue: __geoscene.Point | nil, newValue: __geoscene.Point | nil | number[] | string): __geoscene.Point | undefined;
-/** @deprecated Use useWidget or useViewModel instead */
-export declare function referenceElementHelper(component: WidgetOrMapComponent, refElement: GeosceneReferenceElement | nil | string): Promise<void>;
-export declare const getRenderContainer: (component: Pick<WidgetOrMapComponent, "el">) => HTMLElement | undefined;
-/**
- * Focuses the specified element while waiting for it to be rendered.
- * 
- * Minus the `abortOptions`
- */
-export declare function setFocus(elementOrGetElement: Element | nil | (() => Element | nil)): Promise<void>;
-export {};

package/dist/utils/disconnected.d.ts

@@ -1,3 +0,0 @@
-import { WidgetElement } from './component-utils';
-/** @deprecated Use useWidget or useViewModel instead */
-export declare function onDisconnectedHelper(element: Partial<WidgetElement> & Pick<WidgetElement, "el">): void;

package/dist/utils/feature-form-utils.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { nil } from '@arcgis/toolkit/type';
-export declare const getFieldsInTitleAndDesc: (layer: {
-    formTemplate?: __geoscene.FormTemplate | nil;
-    fields?: __geoscene.Field[];
-}) => string[];

package/dist/utils/feature-utils.d.ts

@@ -1,48 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { nil } from '@arcgis/toolkit/type';
-export declare function createFieldInfoMap(fieldInfos: __geoscene.FieldInfo[], layer: __geoscene.Layer | nil): Map<string, __geoscene.FieldInfo>;
-export declare function getAllFieldInfos(popupTemplate: __geoscene.PopupTemplate | nil): __geoscene.FieldInfo[];
-export declare function getPopupTemplate(graphic: __geoscene.Graphic | nil, defaultPopupTemplateEnabled: boolean): __geoscene.PopupTemplate | nil;
-export declare function getSourceLayer(graphic: __geoscene.Graphic | nil): __geoscene.Layer | undefined;
-export declare function isRelatedField(fieldName?: string): boolean;
-export declare function shouldOpenInNewTab(url: string): boolean;
-export declare function shouldOpenInNewTab(url: undefined): undefined;
-export declare function shouldOpenInNewTab(url: string | undefined): boolean | undefined;
-export declare function getFixedFieldName(field: string, layer: __geoscene.Layer | nil): string;
-export declare function getFixedFieldNames(fields: string[], layer: __geoscene.Layer | nil): string[];
-export declare function isExpressionField(fieldName: string): boolean;
-export declare function getFieldInfo(fieldInfos: __geoscene.FieldInfo[] | nil, fieldName: nil | string): __geoscene.FieldInfo | undefined;
-export declare function isSupportedContext({ fieldInfo, graphic, }: {
-    fieldInfo?: __geoscene.FieldInfo;
-    graphic?: __geoscene.Graphic | nil;
-}): boolean;
-export declare function getFieldInfoLabel({ expressionInfos, fieldInfo, graphic, isContentFieldInfos, layer, }: {
-    expressionInfos?: __geoscene.ExpressionInfo[] | nil;
-    fieldInfo?: __geoscene.FieldInfo;
-    graphic?: __geoscene.Graphic | nil;
-    isContentFieldInfos?: boolean;
-    layer?: __geoscene.FeatureLayer | nil;
-}): nil | string;
-export declare function getFieldFormat({ fieldInfo, isContentFieldInfos, layer, }: {
-    fieldInfo?: __geoscene.FieldInfo;
-    isContentFieldInfos?: nil | boolean;
-    layer?: __geoscene.FeatureLayer | nil;
-}): __geoscene.DateTimeFieldFormat | __geoscene.NumberFieldFormat | nil;
-export declare function substituteValues({ formattedValues, template, fieldInfoMap, }: {
-    formattedValues: HashMap<number | string>;
-    template: string;
-    fieldInfoMap: Map<string, __geoscene.FieldInfo>;
-}): string;
-export declare function fixTokens(template: string, layer: __geoscene.Layer | nil): string;
-export declare function substituteFieldsInLinksAndValues({ values, globalValues, layer, text, fieldInfoMap, }: {
-    values: HashMap<number | string> | nil;
-    globalValues: HashMap<number | string>;
-    layer: __geoscene.Layer | nil;
-    text: nil | string;
-    fieldInfoMap: Map<string, __geoscene.FieldInfo>;
-}): string;
-export declare function graphicCallback<T extends nil | number | object | string>({ type, value, event, }: {
-    type: "content" | "title";
-    value: Promise<T> | T | ((event: __geoscene.PopupTemplateCreatorEvent) => T);
-    event: __geoscene.PopupTemplateCreatorEvent;
-}): Promise<T | undefined>;

package/dist/utils/geolocation-utils.d.ts

@@ -1,13 +0,0 @@
-import { default as MapView } from '@geoscene/core/views/MapView.js';
-import { default as SceneView } from '@geoscene/core/views/SceneView.js';
-import { default as Point } from '@geoscene/core/geometry/Point.js';
-import { AbortOptions } from './async-utils';
-export declare function supported(): boolean;
-export declare function getCurrentPosition(options?: PositionOptions | null): Promise<GeolocationPosition>;
-interface PositionToPointParams {
-    position: GeolocationPosition;
-    view?: MapView | SceneView | null;
-}
-export declare function positionToPoint(params: PositionToPointParams, options?: AbortOptions): Promise<Point>;
-export declare function overridePositionToPoint(value: ((params: PositionToPointParams, options?: AbortOptions) => Promise<Point>) | undefined): void;
-export {};

package/dist/utils/geometry-utils.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { default as Point } from '@geoscene/core/geometry/Point.js';
-import { nil } from '@arcgis/toolkit/type';
-export type GeometryUnion = __geoscene.Extent | __geoscene.Mesh | __geoscene.Multipoint | __geoscene.Point | __geoscene.Polygon | __geoscene.Polyline;
-export declare function getPointFromGeometry(geometry: GeometryUnion): nil | Point;

package/dist/utils/globalCss.d.ts

@@ -1,43 +0,0 @@
-export declare const globalCss: {
-    readonly anchor: "geoscene-widget__anchor";
-    readonly anchorDisabled: "geoscene-widget__anchor--disabled";
-    readonly button: "geoscene-button";
-    readonly buttonDisabled: "geoscene-button--disabled";
-    readonly buttonHalf: "geoscene-button--half";
-    readonly buttonSecondary: "geoscene-button--secondary";
-    readonly buttonSmall: "geoscene-button--small";
-    readonly buttonTertiary: "geoscene-button--tertiary";
-    readonly buttonThird: "geoscene-button--third";
-    readonly disabled: "geoscene-disabled";
-    readonly disabledElement: "geoscene-disabled-element";
-    readonly empty: "geoscene-widget__content--empty";
-    readonly emptyIllustration: "geoscene-widget__content-illustration--empty";
-    readonly heading: "geoscene-widget__heading";
-    readonly hidden: "geoscene-hidden";
-    readonly input: "geoscene-input";
-    readonly interactive: "geoscene-interactive";
-    readonly loader: "geoscene-widget__loader";
-    readonly loaderAnimation: "geoscene-widget__loader-animation";
-    readonly loaderText: "geoscene-widget__loader-text";
-    readonly menu: "geoscene-menu";
-    readonly menuHeader: "geoscene-menu__header";
-    readonly menuItem: "geoscene-menu__list-item";
-    readonly menuItemActive: "geoscene-menu__list-item--active";
-    readonly menuItemFocus: "geoscene-menu__list-item--focus";
-    readonly menuList: "geoscene-menu__list";
-    readonly noBookmarksIcon: "geoscene-widget__no-bookmark-icon";
-    readonly panel: "geoscene-widget--panel";
-    readonly panelHeightOnly: "geoscene-widget--panel-height-only";
-    readonly primaryTick: "primary-tick";
-    readonly primaryTickAmPm: "primary-tick__ampm";
-    readonly primaryTickLabel: "primary-tick__label";
-    readonly rotating: "geoscene-rotating";
-    readonly secondaryTick: "secondary-tick";
-    readonly select: "geoscene-select";
-    readonly table: "geoscene-widget__table";
-    readonly ui: "geoscene-component";
-    readonly widget: "geoscene-widget";
-    readonly widgetButton: "geoscene-widget--button";
-    readonly widgetButtonActive: "geoscene-widget--button-active";
-    readonly widgetDisabled: "geoscene-widget--disabled";
-};

package/dist/utils/highlight-utils.d.ts

@@ -1,22 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { default as Graphic } from '@geoscene/core/Graphic';
-import { default as MapView } from '@geoscene/core/views/MapView';
-import { default as SceneView } from '@geoscene/core/views/SceneView';
-import { GeosceneMap } from '../components/geoscene-map/customElement.js';
-import { GeosceneScene } from '../components/geoscene-scene/customElement.js';
-import { AbortOptions } from './async-utils';
-type ViewOrViewElement = GeosceneMap | GeosceneScene | MapView | SceneView;
-/**
- * Highlights a given feature on the provided view or view element and returns a handle to remove the highlight.
- *
- * It attempts to retrieve the layer view for the provided feature's layer, checks for an available highlight method,
- * and applies the highlight if possible. If highlighting is not supported, it returns a no-op handle.
- *
- * @param view - The view or view element where the feature should be highlighted.
- * @param feature - The feature to highlight.
- * @param options - Optional abort options to cancel the operation if needed.
- *
- * @returns A promise that resolves to a handle that can be used to remove the highlight.
- */
-export declare function highlightFeature(view: ViewOrViewElement, feature: Graphic, options?: AbortOptions): Promise<__geoscene.Handle>;
-export {};

package/dist/utils/layer-list-utils.d.ts

@@ -1,42 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { nil } from '@arcgis/toolkit/type';
-import { Sections, VisibilityAppearance, IconName } from './action-utils';
-export type LayerListLayerUnion = __geoscene.Layer | __geoscene.Sublayer | __geoscene.SubtypeGroupLayer | __geoscene.SubtypeSublayer;
-export type TableSupportedLayers = "knowledge-graph" | "map-image" | "tile";
-type VisibilityMode = "exclusive" | "independent" | "inherited";
-type SortableCollection = __geoscene.Collection<__geoscene.KMLSublayer> | __geoscene.Collection<{
-    uid?: string | null;
-}> | nil;
-export declare const minFilterItems = 10;
-export declare const minDragEnabledItems = 2;
-type StatusIcon = "beacon" | "bullet-point" | "offline" | "square";
-export declare function getVisibilityIcon({ exclusive, visible, visibilityAppearance, }: {
-    exclusive: boolean;
-    visible: boolean;
-    visibilityAppearance: VisibilityAppearance;
-}): IconName;
-export declare function getStatusIcon({ connectionStatus, publishing, }: {
-    connectionStatus?: __geoscene.StreamLayerView["connectionStatus"] | nil;
-    publishing: boolean;
-}): StatusIcon;
-export declare function areChildrenHidden(layer: LayerListLayerUnion | nil): boolean;
-export declare function findLayerListMode(layer: LayerListLayerUnion | nil): string | undefined;
-export declare function findLayerMinScale(layer: LayerListLayerUnion | nil): number | undefined;
-export declare function findLayerMaxScale(layer: LayerListLayerUnion | nil): number | undefined;
-export declare function findLayerVisibilityMode(layer: LayerListLayerUnion | nil): VisibilityMode;
-export declare function removeDestroyedListItems(items: __geoscene.Collection<__geoscene.ListItem | __geoscene.TableListListItem>): void;
-export declare function getNormalizedChildLayerProperty(layer: LayerListLayerUnion | nil): "layers" | "sublayers" | undefined;
-export declare function setFilterPredicate(listEl: HTMLCalciteListElement | nil, filterPredicate: nil | ((item: __geoscene.ListItem | __geoscene.TableListListItem) => boolean)): void;
-export declare function canSortSublayers(item: __geoscene.ListItem | nil): boolean;
-export declare function canDisplayLayer(layer: LayerListLayerUnion | nil): boolean;
-export declare function isLayerOutsideScaleRange(layer: LayerListLayerUnion | nil, currentScale: nil | number): boolean;
-export declare function sortLayersToIds(layers: nil | SortableCollection, itemIds: string[]): void;
-export declare function sortChildLayersToIds(item: __geoscene.ListItem, itemIds: string[]): void;
-export declare function getItemLayers(item: __geoscene.ListItem): __geoscene.Collection<LayerListLayerUnion> | null;
-export declare function isSublayer(layer: LayerListLayerUnion | nil): layer is __geoscene.Sublayer;
-export declare function getItem(element: HTMLElement | nil): __geoscene.ListItem | nil;
-export declare function getLayerType(element: HTMLElement | nil): nil | string;
-export declare function listItemHasChildren(item: __geoscene.ListItem | __geoscene.TableListListItem): boolean;
-export declare function getSingleAction(sections: Sections): __geoscene.ActionButton | __geoscene.ActionToggle | undefined;
-export declare function isCatalogSublayer(sublayer: __geoscene.Sublayer, type: "footprints" | "layers-in-view"): boolean;
-export {};

package/dist/utils/layer-utils.d.ts

@@ -1,4 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-export declare function isFeatureLayer(layer: unknown): layer is __geoscene.FeatureLayer;
-export declare function isFeatureServiceLayer(layer: unknown): layer is __geoscene.FeatureLayer;
-export declare function supportsFieldConfiguration(layer: unknown): layer is __geoscene.FeatureLayer;

package/dist/utils/legacyIcon.d.ts

@@ -1,100 +0,0 @@
-export declare const legacyIcon: {
-    readonly arrowDown: "geoscene-icon-arrow-down";
-    readonly arrowUp: "geoscene-icon-arrow-up";
-    readonly basemap: "geoscene-icon-basemap";
-    readonly bookmark: "geoscene-icon-bookmark";
-    readonly calendar: "geoscene-icon-calendar";
-    readonly checkMark: "geoscene-icon-check-mark";
-    readonly checkboxUnchecked: "geoscene-icon-checkbox-unchecked";
-    readonly close: "geoscene-icon-close";
-    readonly collapse: "geoscene-icon-collapse";
-    readonly defaultAction: "geoscene-icon-default-action";
-    readonly description: "geoscene-icon-description";
-    readonly directions: "geoscene-icon-directions";
-    readonly dockBottom: "geoscene-icon-dock-bottom";
-    readonly dockLeft: "geoscene-icon-dock-left";
-    readonly dockRight: "geoscene-icon-dock-right";
-    readonly down: "geoscene-icon-down";
-    readonly downArrow: "geoscene-icon-down-arrow";
-    readonly download: "geoscene-icon-download";
-    readonly dragHorizontal: "geoscene-icon-drag-horizontal";
-    readonly dragVertical: "geoscene-icon-drag-vertical";
-    readonly duplicate: "geoscene-icon-duplicate";
-    readonly edit: "geoscene-icon-edit";
-    readonly elevationProfile: "geoscene-icon-elevation-profile";
-    readonly environmentSettings: "geoscene-icon-environment-settings";
-    readonly erase: "geoscene-icon-erase";
-    readonly error: "geoscene-icon-error";
-    readonly expand: "geoscene-icon-expand";
-    readonly fontFallbackText: "geoscene-icon-font-fallback-text";
-    readonly forward: "geoscene-icon-forward";
-    readonly gear: "geoscene-icon-gear";
-    readonly handleHorizontal: "geoscene-icon-handle-horizontal";
-    readonly handleVertical: "geoscene-icon-handle-vertical";
-    readonly home: "geoscene-icon-home";
-    readonly icon: "geoscene-icon";
-    readonly launchLinkExternal: "geoscene-icon-launch-link-external";
-    readonly layerList: "geoscene-icon-layer-list";
-    readonly layers: "geoscene-icon-layers";
-    readonly left: "geoscene-icon-left";
-    readonly leftArrows: "geoscene-icon-left-arrow";
-    readonly leftTriangleArrow: "geoscene-icon-left-triangle-arrow";
-    readonly lineOfSight: "geoscene-icon-line-of-sight";
-    readonly link: "geoscene-icon-link";
-    readonly linkExternal: "geoscene-icon-link-external";
-    readonly linkHorizontal: "geoscene-icon-link-horizontal";
-    readonly loadingIndicator: "geoscene-icon-loading-indicator";
-    readonly locate: "geoscene-icon-locate";
-    readonly locateCircled: "geoscene-icon-locate-circled";
-    readonly locked: "geoscene-icon-locked";
-    readonly mapPin: "geoscene-icon-map-pin";
-    readonly maximize: "geoscene-icon-maximize";
-    readonly measure: "geoscene-icon-measure";
-    readonly measureArea: "geoscene-icon-measure-area";
-    readonly measureBuildingHeightShadow: "geoscene-icon-measure-building-height-shadow";
-    readonly measureLine: "geoscene-icon-measure-line";
-    readonly menu: "geoscene-icon-menu";
-    readonly minimize: "geoscene-icon-minimize";
-    readonly minus: "geoscene-icon-minus";
-    readonly nonVisible: "geoscene-icon-non-visible";
-    readonly northNavigation: "geoscene-icon-north-navigation";
-    readonly noticeTriangle: "geoscene-icon-notice-triangle";
-    readonly organization: "geoscene-icon-organization";
-    readonly pan: "geoscene-icon-pan";
-    readonly pan2: "geoscene-icon-pan2";
-    readonly partlyCloudy: "geoscene-icon-partly-cloudy";
-    readonly pause: "geoscene-icon-pause";
-    readonly play: "geoscene-icon-play";
-    readonly playCircled: "geoscene-icon-play-circled";
-    readonly plus: "geoscene-icon-plus";
-    readonly polyline: "geoscene-icon-polyline";
-    readonly printer: "geoscene-icon-printer";
-    readonly radioChecked: "geoscene-icon-radio-checked";
-    readonly radioUnchecked: "geoscene-icon-radio-unchecked";
-    readonly refresh: "geoscene-icon-refresh";
-    readonly reverse: "geoscene-icon-reverse";
-    readonly right: "geoscene-icon-right";
-    readonly rightArrow: "geoscene-icon-right-arrow";
-    readonly rightTriangleArrow: "geoscene-icon-right-triangle-arrow";
-    readonly rotate: "geoscene-icon-rotate";
-    readonly save: "geoscene-icon-save";
-    readonly search: "geoscene-icon-search";
-    readonly settings2: "geoscene-icon-settings2";
-    readonly slice: "geoscene-icon-slice";
-    readonly swap: "geoscene-icon-swap";
-    readonly table: "geoscene-icon-table";
-    readonly timeClock: "geoscene-icon-time-clock";
-    readonly tracking: "geoscene-icon-tracking";
-    readonly trash: "geoscene-icon-trash";
-    readonly unlockedLinkHorizontal: "geoscene-icon-unlocked-link-horizontal";
-    readonly up: "geoscene-icon-up";
-    readonly upArrow: "geoscene-icon-up-arrow";
-    readonly upDownArrows: "geoscene-icon-up-down-arrows";
-    readonly urbanModel: "geoscene-icon-urban-model";
-    readonly vertexGps: "geoscene-icon-vertex-gps";
-    readonly visible: "geoscene-icon-visible";
-    readonly zoomInFixed: "geoscene-icon-zoom-in-fixed";
-    readonly zoomInMagnifyingGlass: "geoscene-icon-zoom-in-magnifying-glass";
-    readonly zoomOutFixed: "geoscene-icon-zoom-out-fixed";
-    readonly zoomToObject: "geoscene-icon-zoom-to-object";
-};

package/dist/utils/mapping-utils.d.ts

@@ -1,2 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-export declare function disableNavigation(view: __geoscene.MapView | __geoscene.SceneView): __geoscene.MapView | __geoscene.SceneView;

package/dist/utils/math-utils.d.ts

@@ -1,6 +0,0 @@
-/**
- * Computes the mathematical (Euclidean) modulo of `n` with respect to `m`.
- * Unlike JavaScript's `%` operator, this always returns a non-negative result
- * in the range [0, m).
- */
-export declare function modulo(n: number, m: number): number;

package/dist/utils/related-feature-utils.d.ts

@@ -1,6 +0,0 @@
-export interface RelatedFieldInfo {
-    layerId: string;
-    fieldName: string;
-    label?: string;
-}
-export declare function getRelatedFieldInfo(field: string): RelatedFieldInfo | null;

package/dist/utils/screen-utils.d.ts

@@ -1,2 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-export declare function createScreenPoint(x?: number, y?: number): __geoscene.ScreenPoint;

package/dist/utils/signal-utils.d.ts

@@ -1,26 +0,0 @@
-type EqualityFunction<T> = (a: T, b: T) => boolean;
-export interface Computed<T> {
-    get value(): T;
-}
-export declare function equalsShallow(a: unknown, b: unknown): boolean;
-/**
- * Creates a reactive readonly value which can be used in auto-tracking contexts, just like an `Accessor` property.
- *
- * @method computed
- * @instance
- * @memberof module:geoscene/core/signal
- *
- * @param {module:geoscene/core/signal~ComputedExpression} compute
- * @param {module:geoscene/core/reactiveUtils~ReactiveEqualityFunction} [equalityFunction]
- *
- * @return {module:geoscene/core/signal~Computed}
- */
-export declare function computed<T>(compute: () => T, equalityFunction?: EqualityFunction<T>): Computed<T>;
-declare class WritableComputed<T> {
-    #private;
-    constructor(query: (prev?: T) => T);
-    mutate(optimisticValue: T): void;
-    get value(): T;
-}
-export declare function writeableComputed<T>(query: (prev?: nullish | T) => T): WritableComputed<T>;
-export {};

package/dist/utils/uri-utils.d.ts

@@ -1,4 +0,0 @@
-export declare function autoLink(messages: {
-    openInApp: string;
-    view: string;
-}, value: string): string;