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

package/core/errors.d.ts

@@ -0,0 +1,68 @@
+import { HonuaWmsCapabilitiesParseError } from "./wms-capabilities.js";
+import { HonuaWmtsCapabilitiesParseError } from "./wmts-capabilities.js";
+export declare class HonuaHttpError extends Error {
+    readonly statusCode: number;
+    readonly body: unknown;
+    constructor(statusCode: number, message: string, body: unknown);
+}
+/** Thrown when a request exceeds the configured timeout. */
+export declare class HonuaTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+/** Thrown when a network-level failure occurs (DNS, connection refused, etc.). */
+export declare class HonuaNetworkError extends Error {
+    readonly cause: unknown;
+    constructor(message: string, cause: unknown);
+}
+/** Thrown when a request is aborted via a caller-provided AbortSignal. */
+export declare class HonuaAbortError extends Error {
+    constructor(message?: string);
+}
+/** Thrown when a gRPC-Web request fails, wrapping the underlying ConnectError. */
+export declare class HonuaGrpcError extends Error {
+    readonly code: number;
+    readonly details: unknown;
+    constructor(code: number, message: string, details?: unknown);
+}
+/**
+ * Thrown when a `Source` is asked to perform an operation that the underlying
+ * protocol or server does not support and the active capability policy is
+ * `strict`. The `capability` field names the missing capability so callers can
+ * decide whether to swap protocols, fall back to a degraded strategy, or
+ * surface the limitation to the user.
+ */
+export declare class HonuaCapabilityNotSupportedError extends Error {
+    readonly capability: string;
+    readonly protocol: string;
+    readonly sourceId: string | undefined;
+    constructor(capability: string, protocol: string, sourceId?: string);
+}
+/**
+ * Thrown when an `ExplorationContext` operation is invalid — for example,
+ * dispatching an intent against a context that has been disposed, restoring
+ * an incompatible snapshot, or binding a view that requests a slice that is
+ * not exposed by the current dataset.
+ */
+export declare class HonuaExplorationContextError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/**
+ * Thrown when a WFS server replies with an `ows:ExceptionReport`. Carries the
+ * structured exception metadata so callers can distinguish capability misses
+ * (for example `OperationProcessingFailed`, `InvalidParameterValue`) from
+ * transport / timeout failures. The XML payload is consumed by
+ * `src/core/wfs-capabilities.ts`; raw access lives behind the `protocol("wfs")`
+ * escape hatch.
+ */
+export declare class HonuaWfsExceptionError extends Error {
+    readonly exceptionCode: string;
+    readonly locator: string | undefined;
+    constructor(exceptionCode: string, message: string, locator?: string);
+}
+/** All Honua SDK error types that can be discriminated with `instanceof`. */
+export type HonuaError = HonuaHttpError | HonuaTimeoutError | HonuaNetworkError | HonuaAbortError | HonuaGrpcError | HonuaCapabilityNotSupportedError | HonuaExplorationContextError | HonuaWfsExceptionError | HonuaWmsCapabilitiesParseError | HonuaWmtsCapabilitiesParseError;
+/** Type guard that narrows any value to one of the Honua SDK error types. */
+export declare function isHonuaError(error: unknown): error is HonuaError;
+//# sourceMappingURL=errors.d.ts.map

package/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/core/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAC;AAEzE,qBAAa,cAAe,SAAQ,KAAK;IACvC,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,IAAI,EAAE,OAAO,CAAC;gBAEX,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;CAMtE;AAED,4DAA4D;AAC5D,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM;CAKrC;AAED,kFAAkF;AAClF,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,SAAyB,KAAK,EAAE,OAAO,CAAC;gBAErB,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;CAKnD;AAED,0EAA0E;AAC1E,qBAAa,eAAgB,SAAQ,KAAK;gBACrB,OAAO,SAAwB;CAInD;AAED,kFAAkF;AAClF,qBAAa,cAAe,SAAQ,KAAK;IACvC,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,OAAO,EAAE,OAAO,CAAC;gBAEd,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;CAMpE;AAED;;;;;;GAMG;AACH,qBAAa,gCAAiC,SAAQ,KAAK;IACzD,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE1B,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAW3E;AAED;;;;;GAKG;AACH,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAKjD;AAED;;;;;;;GAOG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,SAAgB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEzB,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;CAU5E;AAED,6EAA6E;AAC7E,MAAM,MAAM,UAAU,GAClB,cAAc,GACd,iBAAiB,GACjB,iBAAiB,GACjB,eAAe,GACf,cAAc,GACd,gCAAgC,GAChC,4BAA4B,GAC5B,sBAAsB,GACtB,8BAA8B,GAC9B,+BAA+B,CAAC;AAEpC,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAahE"}

package/core/errors.js

@@ -0,0 +1,116 @@
+import { HonuaWmsCapabilitiesParseError } from "./wms-capabilities.js";
+import { HonuaWmtsCapabilitiesParseError } from "./wmts-capabilities.js";
+export class HonuaHttpError extends Error {
+    statusCode;
+    body;
+    constructor(statusCode, message, body) {
+        super(`HTTP ${statusCode}: ${message}`);
+        this.name = "HonuaHttpError";
+        this.statusCode = statusCode;
+        this.body = body;
+    }
+}
+/** Thrown when a request exceeds the configured timeout. */
+export class HonuaTimeoutError extends Error {
+    timeoutMs;
+    constructor(timeoutMs) {
+        super(`Request timed out after ${timeoutMs}ms`);
+        this.name = "HonuaTimeoutError";
+        this.timeoutMs = timeoutMs;
+    }
+}
+/** Thrown when a network-level failure occurs (DNS, connection refused, etc.). */
+export class HonuaNetworkError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = "HonuaNetworkError";
+        this.cause = cause;
+    }
+}
+/** Thrown when a request is aborted via a caller-provided AbortSignal. */
+export class HonuaAbortError extends Error {
+    constructor(message = "Request was aborted") {
+        super(message);
+        this.name = "HonuaAbortError";
+    }
+}
+/** Thrown when a gRPC-Web request fails, wrapping the underlying ConnectError. */
+export class HonuaGrpcError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = "HonuaGrpcError";
+        this.code = code;
+        this.details = details;
+    }
+}
+/**
+ * Thrown when a `Source` is asked to perform an operation that the underlying
+ * protocol or server does not support and the active capability policy is
+ * `strict`. The `capability` field names the missing capability so callers can
+ * decide whether to swap protocols, fall back to a degraded strategy, or
+ * surface the limitation to the user.
+ */
+export class HonuaCapabilityNotSupportedError extends Error {
+    capability;
+    protocol;
+    sourceId;
+    constructor(capability, protocol, sourceId) {
+        super(sourceId
+            ? `Capability "${capability}" is not supported by protocol "${protocol}" on source "${sourceId}"`
+            : `Capability "${capability}" is not supported by protocol "${protocol}"`);
+        this.name = "HonuaCapabilityNotSupportedError";
+        this.capability = capability;
+        this.protocol = protocol;
+        this.sourceId = sourceId;
+    }
+}
+/**
+ * Thrown when an `ExplorationContext` operation is invalid — for example,
+ * dispatching an intent against a context that has been disposed, restoring
+ * an incompatible snapshot, or binding a view that requests a slice that is
+ * not exposed by the current dataset.
+ */
+export class HonuaExplorationContextError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "HonuaExplorationContextError";
+        this.code = code;
+    }
+}
+/**
+ * Thrown when a WFS server replies with an `ows:ExceptionReport`. Carries the
+ * structured exception metadata so callers can distinguish capability misses
+ * (for example `OperationProcessingFailed`, `InvalidParameterValue`) from
+ * transport / timeout failures. The XML payload is consumed by
+ * `src/core/wfs-capabilities.ts`; raw access lives behind the `protocol("wfs")`
+ * escape hatch.
+ */
+export class HonuaWfsExceptionError extends Error {
+    exceptionCode;
+    locator;
+    constructor(exceptionCode, message, locator) {
+        super(locator
+            ? `WFS ExceptionReport ${exceptionCode} (${locator}): ${message}`
+            : `WFS ExceptionReport ${exceptionCode}: ${message}`);
+        this.name = "HonuaWfsExceptionError";
+        this.exceptionCode = exceptionCode;
+        this.locator = locator;
+    }
+}
+/** Type guard that narrows any value to one of the Honua SDK error types. */
+export function isHonuaError(error) {
+    return (error instanceof HonuaHttpError ||
+        error instanceof HonuaTimeoutError ||
+        error instanceof HonuaNetworkError ||
+        error instanceof HonuaAbortError ||
+        error instanceof HonuaGrpcError ||
+        error instanceof HonuaCapabilityNotSupportedError ||
+        error instanceof HonuaExplorationContextError ||
+        error instanceof HonuaWfsExceptionError ||
+        error instanceof HonuaWmsCapabilitiesParseError ||
+        error instanceof HonuaWmtsCapabilitiesParseError);
+}

package/core/grpc-adapter.d.ts

@@ -0,0 +1,23 @@
+import { type FeaturePage, type QueryFeaturesResponse } from "../gen/honua/v1/feature_service_pb.js";
+import type { HonuaCountResponse, HonuaExtentResponse, HonuaFeature, HonuaObjectIdsResponse, HonuaQueryResponse, QueryFeaturesRequest } from "./types.js";
+/**
+ * Converts a SDK QueryFeaturesRequest into a proto QueryFeaturesRequest message.
+ */
+export declare function toProtoQueryRequest(request: QueryFeaturesRequest): import("../gen/honua/v1/feature_service_pb.js").QueryFeaturesRequest;
+/**
+ * Converts a proto QueryFeaturesResponse into the JSON-compatible shape
+ * matching the `f=json` response format.
+ */
+export declare function fromProtoQueryResponse(response: QueryFeaturesResponse): HonuaQueryResponse | HonuaCountResponse | HonuaObjectIdsResponse | HonuaExtentResponse;
+/**
+ * Converts a stream of proto FeaturePages into an async generator
+ * that yields arrays of JSON-compatible features, matching the
+ * existing queryFeaturesStream yield type.
+ */
+export declare function streamProtoPages(stream: AsyncIterable<FeaturePage>): AsyncGenerator<HonuaFeature[], void, undefined>;
+/**
+ * Wraps a ConnectError (or any error from the gRPC transport) in a
+ * HonuaGrpcError for consistent `instanceof` discrimination.
+ */
+export declare function wrapConnectError(error: unknown): Error;
+//# sourceMappingURL=grpc-adapter.d.ts.map

package/core/grpc-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc-adapter.d.ts","sourceRoot":"","sources":["../../../src/core/grpc-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,WAAW,EAWhB,KAAK,qBAAqB,EAM3B,MAAM,uCAAuC,CAAC;AAE/C,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,EAEZ,sBAAsB,EACtB,kBAAkB,EAElB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAgFpB;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,wEAoIhE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,qBAAqB,GAC9B,kBAAkB,GAAG,kBAAkB,GAAG,sBAAsB,GAAG,mBAAmB,CAkDxF;AA0UD;;;;GAIG;AACH,wBAAuB,gBAAgB,CACrC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,GACjC,cAAc,CAAC,YAAY,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,CAiBjD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAYtD"}