@honua/app-platform 0.0.20-alpha.0

package/esri-compat/identity-manager.d.ts

@@ -0,0 +1,74 @@
+import type { HonuaAuthProvider } from "../core/types.js";
+import { OAuthInfoCompat, type OAuthInfoCompatOptions } from "./oauth-info.js";
+export interface IdentityCredentialCompat {
+    server: string;
+    token: string;
+    expires?: number;
+    userId?: string;
+}
+export interface IdentityTokenRegistrationCompat {
+    server: string;
+    token: string;
+    expires?: number;
+    userId?: string;
+}
+/**
+ * A real OAuth2 engine backing a server in {@link IdentityManagerCompatStore}.
+ * Any built-in provider from `@honua/sdk-js/auth` (e.g. `oauth2(...)`) satisfies
+ * this: it is a {@link HonuaAuthProvider} with an optional interactive
+ * `signIn()`. Binding one makes `getCredential(url)` drive the actual PKCE /
+ * refresh flow (obtain a token, register it, return it) instead of only reading
+ * pre-seeded tokens — so migrated `IdentityManager.registerOAuthInfos(...)` +
+ * `IdentityManager.getCredential(...)` code paths work end to end.
+ */
+export interface IdentityManagerOAuth2Engine extends HonuaAuthProvider {
+    signIn?(): Promise<unknown>;
+}
+declare class IdentityManagerCompatStore {
+    private readonly oauthInfosInternal;
+    private readonly credentialsInternal;
+    private readonly engines;
+    constructor();
+    get oauthInfos(): readonly OAuthInfoCompat[];
+    get credentials(): readonly IdentityCredentialCompat[];
+    registerOAuthInfos(infos: readonly (OAuthInfoCompat | OAuthInfoCompatOptions)[]): void;
+    registerToken(token: IdentityTokenRegistrationCompat): void;
+    findCredential(url: string): IdentityCredentialCompat | undefined;
+    checkSignInStatus(url: string): Promise<IdentityCredentialCompat>;
+    /**
+     * Bind a real OAuth2 engine (e.g. `oauth2(...)` from `@honua/sdk-js/auth`) to
+     * a server URL. Once bound, {@link getCredential} for a URL under that server
+     * drives the engine's silent-refresh / interactive sign-in flow instead of
+     * only reading a pre-registered token.
+     *
+     * @example
+     * ```ts
+     * import { oauth2 } from "@honua/sdk-js/auth";
+     * import { identityManager, OAuthInfoCompat } from "@honua/sdk-js/esri-compat";
+     *
+     * const info = new OAuthInfoCompat({ appId: "app", portalUrl: "https://portal.example" });
+     * identityManager.registerOAuthInfos([info]);
+     * identityManager.registerOAuth2Engine(
+     *   info.portalUrl,
+     *   oauth2(info.toOAuth2Config({ redirectUri: `${location.origin}/callback` })),
+     * );
+     * const credential = await identityManager.getCredential("https://portal.example/sharing/rest");
+     * ```
+     */
+    registerOAuth2Engine(server: string, engine: IdentityManagerOAuth2Engine): void;
+    /**
+     * Resolve a credential for `url`. Returns a valid pre-registered token when
+     * one exists; otherwise, if a real OAuth2 engine is bound for the server,
+     * drives it (silent refresh, or interactive `signIn()` when the engine throws
+     * `interaction_required`), registers the resulting token, and returns it.
+     */
+    getCredential(url: string): Promise<IdentityCredentialCompat>;
+    destroyCredentials(): void;
+    reset(): void;
+    private findEngine;
+    private resolveThroughEngine;
+    private findCredentialEntry;
+}
+export declare const identityManager: IdentityManagerCompatStore;
+export {};
+//# sourceMappingURL=identity-manager.d.ts.map

package/esri-compat/identity-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-manager.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/identity-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAwB,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAE/E,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,+BAA+B;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,2BAA4B,SAAQ,iBAAiB;IACpE,MAAM,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7B;AAOD,cAAM,0BAA0B;IAC9B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoB;IACvD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA6B;IACjE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;;IAQxC,IAAW,UAAU,IAAI,SAAS,eAAe,EAAE,CAElD;IAED,IAAW,WAAW,IAAI,SAAS,wBAAwB,EAAE,CAE5D;IAEM,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,eAAe,GAAG,sBAAsB,CAAC,EAAE,GAAG,IAAI;IAOtF,aAAa,CAAC,KAAK,EAAE,+BAA+B,GAAG,IAAI;IA6B3D,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,wBAAwB,GAAG,SAAS;IAQ3D,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAW9E;;;;;;;;;;;;;;;;;;;OAmBG;IACI,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,2BAA2B,GAAG,IAAI;IAWtF;;;;;OAKG;IACU,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAgBnE,kBAAkB,IAAI,IAAI;IAI1B,KAAK,IAAI,IAAI;IAMpB,OAAO,CAAC,UAAU;YAqBJ,oBAAoB;IAyBlC,OAAO,CAAC,mBAAmB;CAsB5B;AAED,eAAO,MAAM,eAAe,4BAAmC,CAAC"}

package/esri-compat/identity-manager.js

@@ -0,0 +1,245 @@
+import { OAuthInfoCompat } from "./oauth-info.js";
+class IdentityManagerCompatStore {
+    oauthInfosInternal;
+    credentialsInternal;
+    engines;
+    constructor() {
+        this.oauthInfosInternal = [];
+        this.credentialsInternal = [];
+        this.engines = [];
+    }
+    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 };
+    }
+    /**
+     * Bind a real OAuth2 engine (e.g. `oauth2(...)` from `@honua/sdk-js/auth`) to
+     * a server URL. Once bound, {@link getCredential} for a URL under that server
+     * drives the engine's silent-refresh / interactive sign-in flow instead of
+     * only reading a pre-registered token.
+     *
+     * @example
+     * ```ts
+     * import { oauth2 } from "@honua/sdk-js/auth";
+     * import { identityManager, OAuthInfoCompat } from "@honua/sdk-js/esri-compat";
+     *
+     * const info = new OAuthInfoCompat({ appId: "app", portalUrl: "https://portal.example" });
+     * identityManager.registerOAuthInfos([info]);
+     * identityManager.registerOAuth2Engine(
+     *   info.portalUrl,
+     *   oauth2(info.toOAuth2Config({ redirectUri: `${location.origin}/callback` })),
+     * );
+     * const credential = await identityManager.getCredential("https://portal.example/sharing/rest");
+     * ```
+     */
+    registerOAuth2Engine(server, engine) {
+        const normalized = normalizeServerUrl(server) ?? server;
+        const existing = this.engines.findIndex((bound) => (normalizeServerUrl(bound.server) ?? bound.server) === normalized);
+        if (existing >= 0) {
+            this.engines.splice(existing, 1);
+        }
+        this.engines.push({ server, engine });
+    }
+    /**
+     * Resolve a credential for `url`. Returns a valid pre-registered token when
+     * one exists; otherwise, if a real OAuth2 engine is bound for the server,
+     * drives it (silent refresh, or interactive `signIn()` when the engine throws
+     * `interaction_required`), registers the resulting token, and returns it.
+     */
+    async getCredential(url) {
+        const existing = this.findCredentialEntry(url);
+        if (existing && !isCredentialExpired(existing)) {
+            return { ...existing };
+        }
+        const engine = this.findEngine(url);
+        if (!engine) {
+            return this.checkSignInStatus(url);
+        }
+        const credential = await this.resolveThroughEngine(engine, url);
+        this.registerToken(credential);
+        return { ...credential };
+    }
+    destroyCredentials() {
+        this.credentialsInternal.length = 0;
+    }
+    reset() {
+        this.oauthInfosInternal.length = 0;
+        this.credentialsInternal.length = 0;
+        this.engines.length = 0;
+    }
+    findEngine(url) {
+        const normalized = normalizeServerUrl(url);
+        if (!normalized) {
+            return undefined;
+        }
+        for (let index = this.engines.length - 1; index >= 0; index -= 1) {
+            const bound = this.engines[index];
+            if (!bound) {
+                continue;
+            }
+            const server = normalizeServerUrl(bound.server);
+            if (!server) {
+                continue;
+            }
+            if (normalized === server || normalized.startsWith(`${server}/`)) {
+                return bound;
+            }
+        }
+        return undefined;
+    }
+    async resolveThroughEngine(bound, url) {
+        const context = { reason: "initial", forceRefresh: false };
+        let credentials;
+        try {
+            credentials = await bound.engine.getCredentials(context);
+        }
+        catch (error) {
+            if (isInteractionRequired(error) && bound.engine.signIn) {
+                await bound.engine.signIn();
+                credentials = await bound.engine.getCredentials(context);
+            }
+            else {
+                throw error;
+            }
+        }
+        const token = tokenFromCredentials(credentials);
+        if (!token) {
+            throw new Error("OAuth2 engine did not return a usable token for the requested server.");
+        }
+        const expires = expiresFromCredentials(credentials);
+        return {
+            server: bound.server,
+            token,
+            ...(expires !== undefined ? { expires } : {}),
+        };
+    }
+    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;
+}
+function isInteractionRequired(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        error.name === "HonuaAuthError" &&
+        error.code === "interaction_required");
+}
+function tokenFromCredentials(credentials) {
+    if (!credentials) {
+        return undefined;
+    }
+    if (typeof credentials === "string") {
+        return credentials.length > 0 ? credentials : undefined;
+    }
+    if (credentials.bearerToken) {
+        return credentials.bearerToken;
+    }
+    if (credentials.authorization) {
+        // Strip a leading "Bearer " scheme so the stored token matches what Esri
+        // clients expect in the `token` field.
+        return credentials.authorization.replace(/^Bearer\s+/i, "");
+    }
+    return credentials.apiKey;
+}
+function expiresFromCredentials(credentials) {
+    if (!credentials || typeof credentials === "string" || credentials.expiresAt === undefined) {
+        return undefined;
+    }
+    const { expiresAt } = credentials;
+    if (expiresAt instanceof Date) {
+        return Number.isFinite(expiresAt.getTime()) ? expiresAt.getTime() : undefined;
+    }
+    if (typeof expiresAt === "number") {
+        return Number.isFinite(expiresAt) ? expiresAt : undefined;
+    }
+    const parsed = Date.parse(expiresAt);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}

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

@@ -0,0 +1,78 @@
+import { HonuaClient } from "../core/client.js";
+import type { HonuaServiceMetadata } from "../core/types.js";
+import { CompatEventBus } from "./event-bus.js";
+export interface ImageryLayerCompatOptions {
+    url: string;
+    id?: string;
+    title?: string;
+    opacity?: number;
+    visible?: boolean;
+    listMode?: string;
+    format?: string;
+    pixelType?: string;
+    bandIds?: ReadonlyArray<number>;
+    renderingRule?: Record<string, unknown>;
+    mosaicRule?: Record<string, unknown>;
+    client?: HonuaClient;
+    eventBus?: CompatEventBus;
+}
+export type ImageryLayerLoadStatusCompat = "not-loaded" | "loading" | "loaded" | "failed";
+export interface ImageryLayerHandleCompat {
+    remove(): void;
+}
+export interface ImageryLayerExportOptions {
+    bbox: [number, number, number, number] | string;
+    size: [number, number] | string;
+    format?: string;
+    pixelType?: string;
+    interpolation?: string;
+    bandIds?: ReadonlyArray<number>;
+    compressionQuality?: number;
+}
+export interface ImageryLayerIdentifyOptions {
+    geometry: Record<string, unknown>;
+    geometryType?: string;
+}
+export interface ImageryLayerQueryOptions {
+    where?: string;
+    objectIds?: readonly number[];
+    outFields?: readonly string[];
+    returnGeometry?: boolean;
+}
+export declare class ImageryLayerCompat {
+    readonly type: "imagery";
+    readonly url: string;
+    readonly serviceId: string;
+    id: string;
+    title: string | undefined;
+    opacity: number;
+    visible: boolean;
+    listMode: string;
+    format: string;
+    pixelType: string | undefined;
+    bandIds: ReadonlyArray<number> | undefined;
+    renderingRule: Record<string, unknown> | undefined;
+    mosaicRule: Record<string, unknown> | undefined;
+    loaded: boolean;
+    loadStatus: ImageryLayerLoadStatusCompat;
+    metadata: HonuaServiceMetadata | undefined;
+    readonly eventBus: CompatEventBus;
+    private readonly client;
+    private readonly imageService;
+    private readonly watchListeners;
+    private readonly eventListeners;
+    constructor(options: ImageryLayerCompatOptions);
+    load(): Promise<ImageryLayerCompat>;
+    when(callback?: (layer: ImageryLayerCompat) => void): Promise<ImageryLayerCompat>;
+    exportImage(options: ImageryLayerExportOptions): Promise<unknown>;
+    identify(options: ImageryLayerIdentifyOptions): Promise<unknown>;
+    queryRasters(options?: ImageryLayerQueryOptions): Promise<unknown>;
+    refresh(): void;
+    watch(propertyName: string, listener: (value: unknown) => void): ImageryLayerHandleCompat;
+    on(eventName: string, listener: (event: unknown) => void): ImageryLayerHandleCompat;
+    setVisibility(visible: boolean): void;
+    setOpacity(opacity: number): void;
+    destroy(): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=imagery-layer.d.ts.map

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

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

package/esri-compat/imagery-layer.js

@@ -0,0 +1,167 @@
+import { HonuaClient } from "../core/client.js";
+import { CompatEventBus, resolveCompatEventBus, safeInvokeCompatListener } from "./event-bus.js";
+import { parseImageServiceUrl } from "./url.js";
+export class ImageryLayerCompat {
+    type;
+    url;
+    serviceId;
+    id;
+    title;
+    opacity;
+    visible;
+    listMode;
+    format;
+    pixelType;
+    bandIds;
+    renderingRule;
+    mosaicRule;
+    loaded;
+    loadStatus;
+    metadata;
+    eventBus;
+    client;
+    imageService;
+    watchListeners;
+    eventListeners;
+    constructor(options) {
+        const parsed = parseImageServiceUrl(options.url);
+        this.type = "imagery";
+        this.url = options.url;
+        this.serviceId = parsed.serviceId;
+        this.id = options.id ?? this.serviceId;
+        this.title = options.title;
+        this.opacity = options.opacity ?? 1;
+        this.visible = options.visible ?? true;
+        this.listMode = options.listMode ?? "show";
+        this.format = options.format ?? "png";
+        this.pixelType = options.pixelType;
+        this.bandIds = options.bandIds;
+        this.renderingRule = options.renderingRule;
+        this.mosaicRule = options.mosaicRule;
+        this.loaded = false;
+        this.loadStatus = "not-loaded";
+        this.metadata = undefined;
+        this.eventBus = options.eventBus ?? resolveCompatEventBus(options.client) ?? new CompatEventBus();
+        this.client = options.client ?? new HonuaClient({ baseUrl: parsed.baseUrl });
+        this.imageService = this.client.imageService(this.serviceId);
+        this.watchListeners = new Map();
+        this.eventListeners = new Map();
+    }
+    async load() {
+        if (this.loaded)
+            return this;
+        this.loadStatus = "loading";
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        try {
+            this.metadata = await this.imageService.metadata();
+            this.notifyWatchers("metadata", this.metadata);
+            this.loaded = true;
+            this.loadStatus = "loaded";
+            this.notifyWatchers("loaded", this.loaded);
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.eventBus.emit("imagery-layer.loaded", { serviceId: this.serviceId, id: this.id }, this);
+        }
+        catch (error) {
+            this.loadStatus = "failed";
+            this.notifyWatchers("loadStatus", this.loadStatus);
+            this.eventBus.emit("imagery-layer.failed", { serviceId: this.serviceId, id: this.id, error }, this);
+            throw error;
+        }
+        return this;
+    }
+    async when(callback) {
+        const layer = await this.load();
+        if (callback)
+            callback(layer);
+        return layer;
+    }
+    async exportImage(options) {
+        await this.load();
+        return this.imageService.exportImage({
+            bbox: options.bbox,
+            size: options.size,
+            format: options.format ?? this.format,
+            pixelType: options.pixelType ?? this.pixelType,
+            bandIds: options.bandIds ?? this.bandIds,
+            interpolation: options.interpolation,
+            compressionQuality: options.compressionQuality,
+        });
+    }
+    async identify(options) {
+        await this.load();
+        return this.imageService.identify({
+            geometry: options.geometry,
+            geometryType: options.geometryType,
+        });
+    }
+    async queryRasters(options = {}) {
+        await this.load();
+        return this.imageService.queryRasterCatalog({
+            where: options.where,
+            objectIds: options.objectIds !== undefined ? [...options.objectIds] : undefined,
+            outFields: options.outFields !== undefined ? [...options.outFields] : undefined,
+            returnGeometry: options.returnGeometry,
+        });
+    }
+    refresh() {
+        this.loaded = false;
+        this.metadata = undefined;
+        this.loadStatus = "not-loaded";
+        this.notifyWatchers("loaded", this.loaded);
+        this.notifyWatchers("metadata", this.metadata);
+        this.notifyWatchers("loadStatus", this.loadStatus);
+        this.eventBus.emit("imagery-layer.refreshed", { serviceId: this.serviceId, id: this.id }, this);
+    }
+    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);
+            },
+        };
+    }
+    on(eventName, listener) {
+        let listeners = this.eventListeners.get(eventName);
+        if (!listeners) {
+            listeners = new Set();
+            this.eventListeners.set(eventName, listeners);
+        }
+        listeners.add(listener);
+        const subscription = this.eventBus.on(`imagery-layer.${eventName}`, (event) => {
+            safeInvokeCompatListener(listener, event.payload);
+        });
+        return {
+            remove: () => {
+                listeners?.delete(listener);
+                subscription.remove();
+            },
+        };
+    }
+    setVisibility(visible) {
+        this.visible = visible;
+        this.notifyWatchers("visible", this.visible);
+        this.eventBus.emit("layer.visibility-changed", { layerId: this.id, visible }, this);
+    }
+    setOpacity(opacity) {
+        this.opacity = Math.min(Math.max(opacity, 0), 1);
+        this.notifyWatchers("opacity", this.opacity);
+        this.eventBus.emit("layer.opacity-changed", { layerId: this.id, opacity: this.opacity }, this);
+    }
+    destroy() {
+        this.watchListeners.clear();
+        this.eventListeners.clear();
+        this.eventBus.emit("imagery-layer.destroyed", { layerId: this.id }, this);
+    }
+    notifyWatchers(propertyName, value) {
+        const listeners = this.watchListeners.get(propertyName);
+        if (!listeners)
+            return;
+        for (const listener of listeners)
+            safeInvokeCompatListener(listener, value);
+    }
+}

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"}