@honua/sdk-esri-compat 0.1.12 → 0.1.13

package/esri-compat/widget-host.d.ts

@@ -5,15 +5,10 @@
  * renders through the shared component set instead of shim-only markup
  * (issue #493, REQ-004).
  *
- * Only three shims delegate through this host today — `LegendCompat`
- * (`honua-legend`), `LayerListCompat` (`honua-layer-list`), and
- * `TimeSliderCompat` (`honua-time-slider`, issue #959). The other ~22 shims
- * that accept a `container` option are state-model-only regardless of
- * registration: they never construct a host, never mount a component, and
- * never emit the missing-kit diagnostic below. {@link expectedKitConstructor}
- * additionally knows `honua-search` / `honua-measurement`, ready for the day
- * `SearchCompat` / `MeasurementCompat` adopt the host; until then, do not
- * describe the registration as something that makes "the widgets" render.
+ * Shims that construct this host delegate their container to a kit element.
+ * A shim that does not construct a host stays state-model-only. The host
+ * never imports the kit; {@link expectedKitConstructor} names the class that
+ * must own each tag.
  *
  * The host **never imports the web-component kit** — not even dynamically:
  * the `/esri-compat` entrypoint is bundle-budgeted, and any intra-package
@@ -22,10 +17,15 @@
  * once via {@link registerHonuaWidgetKit}:
  *
  * ```ts doc-test=skip reason="wiring snippet requires an application host"
+ * import { registerComponent } from "@honua/app-platform/controls";
  * import { registerHonuaWidgetKit } from "@honua/sdk-esri-compat";
  *
- * // Eager (module object) or lazy (loader) — both work:
- * registerHonuaWidgetKit(() => import("@honua/sdk-js/web-components"));
+ * // One tag. registerComponent imports the side-effect-free elements module
+ * // and calls defineHonuaWebComponent for that catalog id only.
+ * await registerComponent("web-components.legend");
+ * registerHonuaWidgetKit({
+ *   HonuaLegendElement: customElements.get("honua-legend"),
+ * });
  * ```
  *
  * The host is deliberately defensive:
@@ -66,18 +66,40 @@ export interface HonuaWidgetKitLike {
     HonuaSearchElement?: CustomElementConstructor;
     HonuaMeasurementElement?: CustomElementConstructor;
     HonuaTimeSliderElement?: CustomElementConstructor;
+    HonuaEditorElement?: CustomElementConstructor;
+    HonuaFeatureEditorElement?: CustomElementConstructor;
+    HonuaFeatureTableElement?: CustomElementConstructor;
+    HonuaBookmarksElement?: CustomElementConstructor;
+    HonuaBasemapControlElement?: CustomElementConstructor;
+    HonuaLocateControlElement?: CustomElementConstructor;
+    HonuaSketchControlElement?: CustomElementConstructor;
+    HonuaPrintExportElement?: CustomElementConstructor;
+    HonuaFeatureInspectionElement?: CustomElementConstructor;
+    HonuaZoomElement?: CustomElementConstructor;
+    HonuaHomeElement?: CustomElementConstructor;
+    HonuaScaleBarElement?: CustomElementConstructor;
+    HonuaCompassElement?: CustomElementConstructor;
+    HonuaFullscreenElement?: CustomElementConstructor;
+    HonuaAttributionElement?: CustomElementConstructor;
+    HonuaFeaturePagerElement?: CustomElementConstructor;
+    HonuaAttachmentsElement?: CustomElementConstructor;
+    HonuaScaleRangeElement?: CustomElementConstructor;
+    HonuaDirectionsElement?: CustomElementConstructor;
+    HonuaChartElement?: CustomElementConstructor;
     defineHonuaWebComponents?: (registry?: CustomElementRegistry) => void;
 }
 /** A kit module object, or a (possibly async) loader for one. */
 export type HonuaWidgetKitSource = HonuaWidgetKitLike | (() => HonuaWidgetKitLike | Promise<HonuaWidgetKitLike>);
 /**
  * Injects the web-component kit that {@link HonuaWidgetHost} delegates to.
- * Call once from application code with the `@honua/sdk-js/web-components`
- * (or `@honua/app-platform/web-components`) module — eagerly or as a lazy
- * loader. Pass `undefined` to unregister: delegating shims return to headless
- * mode, and each host drops any element it had mounted on its next
- * {@link HonuaWidgetHost.mount} / {@link HonuaWidgetHost.update} rather than
- * stranding a live component that no longer receives updates.
+ * Register one tag with `registerComponent` from `@honua/app-platform/controls`
+ * (`src/controls/registry.ts`), then pass that tag's constructor here and omit
+ * `defineHonuaWebComponents`. Importing `@honua/app-platform/web-components`
+ * runs `defineHonuaWebComponents()` for every tag. Pass `undefined` to
+ * unregister: delegating shims return to headless mode, and each host drops
+ * any element it had mounted on its next {@link HonuaWidgetHost.mount} /
+ * {@link HonuaWidgetHost.update} rather than stranding a live component that
+ * no longer receives updates.
  *
  * Calling this also re-arms the one-time missing-kit diagnostic: registration
  * is exactly the state the warning asks for, so an app that later unregisters
@@ -117,4 +139,11 @@ export declare class HonuaWidgetHost {
     /** Removes the mounted element from the container. */
     destroy(): void;
 }
+/**
+ * Constructs a host when `container` is set and a DOM can resolve it.
+ * Headless construction returns `undefined` and does not touch a document.
+ */
+export declare function bindHonuaWidgetHost(tagName: string, container: unknown, eventBus?: CompatEventBus): HonuaWidgetHost | undefined;
+/** Copies shim state onto the mounted element. Missing kit leaves the container empty. */
+export declare function pushWidgetHostState(host: HonuaWidgetHost | undefined, state: Readonly<Record<string, unknown>>): void;
 //# sourceMappingURL=widget-host.d.ts.map

package/esri-compat/widget-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"widget-host.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/widget-host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAiBrD,oEAAoE;AACpE,MAAM,WAAW,sBAAuB,SAAQ,WAAW;IACzD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,kBAAkB,CAAC,EAAE,wBAAwB,CAAC;IAC9C,qBAAqB,CAAC,EAAE,wBAAwB,CAAC;IACjD,kBAAkB,CAAC,EAAE,wBAAwB,CAAC;IAC9C,uBAAuB,CAAC,EAAE,wBAAwB,CAAC;IACnD,sBAAsB,CAAC,EAAE,wBAAwB,CAAC;IAClD,wBAAwB,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,qBAAqB,KAAK,IAAI,CAAC;CACvE;AAED,iEAAiE;AACjE,MAAM,MAAM,oBAAoB,GAAG,kBAAkB,GAAG,CAAC,MAAM,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC;AAYjH;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,oBAAoB,GAAG,SAAS,GAAG,IAAI,CAGrF;AAiCD,qBAAa,eAAe;;IAQ1B;;;;OAIG;gBACgB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,cAAc;IAMjF,gEAAgE;IAChE,IAAW,SAAS,IAAI,OAAO,CAE9B;IAED,6DAA6D;IAC7D,IAAW,OAAO,IAAI,sBAAsB,GAAG,SAAS,CAEvD;IAED;;;;;;;;;;OAUG;IACU,KAAK,IAAI,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC;IAuBjE;;;;OAIG;IACU,MAAM,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAKrF,sDAAsD;IAC/C,OAAO,IAAI,IAAI;CAoCvB"}
+{"version":3,"file":"widget-host.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/widget-host.ts"],"names":[],"mappings":"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"}

package/esri-compat/widget-host.js

@@ -5,15 +5,10 @@
  * renders through the shared component set instead of shim-only markup
  * (issue #493, REQ-004).
  *
- * Only three shims delegate through this host today — `LegendCompat`
- * (`honua-legend`), `LayerListCompat` (`honua-layer-list`), and
- * `TimeSliderCompat` (`honua-time-slider`, issue #959). The other ~22 shims
- * that accept a `container` option are state-model-only regardless of
- * registration: they never construct a host, never mount a component, and
- * never emit the missing-kit diagnostic below. {@link expectedKitConstructor}
- * additionally knows `honua-search` / `honua-measurement`, ready for the day
- * `SearchCompat` / `MeasurementCompat` adopt the host; until then, do not
- * describe the registration as something that makes "the widgets" render.
+ * Shims that construct this host delegate their container to a kit element.
+ * A shim that does not construct a host stays state-model-only. The host
+ * never imports the kit; {@link expectedKitConstructor} names the class that
+ * must own each tag.
  *
  * The host **never imports the web-component kit** — not even dynamically:
  * the `/esri-compat` entrypoint is bundle-budgeted, and any intra-package
@@ -22,10 +17,15 @@
  * once via {@link registerHonuaWidgetKit}:
  *
  * ```ts doc-test=skip reason="wiring snippet requires an application host"
+ * import { registerComponent } from "@honua/app-platform/controls";
  * import { registerHonuaWidgetKit } from "@honua/sdk-esri-compat";
  *
- * // Eager (module object) or lazy (loader) — both work:
- * registerHonuaWidgetKit(() => import("@honua/sdk-js/web-components"));
+ * // One tag. registerComponent imports the side-effect-free elements module
+ * // and calls defineHonuaWebComponent for that catalog id only.
+ * await registerComponent("web-components.legend");
+ * registerHonuaWidgetKit({
+ *   HonuaLegendElement: customElements.get("honua-legend"),
+ * });
  * ```
  *
  * The host is deliberately defensive:
@@ -67,12 +67,14 @@ let widgetKitSource;
 let missingWidgetKitReported = false;
 /**
  * Injects the web-component kit that {@link HonuaWidgetHost} delegates to.
- * Call once from application code with the `@honua/sdk-js/web-components`
- * (or `@honua/app-platform/web-components`) module — eagerly or as a lazy
- * loader. Pass `undefined` to unregister: delegating shims return to headless
- * mode, and each host drops any element it had mounted on its next
- * {@link HonuaWidgetHost.mount} / {@link HonuaWidgetHost.update} rather than
- * stranding a live component that no longer receives updates.
+ * Register one tag with `registerComponent` from `@honua/app-platform/controls`
+ * (`src/controls/registry.ts`), then pass that tag's constructor here and omit
+ * `defineHonuaWebComponents`. Importing `@honua/app-platform/web-components`
+ * runs `defineHonuaWebComponents()` for every tag. Pass `undefined` to
+ * unregister: delegating shims return to headless mode, and each host drops
+ * any element it had mounted on its next {@link HonuaWidgetHost.mount} /
+ * {@link HonuaWidgetHost.update} rather than stranding a live component that
+ * no longer receives updates.
  *
  * Calling this also re-arms the one-time missing-kit diagnostic: registration
  * is exactly the state the warning asks for, so an app that later unregisters
@@ -87,9 +89,11 @@ function missingWidgetKitMessage(tagName) {
     return [
         `[honua/esri-compat] <${tagName}> was not mounted because no Honua widget kit is registered,`,
         "so this widget stays state-model-only and its container renders nothing.",
-        'Call registerHonuaWidgetKit(() => import("@honua/sdk-js/web-components")) once during application',
-        "startup, before constructing compat widgets. This affects the shims that delegate to the widget",
-        `kit — LegendCompat, LayerListCompat, and TimeSliderCompat. See ${WIDGET_KIT_DOCS_URL}`,
+        "Call registerComponent from @honua/app-platform/controls for that one tag, then",
+        "registerHonuaWidgetKit with the registered constructor and without defineHonuaWebComponents,",
+        "once during application startup. Importing @honua/app-platform/web-components runs",
+        "defineHonuaWebComponents() for every tag. This affects the shims that construct a widget host.",
+        `See ${WIDGET_KIT_DOCS_URL}`,
     ].join(" ");
 }
 /**
@@ -216,6 +220,26 @@ export class HonuaWidgetHost {
         return this.#kitLoad;
     }
 }
+/**
+ * Constructs a host when `container` is set and a DOM can resolve it.
+ * Headless construction returns `undefined` and does not touch a document.
+ */
+export function bindHonuaWidgetHost(tagName, container, eventBus) {
+    if (container == null)
+        return undefined;
+    const host = new HonuaWidgetHost(tagName, container, eventBus);
+    return host.available ? host : undefined;
+}
+/** Copies shim state onto the mounted element. Missing kit leaves the container empty. */
+export function pushWidgetHostState(host, state) {
+    if (!host)
+        return;
+    void host.update((element) => {
+        for (const [key, value] of Object.entries(state)) {
+            element[key] = value;
+        }
+    });
+}
 /** Resolves the web-components kit class that must own `tagName` for delegation. */
 function expectedKitConstructor(kit, tagName) {
     switch (tagName) {
@@ -229,6 +253,46 @@ function expectedKitConstructor(kit, tagName) {
             return kit.HonuaMeasurementElement;
         case "honua-time-slider":
             return kit.HonuaTimeSliderElement;
+        case "honua-editor":
+            return kit.HonuaEditorElement;
+        case "honua-feature-editor":
+            return kit.HonuaFeatureEditorElement;
+        case "honua-feature-table":
+            return kit.HonuaFeatureTableElement;
+        case "honua-bookmarks":
+            return kit.HonuaBookmarksElement;
+        case "honua-basemap-control":
+            return kit.HonuaBasemapControlElement;
+        case "honua-locate-control":
+            return kit.HonuaLocateControlElement;
+        case "honua-sketch-control":
+            return kit.HonuaSketchControlElement;
+        case "honua-print-export":
+            return kit.HonuaPrintExportElement;
+        case "honua-feature-inspection":
+            return kit.HonuaFeatureInspectionElement;
+        case "honua-zoom":
+            return kit.HonuaZoomElement;
+        case "honua-home":
+            return kit.HonuaHomeElement;
+        case "honua-scale-bar":
+            return kit.HonuaScaleBarElement;
+        case "honua-compass":
+            return kit.HonuaCompassElement;
+        case "honua-fullscreen":
+            return kit.HonuaFullscreenElement;
+        case "honua-attribution":
+            return kit.HonuaAttributionElement;
+        case "honua-feature-pager":
+            return kit.HonuaFeaturePagerElement;
+        case "honua-attachments":
+            return kit.HonuaAttachmentsElement;
+        case "honua-scale-range":
+            return kit.HonuaScaleRangeElement;
+        case "honua-directions":
+            return kit.HonuaDirectionsElement;
+        case "honua-chart":
+            return kit.HonuaChartElement;
         default:
             return undefined;
     }

package/esri-compat/widget-shell-hosts.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Compat hosts for the feature pager, attachment list, and scale range.
+ * They push shim state into the kit and do not build their own widget DOM.
+ */
+import type { CompatEventBus } from "./event-bus.js";
+export declare class FeaturesCompat {
+    readonly view: unknown;
+    readonly container: unknown;
+    features: readonly unknown[];
+    private widgetHost;
+    constructor(options?: {
+        view?: unknown;
+        container?: unknown;
+        features?: readonly unknown[];
+        eventBus?: CompatEventBus;
+    });
+    setFeatures(features: readonly unknown[]): void;
+    private push;
+}
+export declare function attachmentNamesFromQuery(response: {
+    attachmentInfos?: readonly {
+        name?: string;
+    }[];
+    attachmentGroups?: readonly {
+        attachmentInfos?: readonly {
+            name?: string;
+        }[];
+    }[];
+}): string[];
+export declare class AttachmentsCompat {
+    readonly container: unknown;
+    readonly layer: {
+        queryAttachments?: (options?: unknown) => Promise<Parameters<typeof attachmentNamesFromQuery>[0]>;
+    } | undefined;
+    names: readonly string[];
+    private widgetHost;
+    constructor(options?: {
+        container?: unknown;
+        layer?: AttachmentsCompat["layer"];
+        names?: readonly string[];
+        eventBus?: CompatEventBus;
+    });
+    load(): Promise<readonly string[]>;
+    private push;
+}
+export declare class ScaleRangeCompat {
+    readonly container: unknown;
+    readonly layer: {
+        minScale?: number;
+        maxScale?: number;
+        setScaleRange?: (min: number, max: number) => void;
+    } | undefined;
+    private widgetHost;
+    constructor(options?: {
+        container?: unknown;
+        layer?: ScaleRangeCompat["layer"];
+        eventBus?: CompatEventBus;
+    });
+    private push;
+}
+//# sourceMappingURL=widget-shell-hosts.d.ts.map

package/esri-compat/widget-shell-hosts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-shell-hosts.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/widget-shell-hosts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGrD,qBAAa,cAAc;IACzB,SAAgB,IAAI,EAAE,OAAO,CAAC;IAC9B,SAAgB,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IACpC,OAAO,CAAC,UAAU,CAA8B;gBAG9C,OAAO,GAAE;QACP,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,QAAQ,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;QAC9B,QAAQ,CAAC,EAAE,cAAc,CAAC;KACtB;IASD,WAAW,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI;IAKtD,OAAO,CAAC,IAAI;CAGb;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE;IACjD,eAAe,CAAC,EAAE,SAAS;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC/C,gBAAgB,CAAC,EAAE,SAAS;QAAE,eAAe,CAAC,EAAE,SAAS;YAAE,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAAE,EAAE,CAAC;CAClF,GAAG,MAAM,EAAE,CAWX;AAED,qBAAa,iBAAiB;IAC5B,SAAgB,SAAS,EAAE,OAAO,CAAC;IACnC,SAAgB,KAAK,EACjB;QAAE,gBAAgB,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GACrG,SAAS,CAAC;IACP,KAAK,EAAE,SAAS,MAAM,EAAE,CAAM;IACrC,OAAO,CAAC,UAAU,CAA8B;gBAG9C,OAAO,GAAE;QACP,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,KAAK,CAAC,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;QACnC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC1B,QAAQ,CAAC,EAAE,cAAc,CAAC;KACtB;IASK,IAAI,IAAI,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC;IAQ/C,OAAO,CAAC,IAAI;CAGb;AAED,qBAAa,gBAAgB;IAC3B,SAAgB,SAAS,EAAE,OAAO,CAAC;IACnC,SAAgB,KAAK,EACjB;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,GAC5F,SAAS,CAAC;IACd,OAAO,CAAC,UAAU,CAA8B;gBAG9C,OAAO,GAAE;QACP,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAClC,QAAQ,CAAC,EAAE,cAAc,CAAC;KACtB;IAQR,OAAO,CAAC,IAAI;CAGb"}

package/esri-compat/widget-shell-hosts.js

@@ -0,0 +1,76 @@
+/**
+ * Compat hosts for the feature pager, attachment list, and scale range.
+ * They push shim state into the kit and do not build their own widget DOM.
+ */
+import { bindHonuaWidgetHost, pushWidgetHostState } from "./widget-host.js";
+export class FeaturesCompat {
+    view;
+    container;
+    features;
+    widgetHost;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.container = options.container;
+        this.features = options.features ?? [];
+        this.widgetHost = bindHonuaWidgetHost("honua-feature-pager", this.container, options.eventBus);
+        this.push();
+    }
+    setFeatures(features) {
+        this.features = features;
+        this.push();
+    }
+    push() {
+        pushWidgetHostState(this.widgetHost, { view: this.view, features: this.features });
+    }
+}
+export function attachmentNamesFromQuery(response) {
+    const names = [];
+    for (const info of response.attachmentInfos ?? []) {
+        if (info.name)
+            names.push(info.name);
+    }
+    for (const group of response.attachmentGroups ?? []) {
+        for (const info of group.attachmentInfos ?? []) {
+            if (info.name)
+                names.push(info.name);
+        }
+    }
+    return names;
+}
+export class AttachmentsCompat {
+    container;
+    layer;
+    names = [];
+    widgetHost;
+    constructor(options = {}) {
+        this.container = options.container;
+        this.layer = options.layer;
+        this.names = options.names ?? [];
+        this.widgetHost = bindHonuaWidgetHost("honua-attachments", this.container, options.eventBus);
+        this.push();
+    }
+    async load() {
+        if (this.layer?.queryAttachments) {
+            this.names = attachmentNamesFromQuery(await this.layer.queryAttachments());
+        }
+        this.push();
+        return this.names;
+    }
+    push() {
+        pushWidgetHostState(this.widgetHost, { names: this.names });
+    }
+}
+export class ScaleRangeCompat {
+    container;
+    layer;
+    widgetHost;
+    constructor(options = {}) {
+        this.container = options.container;
+        this.layer = options.layer;
+        this.widgetHost = bindHonuaWidgetHost("honua-scale-range", this.container, options.eventBus);
+        this.push();
+    }
+    push() {
+        pushWidgetHostState(this.widgetHost, { layer: this.layer });
+    }
+}

package/index.d.ts

@@ -137,6 +137,8 @@ export { EditorCompat } from "./esri-compat/editor.js";
 export type { EditorHandleCompat, EditorLoadStatusCompat, EditorCompatOptions, EditorLayerInfoCompat, EditorWorkflowCompat, } from "./esri-compat/editor.js";
 export { snappingOptionsToSnappingConfig } from "./esri-compat/snapping.js";
 export type { SnappingFeatureSourceCompat, SnappingOptionsCompat } from "./esri-compat/snapping.js";
+export { FeatureEffectCompat } from "./esri-compat/feature-effect.js";
+export type { FeatureEffectCompatOptions } from "./esri-compat/feature-effect.js";
 export { FeatureFilterCompat } from "./esri-compat/feature-filter.js";
 export type { FeatureFilterCompatOptions, FeatureFilterEsriProperties, FeatureFilterGeometryCompat, FeatureFilterHandleCompat, FeatureFilterLoadStatusCompat, FeatureFilterSpatialRelationshipCompat, FeatureFilterTimeExtentCompat, } from "./esri-compat/feature-filter.js";
 export { VectorTileLayerCompat } from "./esri-compat/vector-tile-layer.js";
@@ -151,4 +153,4 @@ export { ImageryLayerCompat } from "./esri-compat/imagery-layer.js";
 export type { ImageryLayerCompatOptions, ImageryLayerExportOptions, ImageryLayerHandleCompat, ImageryLayerIdentifyOptions, ImageryLayerLoadStatusCompat, ImageryLayerQueryOptions, } from "./esri-compat/imagery-layer.js";
 export { buffer as geometryEngineBuffer, contains as geometryEngineContains, convexHull as geometryEngineConvexHull, difference as geometryEngineDifference, geodesicArea as geometryEngineGeodesicArea, geodesicLength as geometryEngineGeodesicLength, geometryEngineAsyncCompat, geometryEngineCompat, intersect as geometryEngineIntersect, intersects as geometryEngineIntersects, planarArea as geometryEnginePlanarArea, planarLength as geometryEnginePlanarLength, simplify as geometryEngineSimplify, union as geometryEngineUnion, } from "./esri-compat/geometry-engine.js";
 export type { EsriAreaUnit, EsriLinearUnit, GeometryEngineInput, } from "./esri-compat/geometry-engine.js";
-//# sourceMappingURL=esri-compat-entry.d.ts.map
+//# sourceMappingURL=client-compat-entry.d.ts.map

package/index.js

@@ -69,6 +69,7 @@ export { TableListCompat } from "./esri-compat/table-list.js";
 export { SketchCompat, resolveSketchToolBindingCompat } from "./esri-compat/sketch.js";
 export { EditorCompat } from "./esri-compat/editor.js";
 export { snappingOptionsToSnappingConfig } from "./esri-compat/snapping.js";
+export { FeatureEffectCompat } from "./esri-compat/feature-effect.js";
 export { FeatureFilterCompat } from "./esri-compat/feature-filter.js";
 export { VectorTileLayerCompat } from "./esri-compat/vector-tile-layer.js";
 export { GeoJSONLayerCompat } from "./esri-compat/geojson-layer.js";

package/offline/digest.d.ts

@@ -0,0 +1,15 @@
+/** Code-unit ordering, the deterministic sort used by every persisted identity. */
+export declare function compareCodeUnits(left: string, right: string): number;
+/**
+ * Serialize `value` with sorted own keys and no `undefined` members.
+ *
+ * The output is the digest pre-image for region and resource identity, so it is
+ * deliberately strict: an `undefined` anywhere would silently disappear from the
+ * identity and let two different selections collide.
+ */
+export declare function canonicalJson(value: unknown): string;
+/** Portable Web Crypto SHA-256 over UTF-8 text or raw bytes. */
+export declare function sha256(value: string | Uint8Array): Promise<`sha256:${string}`>;
+/** Domain-separated digest of a canonical identity object. */
+export declare function identityDigest(namespace: string, value: unknown): Promise<`sha256:${string}`>;
+//# sourceMappingURL=digest.d.ts.map

package/offline/digest.js

@@ -0,0 +1,58 @@
+import { HonuaOfflineRegionError } from "./types.js";
+/**
+ * Deterministic identity primitives shared by every offline module.
+ *
+ * Manifest identity, snapshot resource identity, and the read path all have to
+ * agree byte-for-byte on what "the same selection" means, so the canonical
+ * serialization and the digest live in one module rather than being reimplemented
+ * per layer. Nothing here reads storage or accepts a request URL.
+ */
+const encoder = new TextEncoder();
+/** Code-unit ordering, the deterministic sort used by every persisted identity. */
+export function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+/**
+ * Serialize `value` with sorted own keys and no `undefined` members.
+ *
+ * The output is the digest pre-image for region and resource identity, so it is
+ * deliberately strict: an `undefined` anywhere would silently disappear from the
+ * identity and let two different selections collide.
+ */
+export function canonicalJson(value) {
+    if (value === null || typeof value !== "object") {
+        const encoded = JSON.stringify(value);
+        if (encoded === undefined) {
+            throw new HonuaOfflineRegionError("invalid-manifest", "Offline identity cannot contain undefined values.", {
+                path: "identity",
+            });
+        }
+        return encoded;
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    const entries = [];
+    for (const key in value) {
+        if (Object.hasOwn(value, key))
+            entries.push([key, value[key]]);
+    }
+    entries.sort(([left], [right]) => compareCodeUnits(left, right));
+    return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`).join(",")}}`;
+}
+/** Portable Web Crypto SHA-256 over UTF-8 text or raw bytes. */
+export async function sha256(value) {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+        throw new HonuaOfflineRegionError("invalid-manifest", "Offline region identity and integrity require Web Crypto SHA-256.", { path: "crypto" });
+    }
+    const bytes = typeof value === "string" ? encoder.encode(value) : value;
+    const digestInput = bytes.buffer instanceof ArrayBuffer
+        ? bytes
+        : Uint8Array.from(bytes);
+    const digest = await subtle.digest("SHA-256", digestInput);
+    return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+/** Domain-separated digest of a canonical identity object. */
+export async function identityDigest(namespace, value) {
+    return sha256(`${namespace}:v1:${canonicalJson(value)}`);
+}