@honua/react 0.0.20-alpha.0

package/esri-compat/layer-list.js

@@ -0,0 +1,342 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener, } from "./event-bus.js";
+export class LayerListCompat {
+    view;
+    map;
+    container;
+    eventBus;
+    includeHidden;
+    loaded;
+    loadStatus;
+    items;
+    autoRefresh;
+    listItemCreatedFunction;
+    listenersByType;
+    watchListeners;
+    subscriptions;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.map = options.map ?? extractMapFromView(options.view);
+        this.container = options.container;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(this.view, this.map) ?? new CompatEventBus();
+        this.includeHidden = options.includeHidden ?? false;
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.autoRefresh = options.autoRefresh ?? true;
+        this.listItemCreatedFunction = options.listItemCreatedFunction;
+        this.items = [];
+        this.listenersByType = new Map();
+        this.watchListeners = new Map();
+        this.subscriptions = [];
+        if (this.autoRefresh) {
+            this.subscriptions.push(this.eventBus.on("map.layer-added", () => this.refresh()));
+            this.subscriptions.push(this.eventBus.on("map.layer-removed", () => this.refresh()));
+            this.subscriptions.push(this.eventBus.on("map.layers-added", () => this.refresh()));
+            this.subscriptions.push(this.eventBus.on("map.layers-cleared", () => this.refresh()));
+            this.subscriptions.push(this.eventBus.on("map.layer-reordered", () => this.refresh()));
+            this.subscriptions.push(this.eventBus.on("group-layer.layer-added", () => this.refresh()));
+            this.subscriptions.push(this.eventBus.on("group-layer.layer-removed", () => this.refresh()));
+            this.subscriptions.push(this.eventBus.on("group-layer.layers-added", () => this.refresh()));
+            this.subscriptions.push(this.eventBus.on("group-layer.layers-cleared", () => this.refresh()));
+            this.subscriptions.push(this.eventBus.on("layer.visibility-changed", () => this.refresh()));
+        }
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("layer-list.loading", undefined, this);
+        this.refresh();
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("layer-list.loaded", { itemCount: this.items.length }, this);
+        return this;
+    }
+    async when(callback) {
+        const widget = await this.load();
+        if (callback) {
+            callback(widget);
+        }
+        return widget;
+    }
+    watch(propertyName, listener) {
+        let listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            listeners = new Set();
+            this.watchListeners.set(propertyName, listeners);
+        }
+        listeners.add(listener);
+        return {
+            remove: () => {
+                listeners?.delete(listener);
+            },
+        };
+    }
+    refresh() {
+        const rootLayers = getRootLayers(this.map);
+        this.items = rootLayers
+            .map((layer, index) => toLayerListItem(layer, this.includeHidden, index))
+            .filter((item) => item !== undefined);
+        if (this.listItemCreatedFunction) {
+            for (const item of this.items) {
+                applyListItemCreated(item, this.listItemCreatedFunction);
+            }
+        }
+        this.notifyWatchers("items", this.items);
+        const updateEvent = { itemCount: this.items.length };
+        this.eventBus.emit("layer-list.updated", updateEvent, this);
+        this.emit("updated", updateEvent);
+        return this.items;
+    }
+    toggle(layerOrId, visible) {
+        const layer = this.findLayer(layerOrId);
+        if (!layer || !isLayerLike(layer)) {
+            return false;
+        }
+        const nextVisible = visible ?? !toVisible(layer);
+        if (hasSetVisibility(layer)) {
+            layer.setVisibility(nextVisible);
+        }
+        else {
+            layer.visible = nextVisible;
+            this.eventBus.emit("layer.visibility-changed", { layerId: layer.id, visible: nextVisible }, this);
+        }
+        this.refresh();
+        return true;
+    }
+    setItemActions(layerOrId, actionsSections) {
+        const item = this.findItem(layerOrId);
+        if (!item) {
+            return false;
+        }
+        item.actionsSections = normalizeActionSections(actionsSections);
+        this.notifyWatchers("items", this.items);
+        const updateEvent = { itemCount: this.items.length };
+        this.eventBus.emit("layer-list.updated", updateEvent, this);
+        this.emit("updated", updateEvent);
+        return true;
+    }
+    triggerAction(actionId, layerOrId) {
+        const item = layerOrId === undefined ? this.items[0] : this.findItem(layerOrId);
+        if (!item) {
+            return false;
+        }
+        const action = findActionById(item.actionsSections, actionId);
+        if (!action) {
+            return false;
+        }
+        const event = {
+            action,
+            actionId: action.id,
+            item,
+            layer: item.layer,
+        };
+        this.eventBus.emit("layer-list.trigger-action", event, this);
+        this.emit("trigger-action", event);
+        return true;
+    }
+    on(type, listener) {
+        let listeners = this.listenersByType.get(type);
+        if (!listeners) {
+            listeners = new Set();
+            this.listenersByType.set(type, listeners);
+        }
+        const untypedListener = listener;
+        listeners.add(untypedListener);
+        return {
+            remove: () => {
+                listeners?.delete(untypedListener);
+            },
+        };
+    }
+    destroy() {
+        for (const subscription of this.subscriptions.splice(0)) {
+            subscription.remove();
+        }
+        this.listenersByType.clear();
+        this.watchListeners.clear();
+    }
+    findLayer(layerOrId) {
+        const rootLayers = getRootLayers(this.map);
+        if (typeof layerOrId !== "string" && typeof layerOrId !== "number") {
+            return findLayerByReference(rootLayers, layerOrId);
+        }
+        return findLayerById(rootLayers, layerOrId);
+    }
+    findItem(layerOrId) {
+        if (typeof layerOrId !== "string" && typeof layerOrId !== "number") {
+            return findItemByLayer(this.items, layerOrId);
+        }
+        return findItemById(this.items, layerOrId);
+    }
+    emit(type, event) {
+        const listeners = this.listenersByType.get(type);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            try {
+                safeInvokeCompatListener(listener, event);
+            }
+            catch {
+                // Listener errors should not break widget compatibility flow.
+            }
+        }
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function extractMapFromView(view) {
+    if (!isRecord(view)) {
+        return undefined;
+    }
+    return view.map;
+}
+function getRootLayers(map) {
+    if (!isRecord(map) || !Array.isArray(map.layers)) {
+        return [];
+    }
+    return [...map.layers];
+}
+function toLayerListItem(layer, includeHidden, index) {
+    if (!isLayerLike(layer)) {
+        return undefined;
+    }
+    if (!includeHidden && !toVisible(layer)) {
+        return undefined;
+    }
+    const children = getChildLayers(layer)
+        .map((child, childIndex) => toLayerListItem(child, includeHidden, childIndex))
+        .filter((item) => item !== undefined);
+    return {
+        id: layer.id,
+        title: toLayerTitle(layer, index),
+        visible: toVisible(layer),
+        layer,
+        actionsSections: [],
+        children,
+    };
+}
+function applyListItemCreated(item, callback) {
+    callback({ item });
+    for (const child of item.children) {
+        applyListItemCreated(child, callback);
+    }
+}
+function normalizeActionSections(actionsSections) {
+    return actionsSections.map((section) => section
+        .filter((action) => typeof action.id === "string" && action.id.trim().length > 0)
+        .map((action) => ({ ...action })));
+}
+function findActionById(actionsSections, actionId) {
+    for (const section of actionsSections) {
+        for (const action of section) {
+            if (action.id === actionId) {
+                return action;
+            }
+        }
+    }
+    return undefined;
+}
+function findItemByLayer(items, layer) {
+    for (const item of items) {
+        if (item.layer === layer) {
+            return item;
+        }
+        const nested = findItemByLayer(item.children, layer);
+        if (nested) {
+            return nested;
+        }
+    }
+    return undefined;
+}
+function findItemById(items, id) {
+    const normalizedId = String(id);
+    for (const item of items) {
+        if (item.id !== undefined && String(item.id) === normalizedId) {
+            return item;
+        }
+        const nested = findItemById(item.children, id);
+        if (nested) {
+            return nested;
+        }
+    }
+    return undefined;
+}
+function findLayerByReference(layers, target) {
+    for (const layer of layers) {
+        if (layer === target) {
+            return layer;
+        }
+        const nested = findLayerByReference(getChildLayers(layer), target);
+        if (nested !== undefined) {
+            return nested;
+        }
+    }
+    return undefined;
+}
+function findLayerById(layers, id) {
+    const normalizedId = String(id);
+    for (const layer of layers) {
+        if (isLayerLike(layer) && layer.id !== undefined && String(layer.id) === normalizedId) {
+            return layer;
+        }
+        const nested = findLayerById(getChildLayers(layer), id);
+        if (nested !== undefined) {
+            return nested;
+        }
+    }
+    return undefined;
+}
+function isLayerLike(value) {
+    return typeof value === "object" && value !== null;
+}
+function hasSetVisibility(value) {
+    if (!isLayerLike(value)) {
+        return false;
+    }
+    return typeof value.setVisibility === "function";
+}
+function getChildLayers(layer) {
+    if (!isRecord(layer)) {
+        return [];
+    }
+    if (Array.isArray(layer.layers)) {
+        return [...layer.layers];
+    }
+    if (Array.isArray(layer.allSublayers)) {
+        return [...layer.allSublayers];
+    }
+    if (Array.isArray(layer.sublayers)) {
+        return [...layer.sublayers];
+    }
+    return [];
+}
+function toLayerTitle(layer, index) {
+    if (typeof layer.title === "string" && layer.title.trim().length > 0) {
+        return layer.title;
+    }
+    if (typeof layer.id === "string" && layer.id.trim().length > 0) {
+        return layer.id;
+    }
+    if (typeof layer.id === "number" && Number.isFinite(layer.id)) {
+        return String(layer.id);
+    }
+    return `Layer ${index + 1}`;
+}
+function toVisible(layer) {
+    return layer.visible ?? true;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/esri-compat/legend.d.ts

@@ -0,0 +1,53 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface LegendCompatOptions {
+    view?: unknown;
+    map?: unknown;
+    layers?: readonly unknown[];
+    container?: unknown;
+    eventBus?: CompatEventBus;
+    includeHidden?: boolean;
+    autoRefresh?: boolean;
+}
+export interface LegendItemCompat {
+    layerId: number | undefined;
+    layerName: string | undefined;
+    label: string;
+    imageData: string | undefined;
+    contentType: string | undefined;
+    width: number | undefined;
+    height: number | undefined;
+}
+export interface LegendLayerGroupCompat {
+    layer: unknown;
+    title: string;
+    entries: LegendItemCompat[];
+}
+export type LegendLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface LegendHandleCompat {
+    remove(): void;
+}
+export declare class LegendCompat {
+    readonly view: unknown;
+    readonly map: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    readonly includeHidden: boolean;
+    loaded: boolean;
+    loadStatus: LegendLoadStatusCompat;
+    items: LegendLayerGroupCompat[];
+    private readonly explicitLayers;
+    private readonly autoRefresh;
+    private readonly watchListeners;
+    private subscriptions;
+    private refreshRevision;
+    constructor(options?: LegendCompatOptions);
+    load(): Promise<LegendCompat>;
+    when(callback?: (widget: LegendCompat) => void): Promise<LegendCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): LegendHandleCompat;
+    refresh(): Promise<readonly LegendLayerGroupCompat[]>;
+    destroy(): void;
+    private resolveLegendLayers;
+    private nextRefreshRevision;
+    private notifyWatchers;
+}
+//# sourceMappingURL=legend.d.ts.map

package/esri-compat/legend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legend.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/legend.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAIf,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC5B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED,MAAM,MAAM,sBAAsB,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEzE,MAAM,WAAW,kBAAkB;IACjC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,YAAY;IACvB,SAAgB,IAAI,EAAE,OAAO,CAAC;IAC9B,SAAgB,GAAG,EAAE,OAAO,CAAC;IAC7B,SAAgB,SAAS,EAAE,OAAO,CAAC;IACnC,SAAgB,QAAQ,EAAE,cAAc,CAAC;IACzC,SAAgB,aAAa,EAAE,OAAO,CAAC;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,sBAAsB,CAAC;IACnC,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAEvC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiC;IAChE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAU;IACtC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;IAC5E,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,eAAe,CAAS;gBAEb,OAAO,GAAE,mBAAwB;IA+BvC,IAAI,IAAI,OAAO,CAAC,YAAY,CAAC;IAiB7B,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC;IAQ5E,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,kBAAkB;IAe7E,OAAO,IAAI,OAAO,CAAC,SAAS,sBAAsB,EAAE,CAAC;IAoC3D,OAAO,IAAI,IAAI;IAOtB,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,mBAAmB;IAK3B,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/legend.js

@@ -0,0 +1,254 @@
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener, } from "./event-bus.js";
+export class LegendCompat {
+    view;
+    map;
+    container;
+    eventBus;
+    includeHidden;
+    loaded;
+    loadStatus;
+    items;
+    explicitLayers;
+    autoRefresh;
+    watchListeners;
+    subscriptions;
+    refreshRevision;
+    constructor(options = {}) {
+        this.view = options.view;
+        this.map = options.map ?? extractMapFromView(options.view);
+        this.container = options.container;
+        this.explicitLayers = options.layers;
+        this.eventBus =
+            options.eventBus ?? resolveCompatEventBus(this.view, this.map, options.layers) ?? new CompatEventBus();
+        this.includeHidden = options.includeHidden ?? false;
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.autoRefresh = options.autoRefresh ?? true;
+        this.items = [];
+        this.watchListeners = new Map();
+        this.subscriptions = [];
+        this.refreshRevision = 0;
+        if (this.autoRefresh) {
+            this.subscriptions.push(this.eventBus.on("map.layer-added", () => void this.refresh()));
+            this.subscriptions.push(this.eventBus.on("map.layer-removed", () => void this.refresh()));
+            this.subscriptions.push(this.eventBus.on("map.layers-added", () => void this.refresh()));
+            this.subscriptions.push(this.eventBus.on("map.layers-cleared", () => void this.refresh()));
+            this.subscriptions.push(this.eventBus.on("map.layer-reordered", () => void this.refresh()));
+            this.subscriptions.push(this.eventBus.on("group-layer.layer-added", () => void this.refresh()));
+            this.subscriptions.push(this.eventBus.on("group-layer.layer-removed", () => void this.refresh()));
+            this.subscriptions.push(this.eventBus.on("group-layer.layers-added", () => void this.refresh()));
+            this.subscriptions.push(this.eventBus.on("group-layer.layers-cleared", () => void this.refresh()));
+            this.subscriptions.push(this.eventBus.on("layer.visibility-changed", () => void this.refresh()));
+            this.subscriptions.push(this.eventBus.on("layer.legend-updated", () => void this.refresh()));
+        }
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("legend.loading", undefined, this);
+        await this.refresh();
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("legend.loaded", { layerCount: this.items.length }, this);
+        return this;
+    }
+    async when(callback) {
+        const widget = await this.load();
+        if (callback) {
+            callback(widget);
+        }
+        return widget;
+    }
+    watch(propertyName, listener) {
+        let listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            listeners = new Set();
+            this.watchListeners.set(propertyName, listeners);
+        }
+        listeners.add(listener);
+        return {
+            remove: () => {
+                listeners?.delete(listener);
+            },
+        };
+    }
+    async refresh() {
+        const refreshRevision = this.nextRefreshRevision();
+        const layers = this.resolveLegendLayers();
+        const groups = [];
+        for (const layer of layers) {
+            if (!this.includeHidden && !isLayerVisible(layer)) {
+                continue;
+            }
+            let entries;
+            try {
+                entries = await extractLegendEntries(layer);
+            }
+            catch (error) {
+                this.eventBus.emit("legend.layer-failed", { layer, error }, this);
+                continue;
+            }
+            if (entries.length === 0) {
+                continue;
+            }
+            groups.push({
+                layer,
+                title: toLayerTitle(layer, groups.length),
+                entries,
+            });
+        }
+        if (refreshRevision !== this.refreshRevision) {
+            return this.items;
+        }
+        this.items = groups;
+        this.notifyWatchers("items", this.items);
+        this.eventBus.emit("legend.updated", { layerCount: groups.length }, this);
+        return this.items;
+    }
+    destroy() {
+        for (const subscription of this.subscriptions.splice(0)) {
+            subscription.remove();
+        }
+        this.watchListeners.clear();
+    }
+    resolveLegendLayers() {
+        if (this.explicitLayers) {
+            return [...this.explicitLayers];
+        }
+        return getAllLegendLayers(this.map);
+    }
+    nextRefreshRevision() {
+        this.refreshRevision += 1;
+        return this.refreshRevision;
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+async function extractLegendEntries(layer) {
+    const response = await callLegendProvider(layer);
+    if (!isRecord(response) || !Array.isArray(response.layers)) {
+        return [];
+    }
+    const entries = [];
+    for (const layerEntry of response.layers) {
+        if (!isRecord(layerEntry) || !Array.isArray(layerEntry.legend)) {
+            continue;
+        }
+        for (const legendEntry of layerEntry.legend) {
+            if (!isRecord(legendEntry)) {
+                continue;
+            }
+            const label = typeof legendEntry.label === "string" ? legendEntry.label : "Legend";
+            entries.push({
+                layerId: toOptionalNumber(layerEntry.layerId),
+                layerName: toOptionalString(layerEntry.layerName),
+                label,
+                imageData: toOptionalString(legendEntry.imageData),
+                contentType: toOptionalString(legendEntry.contentType),
+                width: toOptionalNumber(legendEntry.width),
+                height: toOptionalNumber(legendEntry.height),
+            });
+        }
+    }
+    return entries;
+}
+async function callLegendProvider(layer) {
+    if (hasMethod(layer, "getLegend")) {
+        return layer.getLegend();
+    }
+    if (hasMethod(layer, "legend")) {
+        return layer.legend();
+    }
+    return undefined;
+}
+function extractMapFromView(view) {
+    if (!isRecord(view)) {
+        return undefined;
+    }
+    return view.map;
+}
+function getRootLayers(map) {
+    if (!isRecord(map) || !Array.isArray(map.layers)) {
+        return [];
+    }
+    return [...map.layers];
+}
+function getAllLegendLayers(map) {
+    if (!isRecord(map)) {
+        return [];
+    }
+    const candidates = Array.isArray(map.allLayers) ? map.allLayers : getRootLayers(map);
+    const layers = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        collectLegendLayer(candidate, layers, seen);
+    }
+    return layers;
+}
+function collectLegendLayer(layer, layers, seen) {
+    if (seen.has(layer)) {
+        return;
+    }
+    seen.add(layer);
+    layers.push(layer);
+    for (const child of getChildLayers(layer)) {
+        collectLegendLayer(child, layers, seen);
+    }
+}
+function getChildLayers(layer) {
+    if (!isRecord(layer)) {
+        return [];
+    }
+    if (Array.isArray(layer.layers)) {
+        return [...layer.layers];
+    }
+    if (Array.isArray(layer.allSublayers)) {
+        return [...layer.allSublayers];
+    }
+    if (Array.isArray(layer.sublayers)) {
+        return [...layer.sublayers];
+    }
+    return [];
+}
+function isLayerVisible(layer) {
+    if (!isRecord(layer) || typeof layer.visible !== "boolean") {
+        return true;
+    }
+    return layer.visible;
+}
+function toLayerTitle(layer, index) {
+    if (!isRecord(layer)) {
+        return `Layer ${index + 1}`;
+    }
+    if (typeof layer.title === "string" && layer.title.trim().length > 0) {
+        return layer.title;
+    }
+    if (typeof layer.id === "string" && layer.id.trim().length > 0) {
+        return layer.id;
+    }
+    return `Layer ${index + 1}`;
+}
+function hasMethod(value, methodName) {
+    return isRecord(value) && typeof value[methodName] === "function";
+}
+function toOptionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function toOptionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}