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

package/esri-compat/reactive-utils.js

@@ -0,0 +1,178 @@
+const DEFAULT_INTERVAL_MS = 16;
+const MAX_COMPARISON_DEPTH = 8;
+export function watch(getter, callback, options = {}) {
+    let active = true;
+    let hasValue = false;
+    let previousValue;
+    let previousComparable;
+    const intervalMs = normalizeInterval(options.intervalMs);
+    const evaluate = () => {
+        if (!active) {
+            return;
+        }
+        let currentValue;
+        try {
+            currentValue = getter();
+        }
+        catch {
+            return;
+        }
+        const currentComparable = createComparableValue(currentValue);
+        if (!hasValue) {
+            hasValue = true;
+            previousValue = currentValue;
+            previousComparable = currentComparable;
+            if (options.initial) {
+                callback(currentValue);
+                if (options.once) {
+                    remove();
+                }
+            }
+            return;
+        }
+        if (valuesEqual(currentValue, previousValue, currentComparable, previousComparable, options.equals)) {
+            return;
+        }
+        previousValue = currentValue;
+        previousComparable = currentComparable;
+        callback(currentValue);
+        if (options.once) {
+            remove();
+        }
+    };
+    const timer = setInterval(evaluate, intervalMs);
+    evaluate();
+    const remove = () => {
+        if (!active) {
+            return;
+        }
+        active = false;
+        clearInterval(timer);
+    };
+    return { remove };
+}
+export function when(getter, callback, options = {}) {
+    let active = true;
+    let seenTruthy = false;
+    let hasEvaluated = false;
+    const intervalMs = normalizeInterval(options.intervalMs);
+    const once = options.once ?? false;
+    const initial = options.initial ?? true;
+    const evaluate = () => {
+        if (!active) {
+            return;
+        }
+        let value;
+        try {
+            value = getter();
+        }
+        catch {
+            return;
+        }
+        const truthy = Boolean(value);
+        if (!truthy) {
+            seenTruthy = false;
+            hasEvaluated = true;
+            return;
+        }
+        const isFirstEvaluation = !hasEvaluated;
+        const shouldNotify = !seenTruthy && (!isFirstEvaluation || initial);
+        if (shouldNotify) {
+            callback(value);
+            if (once) {
+                remove();
+                return;
+            }
+        }
+        seenTruthy = true;
+        hasEvaluated = true;
+    };
+    const timer = setInterval(evaluate, intervalMs);
+    evaluate();
+    const remove = () => {
+        if (!active) {
+            return;
+        }
+        active = false;
+        clearInterval(timer);
+    };
+    return { remove };
+}
+export function whenOnce(getter, options = {}) {
+    return new Promise((resolve) => {
+        const handle = when(getter, (value) => {
+            handle.remove();
+            resolve(value);
+        }, {
+            ...options,
+            initial: true,
+            once: true,
+        });
+    });
+}
+export const reactiveUtils = {
+    watch,
+    when,
+    whenOnce,
+};
+function normalizeInterval(intervalMs) {
+    if (typeof intervalMs !== "number" || !Number.isFinite(intervalMs) || intervalMs < 1) {
+        return DEFAULT_INTERVAL_MS;
+    }
+    return Math.max(1, Math.trunc(intervalMs));
+}
+function valuesEqual(current, previous, currentComparable, previousComparable, equals) {
+    if (equals) {
+        return equals(current, previous);
+    }
+    return Object.is(currentComparable, previousComparable);
+}
+function createComparableValue(value) {
+    if (Array.isArray(value) || isPlainObject(value)) {
+        return stableSerialize(value, 0, new WeakSet());
+    }
+    return value;
+}
+function stableSerialize(value, depth, seen) {
+    if (value === null) {
+        return "null";
+    }
+    if (depth >= MAX_COMPARISON_DEPTH) {
+        return '"[MaxDepth]"';
+    }
+    const valueType = typeof value;
+    if (valueType === "string") {
+        return JSON.stringify(value);
+    }
+    if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
+        return String(value);
+    }
+    if (valueType === "undefined") {
+        return "undefined";
+    }
+    if (valueType !== "object") {
+        return valueType;
+    }
+    if (seen.has(value)) {
+        return '"[Circular]"';
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const serialized = `[${value.map((entry) => stableSerialize(entry, depth + 1, seen)).join(",")}]`;
+        seen.delete(value);
+        return serialized;
+    }
+    const entries = Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entryValue]) => `${JSON.stringify(key)}:${stableSerialize(entryValue, depth + 1, seen)}`);
+    const serialized = `{${entries.join(",")}}`;
+    seen.delete(value);
+    return serialized;
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/esri-compat/request.d.ts

@@ -0,0 +1,41 @@
+import type { HonuaRequestInterceptor } from "../core/types.js";
+export type EsriUrlPattern = string | RegExp;
+export interface EsriRequestOptionsLike {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: BodyInit | null;
+}
+export interface EsriBeforeRequestParams {
+    url: string;
+    requestOptions: EsriRequestOptionsLike;
+}
+export interface EsriRequestInterceptorCompat {
+    urls?: EsriUrlPattern | readonly EsriUrlPattern[];
+    before?(params: EsriBeforeRequestParams): void | Promise<void>;
+    after?(response: Response): void | Promise<void>;
+    error?(error: unknown): void | Promise<void>;
+}
+export interface ArcGisTokenInterceptorOptions {
+    getToken(): string | undefined | Promise<string | undefined>;
+    applyTo?: EsriUrlPattern | readonly EsriUrlPattern[];
+    mode?: "query" | "bearer";
+    queryParamName?: string;
+    headerName?: string;
+    bearerPrefix?: string;
+}
+export interface EsriRequestInterceptorHandle {
+    remove(): void;
+}
+export declare function createEsriRequestInterceptors(interceptors: readonly EsriRequestInterceptorCompat[]): HonuaRequestInterceptor[];
+export declare class EsriRequestInterceptorRegistry {
+    private readonly interceptorsInternal;
+    constructor(initialInterceptors?: readonly EsriRequestInterceptorCompat[]);
+    get interceptors(): readonly EsriRequestInterceptorCompat[];
+    add(interceptor: EsriRequestInterceptorCompat): EsriRequestInterceptorHandle;
+    remove(interceptor: EsriRequestInterceptorCompat): boolean;
+    clear(): void;
+    toHonuaInterceptors(): HonuaRequestInterceptor[];
+    asHonuaInterceptor(): HonuaRequestInterceptor;
+}
+export declare function createArcGisTokenInterceptor(options: ArcGisTokenInterceptorOptions): HonuaRequestInterceptor;
+//# sourceMappingURL=request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../src/esri-compat/request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuB,uBAAuB,EAAqC,MAAM,kBAAkB,CAAC;AAExH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC;AAE7C,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,sBAAsB,CAAC;CACxC;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,CAAC,EAAE,cAAc,GAAG,SAAS,cAAc,EAAE,CAAC;IAClD,MAAM,CAAC,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D,KAAK,CAAC,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,KAAK,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,IAAI,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7D,OAAO,CAAC,EAAE,cAAc,GAAG,SAAS,cAAc,EAAE,CAAC;IACrD,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,4BAA4B;IAC3C,MAAM,IAAI,IAAI,CAAC;CAChB;AAID,wBAAgB,6BAA6B,CAC3C,YAAY,EAAE,SAAS,4BAA4B,EAAE,GACpD,uBAAuB,EAAE,CAE3B;AAED,qBAAa,8BAA8B;IACzC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAiC;gBAEnD,mBAAmB,GAAE,SAAS,4BAA4B,EAAO;IAIpF,IAAW,YAAY,IAAI,SAAS,4BAA4B,EAAE,CAEjE;IAEM,GAAG,CAAC,WAAW,EAAE,4BAA4B,GAAG,4BAA4B;IAS5E,MAAM,CAAC,WAAW,EAAE,4BAA4B,GAAG,OAAO;IAS1D,KAAK,IAAI,IAAI;IAIb,mBAAmB,IAAI,uBAAuB,EAAE;IAIhD,kBAAkB,IAAI,uBAAuB;CA0CrD;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,6BAA6B,GAAG,uBAAuB,CAiC5G"}

package/esri-compat/request.js

@@ -0,0 +1,253 @@
+const VALID_QUERY_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+export function createEsriRequestInterceptors(interceptors) {
+    return interceptors.map((interceptor) => createHonuaInterceptorFromEsri(interceptor));
+}
+export class EsriRequestInterceptorRegistry {
+    interceptorsInternal;
+    constructor(initialInterceptors = []) {
+        this.interceptorsInternal = [...initialInterceptors];
+    }
+    get interceptors() {
+        return [...this.interceptorsInternal];
+    }
+    add(interceptor) {
+        this.interceptorsInternal.push(interceptor);
+        return {
+            remove: () => {
+                this.remove(interceptor);
+            },
+        };
+    }
+    remove(interceptor) {
+        const index = this.interceptorsInternal.indexOf(interceptor);
+        if (index < 0) {
+            return false;
+        }
+        this.interceptorsInternal.splice(index, 1);
+        return true;
+    }
+    clear() {
+        this.interceptorsInternal.length = 0;
+    }
+    toHonuaInterceptors() {
+        return createEsriRequestInterceptors(this.interceptorsInternal);
+    }
+    asHonuaInterceptor() {
+        return {
+            before: async (context) => {
+                let currentContext = cloneRequestContext(context);
+                let applied = false;
+                for (const interceptor of this.interceptorsInternal) {
+                    if (!interceptor.before || !matchesPattern(currentContext.url, interceptor.urls)) {
+                        continue;
+                    }
+                    const params = toEsriBeforeRequestParams(currentContext);
+                    await interceptor.before(params);
+                    const mutation = fromEsriBeforeRequestParams(currentContext, params);
+                    currentContext = applyMutationToContext(currentContext, mutation);
+                    applied = true;
+                }
+                return applied
+                    ? {
+                        url: currentContext.url,
+                        method: currentContext.method,
+                        init: currentContext.init,
+                    }
+                    : undefined;
+            },
+            after: async (context) => {
+                for (const interceptor of this.interceptorsInternal) {
+                    if (!interceptor.after || !matchesPattern(context.request.url, interceptor.urls)) {
+                        continue;
+                    }
+                    await interceptor.after(context.response);
+                }
+            },
+            error: async (context) => {
+                for (const interceptor of this.interceptorsInternal) {
+                    if (!interceptor.error || !matchesPattern(context.request.url, interceptor.urls)) {
+                        continue;
+                    }
+                    await interceptor.error(context.error);
+                }
+            },
+        };
+    }
+}
+export function createArcGisTokenInterceptor(options) {
+    const mode = options.mode ?? "query";
+    const queryParamName = options.queryParamName ?? "token";
+    const headerName = options.headerName ?? "Authorization";
+    const bearerPrefix = options.bearerPrefix ?? "Bearer";
+    return {
+        before: async (context) => {
+            if (!matchesPattern(context.url, options.applyTo)) {
+                return undefined;
+            }
+            const token = await options.getToken();
+            if (!token) {
+                return undefined;
+            }
+            if (mode === "query") {
+                return {
+                    url: setQueryParam(context.url, queryParamName, token),
+                };
+            }
+            const headers = headersToRecord(context.init.headers);
+            headers[headerName] = bearerPrefix.trim().length > 0 ? `${bearerPrefix} ${token}` : token;
+            return {
+                init: {
+                    ...context.init,
+                    headers,
+                },
+            };
+        },
+    };
+}
+function normalizeMethod(method, fallback) {
+    if (typeof method !== "string") {
+        return fallback;
+    }
+    const upper = method.trim().toUpperCase();
+    if (VALID_QUERY_METHODS.has(upper)) {
+        return upper;
+    }
+    return fallback;
+}
+function createHonuaInterceptorFromEsri(interceptor) {
+    return {
+        before: async (context) => {
+            if (!matchesPattern(context.url, interceptor.urls) || !interceptor.before) {
+                return undefined;
+            }
+            const params = toEsriBeforeRequestParams(context);
+            await interceptor.before(params);
+            return fromEsriBeforeRequestParams(context, params);
+        },
+        after: async (context) => {
+            if (!matchesPattern(context.request.url, interceptor.urls)) {
+                return;
+            }
+            await interceptor.after?.(context.response);
+        },
+        error: async (context) => {
+            if (!matchesPattern(context.request.url, interceptor.urls)) {
+                return;
+            }
+            await interceptor.error?.(context.error);
+        },
+    };
+}
+function toEsriBeforeRequestParams(context) {
+    return {
+        url: context.url,
+        requestOptions: {
+            method: context.method,
+            headers: headersToRecord(context.init.headers),
+            body: context.init.body,
+        },
+    };
+}
+function fromEsriBeforeRequestParams(context, params) {
+    const method = normalizeMethod(params.requestOptions.method, context.method);
+    return {
+        url: params.url,
+        method,
+        init: {
+            ...context.init,
+            method,
+            headers: params.requestOptions.headers,
+            body: params.requestOptions.body,
+        },
+    };
+}
+function applyMutationToContext(context, mutation) {
+    const method = mutation.method ?? context.method;
+    const nextInit = mutation.init === undefined
+        ? context.init
+        : {
+            ...context.init,
+            ...mutation.init,
+            method,
+        };
+    return {
+        ...context,
+        url: mutation.url ?? context.url,
+        method,
+        init: nextInit,
+    };
+}
+function cloneRequestContext(context) {
+    return {
+        ...context,
+        init: {
+            ...context.init,
+            headers: headersToRecord(context.init.headers),
+        },
+    };
+}
+function matchesPattern(url, pattern) {
+    if (!pattern) {
+        return true;
+    }
+    const patterns = Array.isArray(pattern) ? pattern : [pattern];
+    return patterns.some((candidate) => typeof candidate === "string" ? matchesStringPattern(url, candidate) : matchesRegExpPattern(url, candidate));
+}
+function matchesStringPattern(url, pattern) {
+    if (!pattern) {
+        return true;
+    }
+    if (url === pattern) {
+        return true;
+    }
+    const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const boundaryRegex = new RegExp(`${escapedPattern}(?=$|[/?#])`, "g");
+    return boundaryRegex.test(url);
+}
+function matchesRegExpPattern(url, pattern) {
+    if (!pattern.global && !pattern.sticky) {
+        return pattern.test(url);
+    }
+    pattern.lastIndex = 0;
+    const matched = pattern.test(url);
+    pattern.lastIndex = 0;
+    return matched;
+}
+function headersToRecord(headers) {
+    if (!headers) {
+        return {};
+    }
+    const record = {};
+    if (headers instanceof Headers) {
+        for (const [key, value] of headers.entries()) {
+            record[key] = value;
+        }
+        return record;
+    }
+    if (Array.isArray(headers)) {
+        for (const [key, value] of headers) {
+            record[key] = value;
+        }
+        return record;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined) {
+            continue;
+        }
+        record[key] = String(value);
+    }
+    return record;
+}
+function setQueryParam(urlText, key, value) {
+    const hashIndex = urlText.indexOf("#");
+    const hash = hashIndex >= 0 ? urlText.slice(hashIndex) : "";
+    const withoutHash = hashIndex >= 0 ? urlText.slice(0, hashIndex) : urlText;
+    const queryIndex = withoutHash.indexOf("?");
+    const path = queryIndex >= 0 ? withoutHash.slice(0, queryIndex) : withoutHash;
+    const existingQuery = queryIndex >= 0 ? withoutHash.slice(queryIndex + 1) : "";
+    const params = new URLSearchParams(existingQuery);
+    params.set(key, value);
+    const nextQuery = params.toString();
+    const withQuery = nextQuery.length > 0 ? `${path}?${nextQuery}` : path;
+    return `${withQuery}${hash}`;
+}

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

@@ -0,0 +1,59 @@
+import { CompatEventBus } from "./event-bus.js";
+export interface RouteStopCompat {
+    name?: string;
+    location: [number, number];
+}
+export interface RouteSolveResultCompat {
+    path: [number, number][];
+    totalLengthMeters: number;
+    totalTimeSeconds: number;
+}
+export interface RouteLayerCompatOptions {
+    id?: string;
+    title?: string;
+    url?: string;
+    visible?: boolean;
+    opacity?: number;
+    listMode?: "show" | "hide";
+    stops?: readonly RouteStopCompat[];
+    autoSolve?: boolean;
+    routeProvider?: (stops: readonly RouteStopCompat[], options: RouteLayerCompat) => Promise<RouteSolveResultCompat> | RouteSolveResultCompat;
+    eventBus?: CompatEventBus;
+}
+export type RouteLayerLoadStatusCompat = "not-loaded" | "loading" | "loaded";
+export interface RouteLayerHandleCompat {
+    remove(): void;
+}
+export declare class RouteLayerCompat {
+    readonly type: "route";
+    id: string | undefined;
+    title: string | undefined;
+    url: string | undefined;
+    visible: boolean;
+    opacity: number;
+    listMode: "show" | "hide";
+    readonly eventBus: CompatEventBus;
+    route: RouteSolveResultCompat | undefined;
+    readonly autoSolve: boolean;
+    solving: boolean;
+    loaded: boolean;
+    loadStatus: RouteLayerLoadStatusCompat;
+    private readonly stopsInternal;
+    private readonly routeProvider;
+    private readonly watchListeners;
+    constructor(options?: RouteLayerCompatOptions);
+    get stops(): readonly RouteStopCompat[];
+    load(): Promise<RouteLayerCompat>;
+    watch(propertyName: string, listener: (value: unknown) => void): RouteLayerHandleCompat;
+    addStop(stop: RouteStopCompat, index?: number): void;
+    addStops(stops: readonly RouteStopCompat[], index?: number): void;
+    clearStops(): void;
+    solve(): Promise<RouteSolveResultCompat | undefined>;
+    refresh(): Promise<RouteSolveResultCompat | undefined>;
+    when(callback?: (layer: RouteLayerCompat) => void): Promise<RouteLayerCompat>;
+    destroy(): void;
+    setVisibility(visible: boolean): void;
+    setOpacity(opacity: number): void;
+    private notifyWatchers;
+}
+//# sourceMappingURL=route-layer.d.ts.map

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

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