@geoscene/map-components 4.33.18

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

@@ -0,0 +1,24 @@
+/// <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 '@arcgis/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

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

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

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

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

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

@@ -0,0 +1,42 @@
+/// <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 {};

package/dist/utils/legacyIcon.d.ts

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

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

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

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

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@geoscene/map-components",
+  "version": "4.33.18",
+  "description": "GeoScene Map Components",
+  "keywords": [
+    "GeoScene",
+    "javascript",
+    "map",
+    "3D",
+    "2D",
+    "visualization",
+    "analytics",
+    "spatial",
+    "data-driven",
+    "gis",
+    "components",
+    "web-components"
+  ],
+  "homepage": "https://doc.geoscene.cn/javascript/",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./loader": "./dist/loader.js",
+    "./package.json": "./package.json",
+    "./components/*/customElement": "./dist/components/*/customElement.js",
+    "./components/*": "./dist/components/*/index.js",
+    "./types/*": "./dist/types/*.d.ts",
+    "./docs/*": "./dist/docs/*",
+    "./geoscene-map-components/geoscene-map-components.css": "./dist/cdn/main.css",
+    "./dist/geoscene-map-components/geoscene-map-components.css": "./dist/cdn/main.css",
+    "./dist/loader": "./dist/loader.js",
+    "./dist/components": "./dist/index.js",
+    "./dist/components/*": "./dist/components/*/index.js",
+    "./main.css": "./dist/cdn/main.css"
+  },
+  "files": [
+    "dist/"
+  ],
+  "license": "SEE LICENSE IN LICENSE.md",
+  "dependencies": {
+    "@arcgis/components-utils": "4.33.18",
+    "@arcgis/lumina": "4.33.18",
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "@geoscene/core": "~4.33.0",
+    "@esri/calcite-components": "^3.2.1"
+  },
+  "css.customData": [
+    "dist/docs/vscode.css-custom-data.json"
+  ],
+  "customElements": "dist/docs/api.json",
+  "html.customData": [
+    "dist/docs/vscode.html-custom-data.json"
+  ],
+  "web-types": "dist/docs/web-types.json"
+}