@geoscene/map-components 4.33.20 → 5.0.19

package/dist/controllers/useViewModel.d.ts

@@ -1,57 +0,0 @@
-import { AccessorController } from '@geoscene/lumina/controllers/accessor';
-import { Nil } from '@arcgis/components-utils';
-import { default as Accessor } from '@geoscene/core/core/Accessor';
-import { default as Evented } from '@geoscene/core/core/Evented';
-import { default as GeosceneMap } from '@geoscene/core/Map';
-import { default as MapView } from '@geoscene/core/views/MapView';
-import { default as SceneView } from '@geoscene/core/views/SceneView';
-import { default as LinkChartView } from '@geoscene/core/views/LinkChartView';
-import { ViewControllerUses } from './useView';
-import { LitElement, EventEmitter } from '@geoscene/lumina';
-type ViewModelControllerRequires<Props, ViewModel extends ViewModelInstance> = LitElement & Pick<ViewModel, keyof Props & keyof ViewModel> & ViewModelControllerUses<ViewModel>;
-type ViewModelInstance = Accessor & Partial<Evented> & {
-    state?: string;
-    view?: LinkChartView | MapView | Nil | SceneView;
-    map?: GeosceneMap | Nil;
-};
-export interface ViewModelControllerUses<ViewModel extends ViewModelInstance> extends ViewControllerUses<NonNullable<ViewModelInstance["view"]>> {
-    state?: ViewModel["state"];
-    icon?: string;
-    label?: string;
-    geoscenePropertyChange: EventEmitter<{
-        name: string;
-    }> | undefined;
-    autoDestroyDisabled: boolean;
-    destroy: () => Promise<void>;
-}
-/**
- * A controller for a mapping component that:
- * - loads the viewModel
- * - initializes the viewModel with the component's properties
- * - does two-way binding between view model and component properties
- * - re-emits the viewModel's events on the component
- * - type-checks everything ✨
- *
- * Documentation:
- * 
- *
- * TEST: add test cases for this controller
- */
-export declare const makeViewModelController: <Props, ViewModel extends ViewModelInstance, OmitProps extends string = never>(loadViewModel: ((props?: Omit<Props, "view">) => ViewModel) | (new (props?: Omit<Props, "view">) => ViewModel), _options?: {
-    /**
-     * Don't expose the following ViewModels's properties on the component.
-     * You can also bind the property to \@State rather than \@Prop if you
-     * wish to use it internally only:
-     *
-     * @example
-     * \@State() timeZone = this.viewModel.timeZone;
-     */
-    omitProps: OmitProps[];
-}) => (component: ViewModelControllerRequires<Omit<Props, OmitProps>, ViewModel>) => ViewModel;
-export declare class ViewModelController<Props, ViewModel extends ViewModelInstance> extends AccessorController<Props, ViewModel, ViewModelControllerUses<ViewModel>> {
-    #private;
-    constructor(component: ViewModelControllerRequires<Props, ViewModel>, loadViewModel: ((props?: Omit<Props, "view">) => ViewModel) | (new (props?: Omit<Props, "view">) => ViewModel));
-    hostLoad(): void;
-    hostDestroy(): void;
-}
-export {};

package/dist/controllers/useWidget.d.ts

@@ -1,72 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { AccessorController } from '@geoscene/lumina/controllers/accessor';
-import { Nil } from '@arcgis/components-utils';
-import { default as GeosceneMap } from '@geoscene/core/Map';
-import { GeosceneReferenceElement } from '../utils/component-utils';
-import { LitElement, EventEmitter } from '@geoscene/lumina';
-import { PropertyValues } from 'lit';
-type Requires<Props, Widget extends WidgetInstance> = LitElement & Pick<Widget, keyof Props & keyof Widget> & Uses<Widget>;
-type WidgetInstance = __geoscene.Widget & {
-    state?: string;
-    viewModel?: __geoscene.Accessor & {
-        state?: string;
-        view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView | Nil;
-        map?: GeosceneMap | Nil;
-    };
-    view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView | Nil;
-    map?: GeosceneMap | Nil;
-    visibleElements?: Record<never, unknown>;
-};
-type Uses<Widget extends WidgetInstance> = {
-    state?: Exclude<Widget["viewModel"], Nil>["state"] | Widget["state"];
-    viewModel?: Widget["viewModel"];
-    closed?: boolean;
-    icon: Nil | string;
-    label: Nil | string;
-    referenceElement?: GeosceneReferenceElement | string;
-    position: __geoscene.UIPosition;
-    geosceneReady: EventEmitter;
-    geoscenePropertyChange: EventEmitter<{
-        name: string;
-    }> | undefined;
-    el: HTMLElement & {
-        childElem?: HTMLElement & {
-            ownedBy?: HTMLElement;
-        };
-        view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView;
-    };
-    autoDestroyDisabled: boolean;
-    destroy: () => Promise<void>;
-};
-/**
- * A controller for a wrapped JS API Widget
- * - loads the widget
- * - initializes the widget with the component's properties
- * - does two-way binding between widget and component properties
- * - re-emits the widgets's events on the component
- * - type-checks everything ✨
- *
- * Documentation:
- * https://qawebgis.geoscene.cn/components/lumina/transition-from-widgets#usewidget-controller
- */
-export declare const makeWidgetController: <Props, Widget extends WidgetInstance, OmitProps extends string = never>(createWidget: ((props?: Props) => Widget) | (new (props?: Props) => Widget), _options?: {
-    /**
-     * Don't expose the following Widget's properties on the component.
-     * You can also bind the property to \@State rather than \@Prop if you
-     * wish to use it internally only:
-     *
-     * @example
-     * \@state() timeZone = this.widget.timeZone;
-     */
-    omitProps: OmitProps[];
-}) => (component: Requires<Omit<Props, OmitProps | "container" | "id" | "view" | "visible" | "visibleElements">, Widget>) => Widget;
-export declare class WidgetController<Props, Widget extends WidgetInstance> extends AccessorController<Props, Widget, Uses<Widget>> {
-    #private;
-    constructor(component: Requires<Props, Widget> & Uses<Widget>, createWidget: ((props?: Props) => Widget) | (new (props?: Props) => Widget));
-    hostConnected(): void;
-    hostLoad(): void;
-    hostUpdate(changes: PropertyValues<Uses<Widget>>): void;
-    hostLoaded(): void;
-    hostDestroy(): void;
-}
-export {};

package/dist/geolocation/GeolocationPositioning.d.ts

@@ -1,55 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { default as Accessor } from '@geoscene/core/core/Accessor.js';
-import { default as Graphic } from '@geoscene/core/Graphic.js';
-import { default as MapView } from '@geoscene/core/views/MapView.js';
-import { default as SceneView } from '@geoscene/core/views/SceneView.js';
-declare class GeolocationPositioning extends Accessor {
-    protected initialize(): void;
-    destroy(): void;
-    protected _geolocationUsable: boolean;
-    geolocationOptions?: PositionOptions;
-    /**
-     * Indicates whether to navigate the view to the position and scale of the geolocated result.
-     *
-     * @default true
-     */
-    goToLocationEnabled: boolean;
-    goToOverride?: __geoscene.GoToOverride;
-    /**
-     * The graphic used to show the user's location on the map.
-     */
-    graphic: Graphic;
-    /**
-     * Indicates the scale to set on the view when navigating to the position of the geolocated
-     * result, after a location is returned from the [track](#event-track) event.
-     *
-     * @default null
-     */
-    scale?: number;
-    /**
-     * A convenience property that overrides the view's [rotationEnabled](https://next.gha.afd.geoscene.cn/javascript/latest/api-reference/geoscene-views-MapView.html#constraints) constraint.
-     *
-     * @default true
-     */
-    rotationEnabled: boolean;
-    /**
-     * The view associated with the Module.
-     */
-    view?: MapView | SceneView;
-    /**
-     * Clears the locate graphic from the view.
-     */
-    protected _clearGraphic(): void;
-    /**
-     * Adds the graphic to the view.
-     */
-    protected _addGraphic(): void;
-    private _handleViewTypeChange;
-    private _getScaleWithinConstraints;
-    private _getScale;
-    private _getHeading;
-    private _addHeading;
-    private _animatePoint;
-    protected updatePosition(position: GeolocationPosition, controller: AbortController): Promise<GeolocationPosition>;
-}
-export default GeolocationPositioning;

package/dist/interfaces.d.ts

@@ -1,31 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { default as Graphic } from '@geoscene/core/Graphic.js';
-import { default as Point } from '@geoscene/core/geometry/Point.js';
-import { default as Viewpoint } from '@geoscene/core/Viewpoint.js';
-type TargetBase = __geoscene.GeometryUnion | __geoscene.GeometryUnion[] | Graphic | Graphic[] | number[] | Viewpoint;
-export type Target2D = TargetBase;
-export type Target3D = __geoscene.Camera | TargetBase;
-interface TargetOptionsBase {
-    scale?: number;
-    zoom?: number;
-    heading?: number;
-    zoomFactor?: number;
-}
-interface TargetOptions2DBase extends TargetOptionsBase {
-    rotation?: number;
-}
-export interface TargetOptions2D extends TargetOptions2DBase {
-    target?: Target2D;
-}
-interface TargetOptions3DBase extends TargetOptionsBase {
-    tilt?: number;
-    position?: Point;
-    fov?: number;
-}
-export interface CenterOptions3D extends TargetOptions3DBase {
-    center?: number[] | Point;
-}
-export interface TargetOptions3D extends TargetOptions3DBase {
-    target?: Target3D;
-}
-export {};

package/dist/runtime.d.ts

@@ -1,6 +0,0 @@
-export declare const runtime: import('@geoscene/lumina').Runtime;
-/**
- * "customElement" needs to be exported - it will be used by the build system.
- * You should not call it directly.
- */
-export declare const customElement: (tagName: string, component: typeof import('@geoscene/lumina').LitElement) => void, getAssetPath: (suffix: string) => string, setAssetPath: (path: URL | string) => void;

package/dist/support/AnalysisViewModel.d.ts

@@ -1,96 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { default as Accessor } from '@geoscene/core/core/Accessor.js';
-import { AnalysisUnion, AnalysisViewUnion } from '@geoscene/core/unionTypes.js';
-import { default as SceneView } from '@geoscene/core/views/SceneView';
-export type AnalysisMap = {
-    [Key in AnalysisUnion["type"]]: Extract<AnalysisUnion, {
-        type: Key;
-    }>;
-};
-export type AnalysisViewMap = {
-    [Key in keyof AnalysisMap]: Extract<AnalysisViewUnion, {
-        analysis: {
-            type: Key;
-        };
-    }>;
-};
-export type AnalysisViewFor<Analysis extends AnalysisUnion> = AnalysisViewMap[Analysis["type"]];
-type OperationState = "active" | "inactive";
-export declare abstract class AnalysisViewModel<IViewType extends SceneView, AnalysisType extends __geoscene.AnalysisUnion> extends Accessor {
-    constructor();
-    protected initialize(): void;
-    destroy(): void;
-    get supported(): boolean;
-    view?: IViewType;
-    set visible(v: boolean);
-    get active(): boolean;
-    get disabled(): boolean;
-    /**
-     * Analysis data object.
-     */
-    set analysis(v: AnalysisType);
-    protected _analysisView?: AnalysisViewFor<AnalysisType>;
-    get analysisView(): AnalysisViewFor<AnalysisType> | undefined;
-    get ready(): boolean;
-    get connectingToView(): boolean;
-    /**
-     * Whether the viewmodel owns the analysis. In that case, it will remove and destroy the analysis when it is is
-     * destroyed. An analysis is initially created by the view model if none is provided and the view model owns it until
-     * it is moved to a layer or removed from the view.
-     */
-    private _ownsAnalysis;
-    private get _viewHasAnalysis();
-    private _reconnectViewTask?;
-    private _forceInteractiveHandle?;
-    private _operationState;
-    get operationState(): OperationState;
-    protected abstract readonly supportedViewType: "2d" | "3d";
-    protected abstract readonly unsupportedErrorMessage: string;
-    private _loggedUnsupportedErrorMessage;
-    /**
-     * Breaks the loop of:
-     *   Analysis move event
-     *   -> reconnect
-     *   -> remove analysis from view.analyses in disconnect
-     *   -> Analysis move event
-     */
-    private _changeFromReconnect;
-    private _startUserOperation;
-    protected abstract constructAnalysis(): AnalysisType;
-    /**
-     * Removes the tool and clears the analysis by resetting its inputs.
-     */
-    clear(): void;
-    abstract place(options?: {
-        signal?: AbortSignal;
-    }): Promise<void>;
-    /**
-     * If analysis has unset inputs, start() will kick off the user operation to specify those inputs.
-     */
-    start(operation?: (options?: {
-        signal?: AbortSignal;
-    }) => Promise<void>): Promise<void>;
-    startNewAnalysis(): Promise<void>;
-    continue(): Promise<void>;
-    stop(): void;
-    protected abstract clearAnalysis(): void;
-    /**
-     * A callback used by view models that manage an analysis belonging to an Layer.
-     *
-     * The function will be called each time the view becomes ready, the internal Layer of
-     * the view model has been added to the map and the analysis view of the analysis has been created.
-     */
-    protected onConnectToAnalysisView(_analysisView: AnalysisViewFor<AnalysisType>): void;
-    /**
-     * A callback used by view models that manage an analysis.
-     *
-     * The function will be called each time the view becomes unready and the internal analysis
-     * has been removed the map or analyses.
-     */
-    protected onDisconnectFromAnalysisView(): void;
-    private _scheduleViewReconnect;
-    private _reconnectView;
-    private _disconnectFromView;
-    private _setExternalAnalysis;
-}
-export {};

package/dist/support/basemapUtils.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-export declare function isBasemap3D(basemap: __geoscene.Basemap): boolean;
-export declare function isBasemapInBeta(basemap: __geoscene.Basemap): boolean;

package/dist/support/heading.d.ts

@@ -1,11 +0,0 @@
-import { JsxNode } from '@geoscene/lumina';
-import { TemplateResult } from 'lit-html';
-type HeadingProperties = {
-    class?: string;
-    level: HeadingLevel;
-    children: JsxNode;
-};
-export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
-export declare function Heading({ level, class: className, children }: HeadingProperties): TemplateResult;
-export declare function incrementHeadingLevel(level: HeadingLevel, incrementBy?: number): HeadingLevel;
-export {};

package/dist/support/maybe.d.ts

@@ -1,10 +0,0 @@
-import { Nil } from '@arcgis/components-utils';
-/**
- * call abort on the given maybe, if it is set.
- */
-export declare function abortMaybe<T extends {
-    abort: () => void;
-}>(object: Nil | T): undefined;
-export declare function removeMaybe<T extends {
-    remove: () => void;
-}>(object: Nil | T): undefined;

package/dist/support/measurementUtils.d.ts

@@ -1,19 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { default as QuantityFormatter } from '@geoscene/core/applications/Components/QuantityFormatter.js';
-export type MeasurementModeString = "euclidean" | "geodesic";
-export type Quantity = __geoscene.Area | __geoscene.Length;
-export type MeasurementState = "disabled" | "measured" | "measuring" | "ready" | "unsupported";
-export type MeasurementValue<T extends Quantity = Quantity> = {
-    state: "available";
-    value: T;
-} | {
-    state: "invalid";
-    value?: never;
-} | {
-    state: "unavailable";
-    value?: never;
-};
-export declare const measurementAreaUnits: ("square-millimeters" | "square-centimeters" | "square-decimeters" | "square-meters" | "square-kilometers" | "square-inches" | "square-feet" | "square-yards" | "square-miles" | "square-nautical-miles" | "square-us-feet" | "acres" | "ares" | "hectares" | "imperial" | "metric")[];
-export declare const measurementLengthUnits: ("imperial" | "metric" | "millimeters" | "centimeters" | "decimeters" | "meters" | "kilometers" | "inches" | "feet" | "yards" | "miles" | "nautical-miles" | "us-feet")[];
-export declare function getMeasurementValue<T extends Quantity>(value: nullish | T, valid?: boolean): MeasurementValue<T>;
-export declare function formatQuantity(formatter: QuantityFormatter, quantity: Quantity): string;

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

@@ -1,24 +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';
-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>;

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

@@ -1,66 +0,0 @@
-import { Nil } from '@arcgis/components-utils';
-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 {};

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/components-utils';
-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/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/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 geoscene-component";
-    readonly widgetButton: "geoscene-widget--button";
-    readonly widgetButtonActive: "geoscene-widget--button-active";
-    readonly widgetDisabled: "geoscene-widget--disabled";
-};

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

@@ -1,42 +0,0 @@
-/// <reference types="@geoscene/core/interfaces.d.ts" />
-import { Nil } from '@arcgis/components-utils';
-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 {};