@geoscene/map-components 4.33.19 → 4.34.9

package/dist/components/geoscene-zoom/customElement.js

@@ -1,86 +1,83 @@
 import { c as h } from "../../chunks/runtime.js";
-import { html as f } from "lit-html";
-import { classes as i } from "@arcgis/components-utils";
+import { css as g, html as b } from "lit";
+import { classes as s } from "@arcgis/toolkit/dom";
 import { ignoreAbortErrors as l } from "@geoscene/core/core/promiseUtils.js";
-import { when as m } from "@geoscene/core/core/reactiveUtils.js";
-import { LitElement as y, createEvent as p, noShadowRoot as g, safeClassMap as r, nothing as u } from "@arcgis/lumina";
-import { usePropertyChange as z } from "@arcgis/lumina/controllers";
-import { u as b } from "../../chunks/useT9n.js";
-import { u as O } from "../../chunks/useView.js";
-import { css as Z } from "@lit/reactive-element/css-tag.js";
+import { when as y } from "@geoscene/core/core/reactiveUtils.js";
+import { LitElement as z, createEvent as p, safeClassMap as i, nothing as m } from "@geoscene/lumina";
+import { usePropertyChange as v } from "@geoscene/lumina/controllers";
+import { u as x } from "../../chunks/useT9n.js";
+import { u as $ } from "../../chunks/useView.js";
 /*! All material copyright GeoScene, All Rights Reserved, unless otherwise specified.
-See https://js.geoscene.cn/4.33/geoscene/copyright.txt for details.
-v4.33.18 */
-const a = {
+See https://js.geoscene.cn/4.34/geoscene/copyright.txt for details.
+v4.34.9 */
+const r = {
   base: "geoscene-zoom",
+  button: "geoscene-button",
   horizontalLayout: "geoscene-zoom--horizontal",
-  button: "geoscene-widget--button",
   zoomIn: "geoscene-zoom__zoom-in",
   zoomOut: "geoscene-zoom__zoom-out"
 };
-function I(t) {
+function u(t) {
+  if (!t)
+    return !1;
   if (t.type === "3d")
-    return !!t.ready;
+    return t.ready;
   if (!t?.ready)
     return !1;
-  const e = d(t), s = t.constraints?.effectiveMaxScale;
-  return s === 0 || e > s;
+  const e = f(t), a = t.constraints?.effectiveMaxScale;
+  return a === 0 || e > a;
 }
-function w(t) {
+function d(t) {
+  if (!t)
+    return !1;
   if (t.type === "3d")
-    return !!t.ready;
+    return t.ready;
   if (!t?.ready)
     return !1;
-  const e = d(t), s = t.constraints?.effectiveMinScale;
-  return s === 0 || e < s;
+  const e = f(t), a = t.constraints?.effectiveMinScale;
+  return a === 0 || e < a;
 }
-function d(t) {
+function f(t) {
   const o = t?.animation?.target;
   return (o && "then" in o ? void 0 : o?.scale) ?? t?.scale ?? 0;
 }
-const x = Z`@layer{geoscene-zoom,.geoscene-zoom{display:flex;flex-flow:column nowrap;box-shadow:0 1px 2px #0000004d}.geoscene-zoom__zoom-out{border-block-start:solid 1px var(--calcite-color-border-1)}.geoscene-zoom--horizontal{flex-flow:row-reverse nowrap}.geoscene-zoom--horizontal .geoscene-zoom__zoom-out{border-block-start:none;border-inline-end:solid 1px var(--calcite-color-border-1)}}`;
-class $ extends y {
+const E = g`.geoscene-button{--calcite-icon-color: var(--calcite-color-text-3);--calcite-button-background-color: var(--calcite-color-foreground-1);color:var(--calcite-color-text-3);line-height:var(--calcite-font-line-height-relative-tight);display:flex;flex-flow:column;cursor:pointer;background-color:var(--calcite-color-foreground-1);font-size:var(--calcite-font-size);:hover{--calcite-icon-color: var(--calcite-color-text-1);--calcite-button-background-color: var(--calcite-color-transparent-hover)}calcite-button{width:var(--calcite-spacing-xxxl);height:var(--calcite-spacing-xxxl)}}:host{display:flex;max-width:fit-content}.geoscene-zoom__zoom-out{border-block-start:solid 1px var(--calcite-color-border-1)}.geoscene-zoom--horizontal{flex-flow:row-reverse nowrap}.geoscene-zoom--horizontal .geoscene-zoom__zoom-out{border-block-start:none;border-inline-end:solid 1px var(--calcite-color-border-1)}`;
+class O extends z {
   constructor() {
-    super(...arguments), this.messages = b({}), this.view = O(this), this.canZoomIn = !1, this.canZoomOut = !1, this.autoDestroyDisabled = !1, this.icon = "magnifying-glass-plus", this.layout = "vertical", this.position = "top-left", this.state = "disabled", this.geoscenePropertyChange = z()("state"), this.geosceneReady = p();
-  }
-  static {
-    this.properties = { canZoomIn: 16, canZoomOut: 16, autoDestroyDisabled: 5, icon: 1, label: 1, layout: 3, messageOverrides: 0, position: 1, referenceElement: 1, state: 3 };
+    super(...arguments), this.messages = x({}), this.view = $(this), this.autoDestroyDisabled = !1, this.icon = "magnifying-glass-plus", this.layout = "vertical", this.state = "disabled", this.geoscenePropertyChange = v()("state"), this.geosceneReady = p();
   }
   static {
-    this.shadowRootOptions = g;
+    this.properties = { view: 0, autoDestroyDisabled: 5, icon: 1, label: 1, layout: 3, messageOverrides: 0, position: 1, referenceElement: 1, state: 3 };
   }
   static {
-    this.styles = x;
+    this.styles = E;
   }
   async destroy() {
     await this.manager.destroy();
   }
   async zoomIn() {
     const { view: o } = this;
-    !this.canZoomIn || !o || (o.type === "2d" ? o.mapViewNavigation.zoomIn() : l(o.goTo({ zoomFactor: 2 })));
+    !u(o) || !o || (o.type === "2d" ? o.mapViewNavigation.zoomIn() : l(o.goTo({ zoomFactor: 2 })));
   }
   async zoomOut() {
     const { view: o } = this;
-    !this.canZoomOut || !o || (o.type === "2d" ? o.mapViewNavigation.zoomOut() : l(o.goTo({ zoomFactor: 0.5 })));
+    !d(o) || !o || (o.type === "2d" ? o.mapViewNavigation.zoomOut() : l(o.goTo({ zoomFactor: 0.5 })));
   }
   loaded() {
     this.manager.onLifecycle(() => [
-      m(() => this.view?.stationary, () => {
-        this.canZoomIn = I(this.view), this.canZoomOut = w(this.view);
-      }, { initial: !0 }),
-      m(() => this.view?.ready ? "ready" : "disabled", (o) => {
+      y(() => this.view?.ready ? "ready" : "disabled", (o) => {
         this.state = o;
       }, { sync: !0, initial: !0 })
     ]);
   }
   render() {
     const o = {
-      [a.horizontalLayout]: this.layout === "horizontal"
-    }, { canZoomIn: e, canZoomOut: s } = this, { zoomIn: n, zoomOut: c } = this.messages;
-    return f`<div class=${r(i(a.base, o))}><calcite-button class=${r(i(a.button, a.zoomIn))} .disabled=${!e} icon-start=plus kind=neutral .label=${n} @click=${this.zoomIn} title=${n ?? u}></calcite-button><calcite-button class=${r(i(a.button, a.zoomOut))} .disabled=${!s} icon-start=minus kind=neutral .label=${c} @click=${this.zoomOut} title=${c ?? u}></calcite-button></div>`;
+      [r.horizontalLayout]: this.layout === "horizontal"
+    }, e = u(this.view), a = d(this.view), { zoomIn: c, zoomOut: n } = this.messages;
+    return b`<div class=${i(s(r.base, r.button, o))}><calcite-button class=${i(s(r.zoomIn))} .disabled=${!e} icon-start=plus kind=neutral .label=${c} @click=${this.zoomIn} title=${c ?? m}></calcite-button><calcite-button class=${i(s(r.zoomOut))} .disabled=${!a} icon-start=minus kind=neutral .label=${n} @click=${this.zoomOut} title=${n ?? m}></calcite-button></div>`;
   }
 }
-h("geoscene-zoom", $);
+h("geoscene-zoom", O);
 export {
-  $ as GeosceneZoom
+  O as GeosceneZoom
 };

package/dist/components/geoscene-zoom/index.d.ts

@@ -1,2 +1,2 @@
-import "@esri/calcite-components/components/calcite-button";
+import "@geoscene/calcite-components/components/calcite-button";
 export * from "./customElement.js";

package/dist/components/geoscene-zoom/index.js

@@ -1,2 +1,2 @@
-import "@esri/calcite-components/components/calcite-button";
+import "@geoscene/calcite-components/components/calcite-button";
 export * from "./customElement.js";

package/dist/components/geoscene-zoom/utils.d.ts

@@ -1,4 +1,4 @@
 import { default as MapView } from '@geoscene/core/views/MapView.js';
 import { default as SceneView } from '@geoscene/core/views/SceneView.js';
-export declare function canZoomIn(view: MapView | SceneView): boolean;
-export declare function canZoomOut(view: MapView | SceneView): boolean;
+export declare function canZoomIn(view?: MapView | SceneView): boolean;
+export declare function canZoomOut(view?: MapView | SceneView): boolean;

package/dist/components/support/utility-components/component-wrapper.d.ts

@@ -0,0 +1,10 @@
+import { JsxNode } from '@geoscene/lumina';
+import { HeadingLevel } from '../../../support/heading';
+export declare function ComponentWrapper(props: {
+    class: Record<string, boolean> | string;
+    children?: JsxNode;
+    hideHeader?: boolean;
+    headingLevel?: HeadingLevel;
+    title?: string;
+    label: string;
+}): JsxNode;

package/dist/components/support/utility-components/visible-element.d.ts

@@ -0,0 +1,5 @@
+import { JsxNode } from '@geoscene/lumina';
+export declare function VisibleElement(props: {
+    hidden?: boolean;
+    children?: JsxNode;
+}): JsxNode;

package/dist/controllers/Handles.d.ts

@@ -1,4 +1,4 @@
-import { IHandle, Nil } from '@arcgis/components-utils';
+import { IHandle, nil } from '@arcgis/toolkit/type';
 export declare class Handles<T = string, H extends IHandle = IHandle> {
     /**
      * A handle to a [highlight](https://next.gha.afd.geoscene.cn/javascript/latest/api-reference/geoscene-views-layers-FeatureLayerView.html#highlight) call result.
@@ -59,7 +59,7 @@ export declare class Handles<T = string, H extends IHandle = IHandle> {
      * ));
      * @instance
      */
-    add(handles: (H | Nil)[] | H | Nil, groupKey?: T): this;
+    add(handles: (H | nil)[] | H | nil, groupKey?: T): this;
     forEach(groupKey: T, callback: (handle: H) => void): void;
     forEach(callback: (handle: H) => void): void;
     /**

package/dist/controllers/createCloseEvent.d.ts

@@ -1,6 +1,6 @@
-import { EventEmitter } from '@arcgis/lumina';
+import { EventEmitter } from '@geoscene/lumina';
 export declare const createCloseEvent: (component: {
     geosceneClose: EventEmitter;
     autoDestroyDisabled: boolean;
     destroy: () => void;
-} & import('@arcgis/lumina').LitElement) => EventEmitter;
+} & import('@geoscene/lumina').LitElement) => EventEmitter;

package/dist/controllers/screenLocation.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+import { GenericController } from '@geoscene/lumina/controllers';
+import { nil } from '@arcgis/toolkit/type';
+import { LitElement } from '@geoscene/lumina';
+interface ScreenLocationComponent extends LitElement {
+    view?: __geoscene.MapView | __geoscene.SceneView | nil;
+    location?: __geoscene.Point | nil;
+    trackLocation: boolean;
+}
+/**
+ * Controller for managing and projecting a map point to a map screen location
+ *
+ * This class observes changes to a MapView/SceneView, location Point, and tracking state, and projects Point coordinates to screen coordinates. It updates the screen location whenever relevant properties change, and exposes the projected screen point.
+ */
+export declare class ScreenLocation extends GenericController<__geoscene.ScreenPoint | nil, ScreenLocationComponent> {
+    constructor(component: LitElement & ScreenLocationComponent);
+    hostLoaded(): void;
+    private _updateScreenLocation;
+}
+export declare const trackScreenLocation: (component: LitElement & ScreenLocationComponent) => nil | __geoscene.ScreenPoint;
+export {};

package/dist/controllers/uiController.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+import { default as LinkChartView } from '@geoscene/core/views/LinkChartView';
+import { default as MapView } from '@geoscene/core/views/MapView';
+import { default as SceneView } from '@geoscene/core/views/SceneView';
+import { JsxNode, LitElement } from '@geoscene/lumina';
+import { GenericController } from '@geoscene/lumina/controllers';
+import { GeosceneLinkChart } from '../components/geoscene-link-chart/customElement.js';
+import { GeosceneMap } from '../components/geoscene-map/customElement.js';
+import { GeoscenePopup } from '../components/geoscene-popup/customElement.js';
+import { GeosceneScene } from '../components/geoscene-scene/customElement.js';
+type ViewComponent = GeosceneLinkChart | GeosceneMap | GeosceneScene;
+type WebGLSupportedError = {
+    name: "webgl:required";
+};
+export declare class UiController extends GenericController<never, {
+    popupDisabled: boolean;
+    view: LinkChartView | MapView | SceneView;
+}> {
+    direction: "ltr" | "rtl";
+    popupRef?: HTMLGeoscenePopupElement;
+    webGLError?: WebGLSupportedError;
+    constructor(component: LitElement & ViewComponent);
+    hostLifecycle(): IHandle;
+    openPopup(options: __geoscene.FeaturesViewModelOpenOptions): void;
+    closePopup(): void;
+    private _handleOpenPopup;
+    private _handlePopupSlotChange;
+    private _webGLErrorAlert;
+    render(): JsxNode;
+}
+export {};

package/dist/controllers/useGeosceneLoadError.d.ts

@@ -0,0 +1,27 @@
+import { default as WebMap } from '@geoscene/core/WebMap.js';
+import { default as WebScene } from '@geoscene/core/WebScene.js';
+import { default as WebLinkChart } from '@geoscene/core/WebLinkChart';
+import { default as Map } from '@geoscene/core/Map.js';
+import { default as Basemap } from '@geoscene/core/Basemap.js';
+import { default as Ground } from '@geoscene/core/Ground.js';
+import { default as Layer } from '@geoscene/core/layers/Layer.js';
+import { EventEmitter } from '@geoscene/lumina';
+/** A potential source of load errors. */
+export type LoadErrorSource = Basemap | Ground | Layer | WebLinkChart | WebMap | WebScene;
+/**
+ * Watches for load errors on components that have a `map` property. Returns an event that will be
+ * emitted each time a load error is thrown. It will also update the component's `loadErrorSources`
+ * property with the latest errors.
+ *
+ * @example
+ *
+ * ```js
+ * class MyMapComponent extends LitElement {
+ *   geosceneLoadError = useGeosceneLoadError(this);
+ * }
+ * ```
+ */
+export declare const useGeosceneLoadError: (component: {
+    map: Map | nullish;
+    loadErrorSources?: LoadErrorSource[];
+} & import('@geoscene/lumina').LitElement) => EventEmitter;

package/dist/controllers/useGeosceneViewReadyError.d.ts

@@ -0,0 +1,17 @@
+import { default as View } from '@geoscene/core/views/View.js';
+import { EventEmitter } from '@geoscene/lumina';
+/**
+ * Watches for view ready state errors on components. Returns an event that will be emitted each
+ * time the view's `readyState` indicates an error.
+ *
+ * @example
+ *
+ * ```js
+ * class MyMapComponent extends LitElement {
+ *   geosceneViewReadyError = useGeosceneViewReadyError(this);
+ * }
+ * ```
+ */
+export declare const useGeosceneViewReadyError: (component: {
+    view: nullish | View;
+} & import('@geoscene/lumina').LitElement) => EventEmitter;

package/dist/controllers/useHandles.d.ts

@@ -1,5 +1,5 @@
-import { IHandle } from '@arcgis/components-utils';
-import { Controller } from '@arcgis/lumina/controllers';
+import { IHandle } from '@arcgis/toolkit/type';
+import { Controller } from '@geoscene/lumina/controllers';
 /**
  * Avoid accidentally adding objects that look like handles because they have a `remove` method,
  * but are not because they can be destroyed e.g. the Handles object.

package/dist/controllers/useT9n.d.ts

@@ -1 +1 @@
-export declare const useT9n: import('@arcgis/lumina/controllers').UseT9n;
+export declare const useT9n: import('@geoscene/lumina/controllers').UseT9n;

package/dist/controllers/useView.d.ts

@@ -1,30 +1,30 @@
 /// <reference types="@geoscene/core/interfaces.d.ts" />
-import { GenericController } from '@arcgis/lumina/controllers';
-import { Nil } from '@arcgis/components-utils';
+import { GenericController } from '@geoscene/lumina/controllers';
+import { nil } from '@arcgis/toolkit/type';
 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 { GeosceneReferenceElement } from '../utils/component-utils';
 import { PropertyValues } from 'lit';
-import { LitElement, EventEmitter } from '@arcgis/lumina';
+import { LitElement, EventEmitter } from '@geoscene/lumina';
 type View = LinkChartView | MapView | SceneView;
 type ViewControllerRequires<ViewType extends View> = LitElement & ViewControllerUses<ViewType>;
 export interface ViewControllerUses<ViewType extends View> {
-    view?: Nil | ViewType;
-    position: __geoscene.UIPosition;
+    view?: nil | ViewType;
+    position?: __geoscene.UIPosition;
     referenceElement?: GeosceneReferenceElement | string;
     geosceneReady: EventEmitter;
     el: HTMLElement & {
         childElem?: HTMLElement & {
             ownedBy?: HTMLElement;
         };
-        view?: Nil | ViewType;
+        view?: nil | ViewType;
     };
 }
 /**
  * Creates a controller which adds a `view` property to the component and connects the component to that view, both when
  * the view is provided directly or linked via the `referenceElement` property. The controller also handles emitting the
- * `arcgisViewReady` event and removing the component from the view's UI when the component is disconnected.
+ * `geosceneViewReady` event and removing the component from the view's UI when the component is disconnected.
  */
 export declare const useView: <ViewType extends View = View>(component: ViewControllerRequires<ViewType>) => ViewType | undefined;
 export declare class ViewController<ViewType extends View = View> extends GenericController<ViewType | undefined, ViewControllerRequires<ViewType>> {

package/dist/controllers/useViewModel.d.ts

@@ -1,18 +1,18 @@
-import { AccessorController } from '@arcgis/lumina/controllers/accessor';
-import { Nil } from '@arcgis/components-utils';
+import { AccessorController } from '@geoscene/lumina/controllers/accessor';
+import { nil } from '@arcgis/toolkit/type';
 import { default as Accessor } from '@geoscene/core/core/Accessor';
-import { default as Evented } from '@geoscene/core/core/Evented';
+import { 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 '@arcgis/lumina';
+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;
+    view?: LinkChartView | MapView | nil | SceneView;
+    map?: GeosceneMap | nil;
 };
 export interface ViewModelControllerUses<ViewModel extends ViewModelInstance> extends ViewControllerUses<NonNullable<ViewModelInstance["view"]>> {
     state?: ViewModel["state"];

package/dist/controllers/useWidget.d.ts

@@ -1,30 +1,30 @@
 /// <reference types="@geoscene/core/interfaces.d.ts" />
-import { AccessorController } from '@arcgis/lumina/controllers/accessor';
-import { Nil } from '@arcgis/components-utils';
+import { AccessorController } from '@geoscene/lumina/controllers/accessor';
+import { nil } from '@arcgis/toolkit/type';
 import { default as GeosceneMap } from '@geoscene/core/Map';
 import { GeosceneReferenceElement } from '../utils/component-utils';
-import { LitElement, EventEmitter } from '@arcgis/lumina';
+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;
     };
-    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"];
+    state?: Exclude<Widget["viewModel"], nil>["state"] | Widget["state"];
     viewModel?: Widget["viewModel"];
     closed?: boolean;
-    icon: Nil | string;
-    label: Nil | string;
+    icon: nil | string;
+    label: nil | string;
     referenceElement?: GeosceneReferenceElement | string;
-    position: __geoscene.UIPosition;
+    position?: __geoscene.UIPosition;
     geosceneReady: EventEmitter;
     geoscenePropertyChange: EventEmitter<{
         name: string;
@@ -33,7 +33,7 @@ type Uses<Widget extends WidgetInstance> = {
         childElem?: HTMLElement & {
             ownedBy?: HTMLElement;
         };
-        view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView;
+        view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView | nullish;
     };
     autoDestroyDisabled: boolean;
     destroy: () => Promise<void>;
@@ -59,7 +59,7 @@ export declare const makeWidgetController: <Props, Widget extends WidgetInstance
      * \@state() timeZone = this.widget.timeZone;
      */
     omitProps: OmitProps[];
-}) => (component: Requires<Omit<Props, OmitProps | "container" | "id" | "view" | "visible" | "visibleElements">, Widget>) => Widget;
+}) => (component: Requires<Omit<Props, OmitProps | "container" | "destroyed" | "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));