@honua/react 0.0.20-alpha.0

package/core/path-utils.js

@@ -0,0 +1,123 @@
+/**
+ * Linear-time string trimming helpers used for URL and path normalization.
+ *
+ * These intentionally avoid regular expressions such as `\/+$` or `^\/+`.
+ * Anchored quantifier regexes over repeated characters can exhibit
+ * super-linear (polynomial) matching on adversarial input, so the helpers
+ * below scan from the relevant end with simple index arithmetic, which is
+ * always O(n) regardless of input shape.
+ */
+/** Remove every trailing `/` character from `value`. */
+export function trimTrailingSlashes(value) {
+    let end = value.length;
+    while (end > 0 && value.charCodeAt(end - 1) === 47 /* '/' */) {
+        end -= 1;
+    }
+    return end === value.length ? value : value.slice(0, end);
+}
+/** Remove every leading `/` character from `value`. */
+export function trimLeadingSlashes(value) {
+    let start = 0;
+    while (start < value.length && value.charCodeAt(start) === 47 /* '/' */) {
+        start += 1;
+    }
+    return start === 0 ? value : value.slice(start);
+}
+/** Remove every leading and trailing `/` character from `value`. */
+export function trimSurroundingSlashes(value) {
+    return trimTrailingSlashes(trimLeadingSlashes(value));
+}
+/**
+ * Remove leading and trailing runs of `char` from `value`.
+ *
+ * `char` must be a single-character string; only its first code unit is
+ * considered. Used for slug/identifier normalization (e.g. stripping `-`
+ * or `_` padding) without anchored `^x+|x+$` regexes.
+ */
+export function trimChar(value, char) {
+    const code = char.charCodeAt(0);
+    let start = 0;
+    let end = value.length;
+    while (start < end && value.charCodeAt(start) === code) {
+        start += 1;
+    }
+    while (end > start && value.charCodeAt(end - 1) === code) {
+        end -= 1;
+    }
+    return start === 0 && end === value.length ? value : value.slice(start, end);
+}
+/**
+ * Return `value` with any `?query` and `#fragment` suffix removed.
+ *
+ * Equivalent to `value.replace(/[?#].*$/, "")` but uses `indexOf` slicing
+ * so it stays linear and cannot backtrack.
+ */
+export function stripQueryAndFragment(value) {
+    let cut = -1;
+    for (let i = 0; i < value.length; i += 1) {
+        const code = value.charCodeAt(i);
+        if (code === 63 /* '?' */ || code === 35 /* '#' */) {
+            cut = i;
+            break;
+        }
+    }
+    return cut < 0 ? value : value.slice(0, cut);
+}
+/**
+ * Return `value` with any `?query` suffix removed (the fragment, if present,
+ * is preserved). Equivalent to `value.replace(/\?.*$/, "")`.
+ */
+export function stripQuery(value) {
+    const index = value.indexOf("?");
+    return index < 0 ? value : value.slice(0, index);
+}
+/**
+ * Encode an Esri-style `serviceId` for use as a URL path segment, preserving
+ * folder structure.
+ *
+ * Esri/GeoServices services may be folder-organized, e.g.
+ * `MyFolder/MyService`. Naively passing the whole id through
+ * `encodeURIComponent` percent-encodes the `/` separator (`%2F`), collapsing
+ * the folder and service into a single path segment that the server cannot
+ * route. This helper splits on `/`, encodes each non-empty segment
+ * individually, and rejoins with `/` so the folder path is preserved while
+ * special characters within a segment (spaces, `&`, etc.) are still encoded.
+ *
+ * A plain `serviceId` without slashes behaves exactly like
+ * `encodeURIComponent(serviceId)`. Empty segments produced by leading,
+ * trailing, or doubled slashes are dropped so the result never contains
+ * stray `/` runs. Use {@link encodePathSegments} instead when empty segments
+ * must be preserved verbatim.
+ */
+export function encodeServiceIdPath(serviceId) {
+    if (!serviceId.includes("/")) {
+        return encodeURIComponent(serviceId);
+    }
+    return serviceId
+        .split("/")
+        .filter((segment) => segment.length > 0)
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+}
+/**
+ * Percent-encode a path that may contain `/` separators, encoding each
+ * segment independently so the separators survive.
+ *
+ * `encodeURIComponent("a/b")` returns `a%2Fb`, which is wrong for
+ * folder-prefixed identifiers such as `myFolder/parcels` that must serialize
+ * as `myFolder/parcels` on the wire. Splitting on `/` and encoding each
+ * segment keeps the separators literal while still escaping reserved
+ * characters inside each segment. Empty segments (leading/trailing/double
+ * slashes) are preserved verbatim so callers retain full control over the
+ * resulting path shape. Use {@link encodeServiceIdPath} when empty segments
+ * should instead be dropped (e.g. routable Esri service ids).
+ */
+export function encodePathSegments(value) {
+    if (!value.includes("/")) {
+        return encodeURIComponent(value);
+    }
+    return value
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+}

package/core/pbf-decoder.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Minimal protobuf wire-format reader and Esri PBF query response decoder.
+ *
+ * Decodes `FeatureCollectionPBuffer` responses (from `f=pbf`) into the same
+ * JSON-compatible shape as `f=json`, making the binary format transparent
+ * to callers.
+ *
+ * No external protobuf library dependency. Implements only the subset of
+ * the wire format needed for the Esri PBF query schema.
+ *
+ * @module
+ */
+/**
+ * Thrown when a PBF feature response cannot be decoded losslessly into the
+ * `f=json` shape — either because it carries Z/M geometry (which the flat
+ * 2D fast-path decoder would silently garble) or because the coordinate
+ * stream is malformed (odd length / non-finite values from a truncated or
+ * hostile payload). `HonuaClient` treats this as a signal to fall back to a
+ * fresh `f=json` request, which decodes the same data correctly.
+ */
+export declare class PbfDecodeError extends Error {
+    constructor(message: string);
+}
+/**
+ * Decode an Esri FeatureCollectionPBuffer response into a JSON-compatible
+ * query response object.
+ *
+ * The returned object has the same shape as an `f=json` response:
+ * `{ objectIdFieldName, geometryType, spatialReference, fields, features, ... }`
+ *
+ * @param buffer - The raw PBF bytes from a `f=pbf` response.
+ * @returns A JSON-compatible query response object.
+ */
+export declare function decodePbfQueryResponse(buffer: ArrayBuffer | Uint8Array): Record<string, unknown>;
+/**
+ * Check whether a Response has a protobuf content type.
+ */
+export declare function isPbfResponse(response: Response): boolean;
+//# sourceMappingURL=pbf-decoder.d.ts.map

package/core/pbf-decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbf-decoder.d.ts","sourceRoot":"","sources":["../../../src/core/pbf-decoder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,KAAK;gBACpB,OAAO,EAAE,MAAM;CAInC;AA+nBD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiChG;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAGzD"}