@honua/react 0.0.20-alpha.0

package/core/request-pipeline.js

@@ -0,0 +1,273 @@
+import { HonuaAbortError, HonuaHttpError, HonuaNetworkError, HonuaTimeoutError } from "./errors.js";
+export const DEFAULT_RETRY_STATUSES = new Set([429, 502, 503, 504]);
+export const DEFAULT_RETRY_METHODS = new Set(["GET", "PUT", "DELETE"]);
+export function normalizeTimeoutMs(timeoutMs) {
+    if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) {
+        return undefined;
+    }
+    return Math.max(1, Math.trunc(timeoutMs));
+}
+export function normalizeRetryOptions(options) {
+    if (!options) {
+        return undefined;
+    }
+    const maxRetries = typeof options.maxRetries === "number" && Number.isFinite(options.maxRetries)
+        ? Math.max(0, Math.trunc(options.maxRetries))
+        : 0;
+    if (maxRetries < 1) {
+        return undefined;
+    }
+    const baseDelayMs = typeof options.baseDelayMs === "number" && Number.isFinite(options.baseDelayMs)
+        ? Math.max(1, Math.trunc(options.baseDelayMs))
+        : 100;
+    const maxDelayMs = typeof options.maxDelayMs === "number" && Number.isFinite(options.maxDelayMs)
+        ? Math.max(baseDelayMs, Math.trunc(options.maxDelayMs))
+        : 2_000;
+    const retryStatuses = new Set((options.retryStatuses ?? Array.from(DEFAULT_RETRY_STATUSES))
+        .map((status) => Math.trunc(status))
+        .filter((status) => Number.isFinite(status) && status >= 100 && status <= 599));
+    if (retryStatuses.size === 0) {
+        for (const status of DEFAULT_RETRY_STATUSES) {
+            retryStatuses.add(status);
+        }
+    }
+    return {
+        maxRetries,
+        baseDelayMs,
+        maxDelayMs,
+        retryStatuses,
+    };
+}
+/**
+ * Parse a `Retry-After` header value (delta-seconds or HTTP-date) into a delay
+ * in milliseconds. Shared by the REST {@link parseRetryAfterMs} response helper
+ * and the gRPC-web path, which reads the same header off the Connect error
+ * metadata (a `Headers`-shaped object) rather than a `Response`.
+ */
+export function parseRetryAfterHeaderMs(headers) {
+    const value = headers.get("retry-after");
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number.parseInt(value, 10);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return seconds * 1_000;
+    }
+    const targetTime = Date.parse(value);
+    if (!Number.isFinite(targetTime)) {
+        return undefined;
+    }
+    return Math.max(0, targetTime - Date.now());
+}
+export function parseRetryAfterMs(response) {
+    return parseRetryAfterHeaderMs(response.headers);
+}
+/**
+ * Decide whether a failed attempt should be retried. Idempotent/replay-safe
+ * methods (GET/PUT/DELETE) are retried on the configured retry statuses or on
+ * transient network/timeout errors; aborts are never retried.
+ */
+export function shouldRetryRequest(retryOptions, method, attempt, statusCode, error) {
+    if (!retryOptions || attempt >= retryOptions.maxRetries) {
+        return false;
+    }
+    if (!DEFAULT_RETRY_METHODS.has(method)) {
+        return false;
+    }
+    if (error instanceof HonuaAbortError) {
+        return false;
+    }
+    if (statusCode !== undefined) {
+        return retryOptions.retryStatuses.has(statusCode);
+    }
+    return error instanceof HonuaNetworkError || error instanceof HonuaTimeoutError;
+}
+/**
+ * Resolve the backoff delay before the next attempt. A server `Retry-After`
+ * header (capped by `maxDelayMs`) wins; otherwise an exponential backoff with
+ * full jitter in the [0.5x, 1x] band is used.
+ */
+export function resolveRetryDelayMs(retryOptions, attempt, response) {
+    const retryAfterMs = response ? parseRetryAfterMs(response) : undefined;
+    if (retryAfterMs !== undefined) {
+        return Math.min(retryOptions?.maxDelayMs ?? retryAfterMs, retryAfterMs);
+    }
+    if (!retryOptions) {
+        return 0;
+    }
+    const exponentialDelay = retryOptions.baseDelayMs * 2 ** attempt;
+    const cappedDelay = Math.min(retryOptions.maxDelayMs, exponentialDelay);
+    return cappedDelay * (0.5 + Math.random() * 0.5);
+}
+/**
+ * gRPC/Connect numeric status codes that map to the transient REST retry
+ * statuses in {@link DEFAULT_RETRY_STATUSES}, so the grpc-web transport retries
+ * the same class of transient failures as REST. Mirrors the gRPC retry
+ * conventions: `resource_exhausted` (~429), `unavailable` (~502/503),
+ * `deadline_exceeded` (~504), and the transient `aborted` concurrency code.
+ */
+export const DEFAULT_RETRYABLE_GRPC_CODES = new Set([
+    4, // deadline_exceeded
+    8, // resource_exhausted
+    10, // aborted
+    14, // unavailable
+]);
+/** Connect/gRPC `canceled` code — caller/abort-driven, never retried. */
+const GRPC_CODE_CANCELED = 1;
+/**
+ * Extract the numeric gRPC/Connect status code off a thrown error (a
+ * `ConnectError` carries a numeric `code`). Returns `undefined` for non-Connect
+ * errors so callers can treat them as non-retryable.
+ */
+export function connectErrorCode(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "number") {
+        return error.code;
+    }
+    return undefined;
+}
+/**
+ * Decide whether a failed gRPC-web call should be retried. Mirrors
+ * {@link shouldRetryRequest} for the Connect transport: retries only the
+ * transient {@link DEFAULT_RETRYABLE_GRPC_CODES} while honoring `maxRetries`,
+ * and never retries once the call's abort signal has fired (caller abort or the
+ * `timeoutMs` deadline) or for the `canceled` code.
+ *
+ * Replay-safety (unary-only, since server-streaming responses cannot be safely
+ * replayed mid-iteration) is enforced by the caller, mirroring the REST
+ * {@link DEFAULT_RETRY_METHODS} idempotency gate.
+ */
+export function shouldRetryGrpcCall(retryOptions, attempt, error, aborted) {
+    if (!retryOptions || attempt >= retryOptions.maxRetries) {
+        return false;
+    }
+    if (aborted) {
+        return false;
+    }
+    const code = connectErrorCode(error);
+    if (code === undefined || code === GRPC_CODE_CANCELED) {
+        return false;
+    }
+    return DEFAULT_RETRYABLE_GRPC_CODES.has(code);
+}
+function connectErrorMetadata(error) {
+    if (typeof error === "object" && error !== null && "metadata" in error) {
+        const metadata = error.metadata;
+        if (metadata && typeof metadata.get === "function") {
+            return metadata;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the backoff delay before the next gRPC-web attempt. Reuses the shared
+ * {@link resolveRetryDelayMs} exponential-with-jitter math; a `retry-after`
+ * value carried on the Connect error metadata (capped by `maxDelayMs`) wins,
+ * mirroring the REST `Retry-After` handling.
+ */
+export function resolveGrpcRetryDelayMs(retryOptions, attempt, error) {
+    const metadata = connectErrorMetadata(error);
+    const retryAfterMs = metadata ? parseRetryAfterHeaderMs(metadata) : undefined;
+    if (retryAfterMs !== undefined) {
+        return Math.min(retryOptions?.maxDelayMs ?? retryAfterMs, retryAfterMs);
+    }
+    return resolveRetryDelayMs(retryOptions, attempt);
+}
+export async function sleep(ms, signal) {
+    if (ms <= 0) {
+        return;
+    }
+    if (signal?.aborted) {
+        throw new HonuaAbortError();
+    }
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        }, ms);
+        const abort = () => {
+            clearTimeout(timer);
+            reject(new HonuaAbortError());
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+    });
+}
+export function normalizeNetworkError(error) {
+    if (error instanceof Error && error.name === "AbortError") {
+        return new HonuaAbortError();
+    }
+    if (error instanceof Error) {
+        return new HonuaNetworkError(error.message, error);
+    }
+    return new HonuaNetworkError(String(error), error);
+}
+export function createTimeoutSignal(existingSignal, timeoutMs) {
+    if (timeoutMs === undefined) {
+        return {
+            signal: existingSignal ?? undefined,
+            didTimeout: false,
+            dispose: () => undefined,
+        };
+    }
+    const controller = new AbortController();
+    let didTimeout = false;
+    let timer;
+    let onAbort;
+    timer = setTimeout(() => {
+        didTimeout = true;
+        controller.abort();
+    }, timeoutMs);
+    if (existingSignal) {
+        if (existingSignal.aborted) {
+            controller.abort();
+        }
+        else {
+            onAbort = () => {
+                controller.abort();
+            };
+            existingSignal.addEventListener("abort", onAbort, { once: true });
+        }
+    }
+    return {
+        signal: controller.signal,
+        get didTimeout() {
+            return didTimeout;
+        },
+        dispose: () => {
+            if (timer) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+            if (existingSignal && onAbort) {
+                existingSignal.removeEventListener("abort", onAbort);
+                onAbort = undefined;
+            }
+        },
+    };
+}
+/**
+ * Map a non-OK HTTP response body into a {@link HonuaHttpError}, preferring the
+ * server's structured error message (`error.message`, `message`, or `detail`)
+ * and falling back to a generic message while preserving the raw body.
+ */
+export function toHttpError(statusCode, body) {
+    const fallback = "Request failed";
+    if (isObject(body)) {
+        const error = body.error;
+        if (isObject(error) && typeof error.message === "string") {
+            return new HonuaHttpError(statusCode, error.message, body);
+        }
+        if (typeof body.message === "string") {
+            return new HonuaHttpError(statusCode, body.message, body);
+        }
+        if (typeof body.detail === "string") {
+            return new HonuaHttpError(statusCode, body.detail, body);
+        }
+    }
+    return new HonuaHttpError(statusCode, fallback, body);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}

package/core/spatial-filter.d.ts

@@ -0,0 +1,93 @@
+import type { EsriGeometryType, EsriSpatialRel, HonuaSpatialReference } from "./types.js";
+/**
+ * A spatial filter fragment that can be spread into a `QueryFeaturesRequest`
+ * or applied via `QueryBuilder.geometry()` / `.geometryType()` / `.spatialRel()`.
+ */
+export interface SpatialFilter {
+    geometry: Record<string, unknown>;
+    geometryType: EsriGeometryType;
+    spatialRel?: EsriSpatialRel;
+}
+/**
+ * Create an envelope (bounding box) spatial filter.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...envelope(-118.5, 33.7, -117.5, 34.2),
+ * };
+ * ```
+ */
+export declare function envelope(xmin: number, ymin: number, xmax: number, ymax: number, spatialReference?: HonuaSpatialReference): SpatialFilter;
+/**
+ * Create a point spatial filter.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...point(-118.24, 34.05),
+ * };
+ * ```
+ */
+export declare function point(x: number, y: number, spatialReference?: HonuaSpatialReference): SpatialFilter;
+/**
+ * Create a polygon spatial filter from an array of rings.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...polygon([[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]]),
+ * };
+ * ```
+ */
+export declare function polygon(rings: number[][][], spatialReference?: HonuaSpatialReference): SpatialFilter;
+/**
+ * Create an envelope spatial filter centered on a point, approximating a
+ * circular buffer as a bounding box.
+ *
+ * @param x - Center x coordinate
+ * @param y - Center y coordinate
+ * @param distance - Half-width of the envelope in coordinate units
+ * @param spatialReference - Optional spatial reference
+ *
+ * @example
+ * ```ts
+ * // 0.5-degree bounding box around a point
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...buffer(-118.24, 34.05, 0.5),
+ * };
+ * ```
+ */
+export declare function buffer(x: number, y: number, distance: number, spatialReference?: HonuaSpatialReference): SpatialFilter;
+/**
+ * Wrap an existing geometry with `esriSpatialRelIntersects`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialIntersects({ xmin: -180, ymin: -90, xmax: 180, ymax: 90 });
+ * ```
+ */
+export declare function spatialIntersects(geometry: Record<string, unknown>): SpatialFilter;
+/**
+ * Wrap an existing geometry with `esriSpatialRelContains`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialContains({ rings: [[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]] });
+ * ```
+ */
+export declare function spatialContains(geometry: Record<string, unknown>): SpatialFilter;
+/**
+ * Wrap an existing geometry with `esriSpatialRelWithin`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialWithin({ rings: [[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]] });
+ * ```
+ */
+export declare function spatialWithin(geometry: Record<string, unknown>): SpatialFilter;
+//# sourceMappingURL=spatial-filter.d.ts.map

package/core/spatial-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial-filter.d.ts","sourceRoot":"","sources":["../../../src/core/spatial-filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAE1F;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,YAAY,EAAE,gBAAgB,CAAC;IAC/B,UAAU,CAAC,EAAE,cAAc,CAAC;CAC7B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,gBAAgB,CAAC,EAAE,qBAAqB,GACvC,aAAa,CAQf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,qBAAqB,GAAG,aAAa,CAQnG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,gBAAgB,CAAC,EAAE,qBAAqB,GAAG,aAAa,CAQpG;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,MAAM,EAChB,gBAAgB,CAAC,EAAE,qBAAqB,GACvC,aAAa,CAEf;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,aAAa,CAMlF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,aAAa,CAMhF;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,aAAa,CAM9E"}

package/core/spatial-filter.js

@@ -0,0 +1,153 @@
+/**
+ * Create an envelope (bounding box) spatial filter.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...envelope(-118.5, 33.7, -117.5, 34.2),
+ * };
+ * ```
+ */
+export function envelope(xmin, ymin, xmax, ymax, spatialReference) {
+    const geometry = { xmin, ymin, xmax, ymax };
+    if (spatialReference)
+        geometry.spatialReference = spatialReference;
+    return {
+        geometry,
+        geometryType: "esriGeometryEnvelope",
+        spatialRel: "esriSpatialRelIntersects",
+    };
+}
+/**
+ * Create a point spatial filter.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...point(-118.24, 34.05),
+ * };
+ * ```
+ */
+export function point(x, y, spatialReference) {
+    const geometry = { x, y };
+    if (spatialReference)
+        geometry.spatialReference = spatialReference;
+    return {
+        geometry,
+        geometryType: "esriGeometryPoint",
+        spatialRel: "esriSpatialRelIntersects",
+    };
+}
+/**
+ * Create a polygon spatial filter from an array of rings.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...polygon([[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]]),
+ * };
+ * ```
+ */
+export function polygon(rings, spatialReference) {
+    const geometry = { rings };
+    if (spatialReference)
+        geometry.spatialReference = spatialReference;
+    return {
+        geometry,
+        geometryType: "esriGeometryPolygon",
+        spatialRel: "esriSpatialRelIntersects",
+    };
+}
+/**
+ * Create an envelope spatial filter centered on a point, approximating a
+ * circular buffer as a bounding box.
+ *
+ * @param x - Center x coordinate
+ * @param y - Center y coordinate
+ * @param distance - Half-width of the envelope in coordinate units
+ * @param spatialReference - Optional spatial reference
+ *
+ * @example
+ * ```ts
+ * // 0.5-degree bounding box around a point
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...buffer(-118.24, 34.05, 0.5),
+ * };
+ * ```
+ */
+export function buffer(x, y, distance, spatialReference) {
+    return envelope(x - distance, y - distance, x + distance, y + distance, spatialReference);
+}
+/**
+ * Wrap an existing geometry with `esriSpatialRelIntersects`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialIntersects({ xmin: -180, ymin: -90, xmax: 180, ymax: 90 });
+ * ```
+ */
+export function spatialIntersects(geometry) {
+    return {
+        geometry,
+        geometryType: detectGeometryType(geometry),
+        spatialRel: "esriSpatialRelIntersects",
+    };
+}
+/**
+ * Wrap an existing geometry with `esriSpatialRelContains`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialContains({ rings: [[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]] });
+ * ```
+ */
+export function spatialContains(geometry) {
+    return {
+        geometry,
+        geometryType: detectGeometryType(geometry),
+        spatialRel: "esriSpatialRelContains",
+    };
+}
+/**
+ * Wrap an existing geometry with `esriSpatialRelWithin`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialWithin({ rings: [[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]] });
+ * ```
+ */
+export function spatialWithin(geometry) {
+    return {
+        geometry,
+        geometryType: detectGeometryType(geometry),
+        spatialRel: "esriSpatialRelWithin",
+    };
+}
+/**
+ * Detect the Esri geometry type from a plain geometry object by inspecting
+ * its shape (duck-typing).
+ *
+ * @internal
+ */
+function detectGeometryType(geometry) {
+    if ("xmin" in geometry && "ymin" in geometry && "xmax" in geometry && "ymax" in geometry) {
+        return "esriGeometryEnvelope";
+    }
+    if ("rings" in geometry) {
+        return "esriGeometryPolygon";
+    }
+    if ("paths" in geometry) {
+        return "esriGeometryPolyline";
+    }
+    if ("points" in geometry) {
+        return "esriGeometryMultipoint";
+    }
+    if ("x" in geometry && "y" in geometry) {
+        return "esriGeometryPoint";
+    }
+    return "esriGeometryPoint";
+}

package/core/stac.d.ts

@@ -0,0 +1,55 @@
+/**
+ * STAC API search surface. STAC builds on OGC API Features, so this
+ * class wraps the STAC catalog landing, collections listing, items, and
+ * cross-collection search endpoints. The wire calls live on
+ * `HonuaClient`; this class is the request-shaping layer on top.
+ *
+ * @module
+ */
+import type { HonuaClient } from "./client.js";
+import type { HonuaProtocolTransport } from "./protocol-transport.js";
+import type { HonuaOgcCollectionMetadata, HonuaOgcCollectionsResponse, HonuaStacItemCollectionResponse, HonuaStacItemResponse, HonuaStacLandingResponse, OgcCollectionRequest, OgcMetadataRequest, StacSearchRequest } from "./types.js";
+export interface HonuaStacSearchOptions {
+    client: HonuaClient;
+}
+export interface HonuaStacSearchAllRequest extends StacSearchRequest {
+    /** Maximum number of items to materialize across pages. */
+    pageSize?: number;
+    /** Hard cap on the number of pages to fetch (defaults to 100). */
+    maxPages?: number;
+}
+/**
+ * STAC API entry point. Discovery (`landing`, `collections`,
+ * `collection`) plus search (`search`, `searchAll`, `searchStream`) and
+ * item fetch.
+ */
+export declare class HonuaStacSearch {
+    readonly client: HonuaClient;
+    constructor(options: HonuaStacSearchOptions);
+    landing(request?: OgcMetadataRequest): Promise<HonuaStacLandingResponse>;
+    collections(request?: OgcMetadataRequest): Promise<HonuaOgcCollectionsResponse>;
+    collection(request: OgcCollectionRequest): Promise<HonuaOgcCollectionMetadata>;
+    item(request: {
+        collectionId: string | number;
+        itemId: string | number;
+        signal?: AbortSignal;
+        responseFormat?: string;
+        extraParams?: Record<string, string | number | boolean>;
+    }): Promise<HonuaStacItemResponse>;
+    search(request?: StacSearchRequest): Promise<HonuaStacItemCollectionResponse>;
+    searchAll(request?: HonuaStacSearchAllRequest): Promise<HonuaStacItemResponse[]>;
+    searchStream(request?: HonuaStacSearchAllRequest): AsyncGenerator<HonuaStacItemResponse[], void, undefined>;
+}
+export declare function createHonuaStacSearch(client: HonuaClient): HonuaStacSearch;
+export declare function getStacLanding(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaStacLandingResponse>;
+export declare function listStacCollections(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaOgcCollectionsResponse>;
+export declare function getStacCollection(transport: HonuaProtocolTransport, request: OgcCollectionRequest): Promise<HonuaOgcCollectionMetadata>;
+export declare function getStacItem(transport: HonuaProtocolTransport, request: {
+    collectionId: string | number;
+    itemId: string | number;
+    signal?: AbortSignal;
+    responseFormat?: string;
+    extraParams?: Record<string, string | number | boolean>;
+}): Promise<HonuaStacItemResponse>;
+export declare function searchStac(transport: HonuaProtocolTransport, request?: StacSearchRequest): Promise<HonuaStacItemCollectionResponse>;
+//# sourceMappingURL=stac.d.ts.map

package/core/stac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stac.d.ts","sourceRoot":"","sources":["../../../src/core/stac.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EACV,0BAA0B,EAC1B,2BAA2B,EAC3B,+BAA+B,EAC/B,qBAAqB,EACrB,wBAAwB,EACxB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,yBAA0B,SAAQ,iBAAiB;IAClE,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAKD;;;;GAIG;AACH,qBAAa,eAAe;IAC1B,SAAgB,MAAM,EAAE,WAAW,CAAC;gBAEjB,OAAO,EAAE,sBAAsB;IAIrC,OAAO,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAI5E,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAInF,UAAU,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAI9E,IAAI,CAAC,OAAO,EAAE;QACzB,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;QAC9B,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;QACxB,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;KACzD,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAIrB,MAAM,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,+BAA+B,CAAC;IAIjF,SAAS,CAAC,OAAO,GAAE,yBAA8B,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAyBnF,YAAY,CACxB,OAAO,GAAE,yBAA8B,GACtC,cAAc,CAAC,qBAAqB,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC;CAoB5D;AAkCD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,eAAe,CAE1E;AAID,wBAAsB,cAAc,CAClC,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,wBAAwB,CAAC,CAOnC;AAED,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,2BAA2B,CAAC,CAOtC;AAED,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,0BAA0B,CAAC,CAOrC;AAED,wBAAsB,WAAW,CAC/B,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE;IACP,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CACzD,GACA,OAAO,CAAC,qBAAqB,CAAC,CAMhC;AAED,wBAAsB,UAAU,CAC9B,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,+BAA+B,CAAC,CAmB1C"}