@honua/sdk-esri-compat 0.0.6-alpha.0

package/esri-compat/identity-manager.js

@@ -0,0 +1,115 @@
+import { OAuthInfoCompat } from "./oauth-info.js";
+class IdentityManagerCompatStore {
+    oauthInfosInternal;
+    credentialsInternal;
+    constructor() {
+        this.oauthInfosInternal = [];
+        this.credentialsInternal = [];
+    }
+    get oauthInfos() {
+        return this.oauthInfosInternal.map((info) => info.clone());
+    }
+    get credentials() {
+        return this.credentialsInternal.map((credential) => ({ ...credential }));
+    }
+    registerOAuthInfos(infos) {
+        this.oauthInfosInternal.length = 0;
+        for (const info of infos) {
+            this.oauthInfosInternal.push(info instanceof OAuthInfoCompat ? info.clone() : new OAuthInfoCompat(info));
+        }
+    }
+    registerToken(token) {
+        const next = {
+            server: token.server,
+            token: token.token,
+            expires: typeof token.expires === "number" && Number.isFinite(token.expires) ? token.expires : undefined,
+            userId: token.userId,
+        };
+        const deduped = [];
+        let replaced = false;
+        for (const existing of this.credentialsInternal) {
+            if (isSameCredentialServer(existing.server, next.server)) {
+                if (!replaced) {
+                    deduped.push(next);
+                    replaced = true;
+                }
+                continue;
+            }
+            deduped.push(existing);
+        }
+        if (!replaced) {
+            deduped.push(next);
+        }
+        this.credentialsInternal.length = 0;
+        this.credentialsInternal.push(...deduped);
+    }
+    findCredential(url) {
+        const match = this.findCredentialEntry(url);
+        if (!match || isCredentialExpired(match)) {
+            return undefined;
+        }
+        return { ...match };
+    }
+    async checkSignInStatus(url) {
+        const credential = this.findCredentialEntry(url);
+        if (!credential) {
+            throw new Error("No registered credential for requested server.");
+        }
+        if (isCredentialExpired(credential)) {
+            throw new Error("Registered credential for requested server has expired.");
+        }
+        return { ...credential };
+    }
+    async getCredential(url) {
+        return this.checkSignInStatus(url);
+    }
+    destroyCredentials() {
+        this.credentialsInternal.length = 0;
+    }
+    reset() {
+        this.oauthInfosInternal.length = 0;
+        this.credentialsInternal.length = 0;
+    }
+    findCredentialEntry(url) {
+        const normalized = normalizeServerUrl(url);
+        if (!normalized) {
+            return undefined;
+        }
+        for (let index = this.credentialsInternal.length - 1; index >= 0; index -= 1) {
+            const credential = this.credentialsInternal[index];
+            if (!credential) {
+                continue;
+            }
+            const server = normalizeServerUrl(credential.server);
+            if (!server) {
+                continue;
+            }
+            if (normalized === server || normalized.startsWith(`${server}/`)) {
+                return credential;
+            }
+        }
+        return undefined;
+    }
+}
+export const identityManager = new IdentityManagerCompatStore();
+function normalizeServerUrl(value) {
+    try {
+        const url = new URL(value);
+        const pathname = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
+        return `${url.protocol}//${url.host}${pathname}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isCredentialExpired(credential) {
+    return (typeof credential.expires === "number" && Number.isFinite(credential.expires) && credential.expires <= Date.now());
+}
+function isSameCredentialServer(left, right) {
+    const leftNormalized = normalizeServerUrl(left);
+    const rightNormalized = normalizeServerUrl(right);
+    if (leftNormalized && rightNormalized) {
+        return leftNormalized === rightNormalized;
+    }
+    return left === right;
+}

package/esri-compat/label-class.d.ts

@@ -0,0 +1,31 @@
+export interface LabelClassCompatOptions {
+    labelExpressionInfo?: unknown;
+    symbol?: unknown;
+    where?: string;
+    minScale?: number;
+    maxScale?: number;
+}
+export type LabelClassLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface LabelClassHandleCompat {
+    remove(): void;
+}
+export declare class LabelClassCompat {
+    loaded: boolean;
+    loadStatus: LabelClassLoadStatusCompat;
+    labelExpressionInfo: unknown;
+    symbol: unknown;
+    where: string | undefined;
+    minScale: number | undefined;
+    maxScale: number | undefined;
+    private readonly watchListeners;
+    constructor(options?: LabelClassCompatOptions);
+    load(): Promise<LabelClassCompat>;
+    when(callback?: (labelClass: LabelClassCompat) => void): Promise<LabelClassCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): LabelClassHandleCompat;
+    update(options: LabelClassCompatOptions): void;
+    clone(): LabelClassCompat;
+    toJSON(): LabelClassCompatOptions;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=label-class.d.ts.map

package/esri-compat/label-class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"label-class.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/label-class.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,uBAAuB;IACtC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,0BAA0B,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE7E,MAAM,WAAW,sBAAsB;IACrC,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,qBAAa,gBAAgB;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,0BAA0B,CAAC;IACvC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6C;gBAEzD,OAAO,GAAE,uBAA4B;IAW3C,IAAI,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAcjC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,gBAAgB,KAAK,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAQxF,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,sBAAsB;IAevF,MAAM,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI;IAuB9C,KAAK,IAAI,gBAAgB;IAIzB,MAAM,IAAI,uBAAuB;IAUjC,OAAO,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;CAUvB"}

package/esri-compat/label-class.js

@@ -0,0 +1,102 @@
+import { safeInvokeCompatListener } from "./event-bus.js";
+export class LabelClassCompat {
+    loaded;
+    loadStatus;
+    labelExpressionInfo;
+    symbol;
+    where;
+    minScale;
+    maxScale;
+    watchListeners;
+    constructor(options = {}) {
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.labelExpressionInfo = options.labelExpressionInfo;
+        this.symbol = options.symbol;
+        this.where = options.where;
+        this.minScale = finiteNumberOrUndefined(options.minScale);
+        this.maxScale = finiteNumberOrUndefined(options.maxScale);
+        this.watchListeners = new Map();
+    }
+    async load() {
+        if (this.loaded) {
+            return this;
+        }
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.loaded = true;
+        this.notifyWatchers("loaded", this.loaded);
+        this.loadStatus = "loaded";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        return this;
+    }
+    async when(callback) {
+        const labelClass = await this.load();
+        if (callback) {
+            callback(labelClass);
+        }
+        return labelClass;
+    }
+    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);
+            },
+        };
+    }
+    update(options) {
+        if (options.labelExpressionInfo !== undefined) {
+            this.labelExpressionInfo = options.labelExpressionInfo;
+            this.notifyWatchers("labelExpressionInfo", this.labelExpressionInfo);
+        }
+        if (options.symbol !== undefined) {
+            this.symbol = options.symbol;
+            this.notifyWatchers("symbol", this.symbol);
+        }
+        if (options.where !== undefined) {
+            this.where = options.where;
+            this.notifyWatchers("where", this.where);
+        }
+        if (options.minScale !== undefined) {
+            this.minScale = finiteNumberOrUndefined(options.minScale);
+            this.notifyWatchers("minScale", this.minScale);
+        }
+        if (options.maxScale !== undefined) {
+            this.maxScale = finiteNumberOrUndefined(options.maxScale);
+            this.notifyWatchers("maxScale", this.maxScale);
+        }
+    }
+    clone() {
+        return new LabelClassCompat(this.toJSON());
+    }
+    toJSON() {
+        return {
+            labelExpressionInfo: this.labelExpressionInfo,
+            symbol: this.symbol,
+            where: this.where,
+            minScale: this.minScale,
+            maxScale: this.maxScale,
+        };
+    }
+    destroy() {
+        this.watchListeners.clear();
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            safeInvokeCompatListener(listener, value);
+        }
+    }
+}
+function finiteNumberOrUndefined(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}

package/esri-compat/layer-list.d.ts

@@ -0,0 +1,77 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface LayerListCompatOptions {
+    view?: unknown;
+    map?: unknown;
+    container?: unknown;
+    eventBus?: CompatEventBus;
+    includeHidden?: boolean;
+    autoRefresh?: boolean;
+    listItemCreatedFunction?: (event: LayerListListItemCreatedEventCompat) => void;
+}
+export interface LayerListActionCompat {
+    id: string;
+    title?: string;
+    className?: string;
+    icon?: string;
+    value?: unknown;
+}
+export interface LayerListItemCompat {
+    id: string | number | undefined;
+    title: string;
+    visible: boolean;
+    layer: unknown;
+    actionsSections: LayerListActionCompat[][];
+    children: LayerListItemCompat[];
+}
+export interface LayerListListItemCreatedEventCompat {
+    item: LayerListItemCompat;
+}
+export interface LayerListTriggerActionEventCompat {
+    action: LayerListActionCompat;
+    actionId: string;
+    item: LayerListItemCompat;
+    layer: unknown;
+}
+export interface LayerListUpdatedEventCompat {
+    itemCount: number;
+}
+export interface LayerListHandleCompat {
+    remove(): void;
+}
+export type LayerListLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+interface LayerListEventPayloadByType {
+    "trigger-action": LayerListTriggerActionEventCompat;
+    updated: LayerListUpdatedEventCompat;
+}
+type LayerListEventTypeCompat = keyof LayerListEventPayloadByType;
+export declare class LayerListCompat {
+    readonly view: unknown;
+    readonly map: unknown;
+    readonly container: unknown;
+    readonly eventBus: CompatEventBus;
+    readonly includeHidden: boolean;
+    loaded: boolean;
+    loadStatus: LayerListLoadStatusCompat;
+    items: LayerListItemCompat[];
+    private readonly autoRefresh;
+    private readonly listItemCreatedFunction;
+    private readonly listenersByType;
+    private readonly watchListeners;
+    private subscriptions;
+    constructor(options?: LayerListCompatOptions);
+    load(): Promise<LayerListCompat>;
+    when(callback?: (widget: LayerListCompat) => void): Promise<LayerListCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): LayerListHandleCompat;
+    refresh(): readonly LayerListItemCompat[];
+    toggle(layerOrId: unknown | string | number, visible?: boolean): boolean;
+    setItemActions(layerOrId: unknown | string | number, actionsSections: readonly (readonly LayerListActionCompat[])[]): boolean;
+    triggerAction(actionId: string, layerOrId?: unknown | string | number): boolean;
+    on<TType extends LayerListEventTypeCompat>(type: TType, listener: (event: LayerListEventPayloadByType[TType]) => void): LayerListHandleCompat;
+    destroy(): void;
+    private findLayer;
+    private findItem;
+    private emit;
+    private notifyWatchers;
+}
+export {};
+//# sourceMappingURL=layer-list.d.ts.map

package/esri-compat/layer-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-list.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/layer-list.ts"],"names":[],"mappings":"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"}

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;
+}