@honua/react 0.1.0-beta.0 → 0.1.2-beta.0

package/core/odata.js

@@ -15,7 +15,34 @@
  * @module
  */
 import { createHonuaCacheState, honuaCacheValidatorFromHeaders, honuaMetadataRequestHeaders, isHonuaCacheEntryFresh, normalizeHonuaMetadataRequestOptions, withHonuaCacheState, withoutHonuaCacheState, } from "./cache-state.js";
+import { encodeOdataKeyPredicatePath } from "./odata-key-path.js";
 import { trimTrailingSlashes } from "./path-utils.js";
+const MAX_ODATA_METADATA_CHARACTERS = 4 * 1024 * 1024;
+const ODATA_SOURCE_SCHEMA_PROJECTION_SAFETY = Symbol("honua.odata.source-schema-projection-safety");
+const ODATA_SOURCE_SCHEMA_PROJECTION_DETAILS = Symbol("honua.odata.source-schema-projection-details");
+/** @internal Read parser evidence without changing the legacy string-keyed metadata shape. */
+export function getOdataSourceSchemaProjectionSafety(metadata) {
+    return odataProjectionEvidence(metadata, ODATA_SOURCE_SCHEMA_PROJECTION_SAFETY);
+}
+/** @internal Read rich CSDL state without changing the legacy string-keyed metadata shape. */
+export function getOdataSourceSchemaProjectionDetails(metadata) {
+    return odataProjectionEvidence(metadata, ODATA_SOURCE_SCHEMA_PROJECTION_DETAILS);
+}
+function odataProjectionEvidence(metadata, key) {
+    let descriptor;
+    try {
+        descriptor = Object.getOwnPropertyDescriptor(metadata, key);
+    }
+    catch {
+        throw new TypeError("OData metadata projection evidence is inaccessible");
+    }
+    if (!descriptor)
+        return undefined;
+    if (!("value" in descriptor)) {
+        throw new TypeError("OData metadata projection evidence must be a data property");
+    }
+    return descriptor.value;
+}
 // ── Runtime class ─────────────────────────────────────────────
 /**
  * Runtime handle for one OData entity set. Returned by
@@ -166,7 +193,7 @@ export class HonuaOdataEntitySet {
     async add(body, options = {}) {
         const path = this.entitySetPath();
         return this.requestJson("POST", path, undefined, options.signal, JSON.stringify(body), {
-            "Content-Type": "application/json",
+            "Content-Type": options.contentType ?? "application/json",
         });
     }
     /**
@@ -177,14 +204,14 @@ export class HonuaOdataEntitySet {
      * `docs/protocol-capability-matrix.md` under the OData section).
      */
     async update(key, body, options = {}) {
-        const path = `${this.entitySetPath()}(${encodeOdataKey(key)})`;
+        const path = `${this.entitySetPath()}(${encodeOdataKeyPredicatePath(key)})`;
         return this.requestJson("PATCH", path, undefined, options.signal, JSON.stringify(body), {
-            "Content-Type": "application/json",
+            "Content-Type": options.contentType ?? "application/json",
         });
     }
     /** Delete a row via `DELETE /<entitySet>(<key>)`. */
     async delete(key, options = {}) {
-        const path = `${this.entitySetPath()}(${encodeOdataKey(key)})`;
+        const path = `${this.entitySetPath()}(${encodeOdataKeyPredicatePath(key)})`;
         await this.requestJson("DELETE", path, undefined, options.signal);
     }
     /**
@@ -210,9 +237,7 @@ export class HonuaOdataEntitySet {
             url: stripLeadingSlash(op.url),
             ...(op.headers
                 ? { headers: { "Content-Type": "application/json", ...op.headers } }
-                : {
-                    headers: { "Content-Type": "application/json" },
-                }),
+                : { headers: { "Content-Type": "application/json" } }),
             ...(op.body !== undefined ? { body: op.body } : {}),
             ...(groupId !== undefined ? { atomicityGroup: groupId } : {}),
         }));
@@ -390,46 +415,6 @@ function ensureLeadingSlash(path) {
 function stripLeadingSlash(path) {
     return path.startsWith("/") ? path.slice(1) : path;
 }
-/**
- * Make an OData entity key safe to interpolate into the URL path segment
- * `<entitySet>(<key>)`. A raw key containing characters such as `&`, `?`,
- * `#`, `/`, space, or `'` would otherwise split or mis-target the path
- * (e.g. `Customers(A&B)`).
- *
- * The key is treated as an OData literal: single-quoted spans are kept as
- * quoted string literals (with embedded `'` doubled per OData v4 §5.1.1.6.1),
- * and structural characters that delimit composite keys (`,`, `=`) and
- * literal quotes are preserved. Everything else is percent-encoded so the
- * resulting segment is a single, correctly-targeted URL path component.
- */
-function encodeOdataKey(key) {
-    const raw = String(key);
-    let out = "";
-    let inQuote = false;
-    for (let i = 0; i < raw.length; i += 1) {
-        const ch = raw[i];
-        if (ch === "'") {
-            // Toggle quoted-literal state and keep the (URL-safe) quote verbatim.
-            inQuote = !inQuote;
-            out += "'";
-            continue;
-        }
-        if (!inQuote && (ch === "," || ch === "=")) {
-            // Composite-key delimiters stay structural outside quoted spans.
-            out += ch;
-            continue;
-        }
-        // Percent-encode anything that is unsafe in a path segment. Unreserved
-        // characters (RFC 3986) pass through untouched.
-        if (/[A-Za-z0-9\-._~]/.test(ch)) {
-            out += ch;
-        }
-        else {
-            out += encodeURIComponent(ch);
-        }
-    }
-    return out;
-}
 /**
  * Translate canonical query params onto the OData `$`-prefixed query
  * string. Empty strings, undefined values, and zero-length lists are
@@ -491,18 +476,24 @@ function ensureTrailingSlash(url) {
  * well-defined by OData CSDL §6 and the Honua Server spec page.
  */
 export function parseOdataMetadata(xml) {
-    const entitySets = {};
-    const keys = {};
-    const fields = {};
-    const capabilities = {};
+    if (xml.length > MAX_ODATA_METADATA_CHARACTERS) {
+        throw new RangeError(`OData metadata exceeds ${MAX_ODATA_METADATA_CHARACTERS} characters`);
+    }
+    const entitySets = Object.create(null);
+    const keys = Object.create(null);
+    const fields = Object.create(null);
+    const projectionFields = Object.create(null);
+    const complexTypes = Object.create(null);
+    const enumTypes = Object.create(null);
+    const openTypes = Object.create(null);
+    const capabilities = Object.create(null);
     // Sibling annotations: <Annotations Target="<schema>.<container>/<entitySet>">
     // …</Annotations>. Honua Server emits Capabilities.* this way (next to
     // the EntityContainer) rather than nesting them inside <EntitySet>, so
     // capability negotiation must merge both shapes.
     const siblingByEntitySet = new Map();
-    const siblingAnnotationsRe = /<Annotations\s+([^>]*?)>([\s\S]*?)<\/Annotations>/g;
-    for (const match of xml.matchAll(siblingAnnotationsRe)) {
-        const attrs = match[1] ?? "";
+    for (const element of xmlElements(xml, "Annotations")) {
+        const attrs = element.attributes;
         const target = readAttr(attrs, "Target");
         if (!target)
             continue;
@@ -512,20 +503,19 @@ export function parseOdataMetadata(xml) {
         const setName = target.slice(slash + 1);
         if (!setName)
             continue;
-        const body = match[2] ?? "";
+        const body = element.body;
         const existing = siblingByEntitySet.get(setName);
         siblingByEntitySet.set(setName, existing === undefined ? body : `${existing}\n${body}`);
     }
     // Entity sets: <EntitySet Name="Foo" EntityType="ns.FooEntity"/>
-    const entitySetRe = /<EntitySet\s+([^>]*?)\/>|<EntitySet\s+([^>]*?)>([\s\S]*?)<\/EntitySet>/g;
-    for (const match of xml.matchAll(entitySetRe)) {
-        const attrs = match[1] ?? match[2] ?? "";
+    for (const element of xmlElements(xml, "EntitySet")) {
+        const attrs = element.attributes;
         const name = readAttr(attrs, "Name");
         const type = readAttr(attrs, "EntityType");
         if (!name || !type)
             continue;
         entitySets[name] = stripNamespace(type);
-        const inlineBody = match[3] ?? "";
+        const inlineBody = element.body;
         const siblingBody = siblingByEntitySet.get(name) ?? "";
         capabilities[name] = parseEntitySetAnnotations(`${inlineBody}\n${siblingBody}`);
         siblingByEntitySet.delete(name);
@@ -537,48 +527,242 @@ export function parseOdataMetadata(xml) {
         capabilities[setName] = parseEntitySetAnnotations(body);
     }
     // Entity types: <EntityType Name="FooEntity">…<Key><PropertyRef Name="Id"/></Key><Property…/>…</EntityType>
-    const entityTypeRe = /<EntityType\s+([^>]*?)>([\s\S]*?)<\/EntityType>/g;
-    for (const match of xml.matchAll(entityTypeRe)) {
-        const attrs = match[1] ?? "";
-        const body = match[2] ?? "";
+    for (const element of xmlElements(xml, "EntityType")) {
+        const attrs = element.attributes;
+        const body = element.body;
         const name = readAttr(attrs, "Name");
         if (!name)
             continue;
+        if (readAttr(attrs, "OpenType")?.toLowerCase() === "true")
+            openTypes[name] = true;
         const keyNames = [];
-        const keyBlock = /<Key>([\s\S]*?)<\/Key>/.exec(body);
-        if (keyBlock) {
-            for (const ref of keyBlock[1].matchAll(/<PropertyRef\s+([^>]*?)\/>/g)) {
-                const refName = readAttr(ref[1], "Name");
+        const keyBlock = xmlElements(body, "Key").next();
+        if (!keyBlock.done) {
+            for (const refAttrs of xmlStartTags(keyBlock.value.body, "PropertyRef")) {
+                const refName = readAttr(refAttrs, "Name");
                 if (refName)
                     keyNames.push(refName);
             }
         }
         keys[name] = keyNames;
-        const props = [];
-        for (const propMatch of body.matchAll(/<Property\s+([^>]*?)\/>|<Property\s+([^>]*?)>/g)) {
-            const propAttrs = propMatch[1] ?? propMatch[2] ?? "";
-            const propName = readAttr(propAttrs, "Name");
-            const propType = readAttr(propAttrs, "Type");
-            if (!propName || !propType)
+        const richFields = parseOdataProperties(body);
+        projectionFields[name] = richFields;
+        fields[name] = richFields.map(legacyOdataFieldInfo);
+    }
+    for (const element of xmlElements(xml, "ComplexType")) {
+        const name = readAttr(element.attributes, "Name");
+        if (name)
+            complexTypes[name] = parseOdataProperties(element.body);
+    }
+    for (const element of xmlElements(xml, "EnumType")) {
+        const attrs = element.attributes;
+        const name = readAttr(attrs, "Name");
+        if (!name)
+            continue;
+        const underlyingType = readAttr(attrs, "UnderlyingType") ?? "Edm.Int32";
+        const isFlags = readAttr(attrs, "IsFlags")?.toLowerCase() === "true";
+        const declarations = [...xmlStartTags(element.body, "Member")].map((memberAttrs) => ({
+            name: readAttr(memberAttrs, "Name"),
+            rawValue: readAttr(memberAttrs, "Value"),
+        }));
+        const hasExplicit = declarations.some((member) => member.rawValue !== undefined);
+        const hasImplicit = declarations.some((member) => member.rawValue === undefined);
+        const valueMode = hasExplicit ? (hasImplicit ? "mixed" : "explicit") : "implicit";
+        let declarationReason;
+        const invalidate = (reason) => {
+            declarationReason ??= reason;
+        };
+        const bounds = odataEnumBounds(underlyingType);
+        if (declarations.length === 0)
+            invalidate("empty-declaration");
+        if (!bounds)
+            invalidate("invalid-underlying-type");
+        if (isFlags && hasImplicit)
+            invalidate("flags-require-explicit-values");
+        const members = [];
+        const names = new Set();
+        let previousValue;
+        for (const [index, declaration] of declarations.entries()) {
+            let parsed;
+            if (declaration.rawValue === undefined) {
+                if (!isFlags) {
+                    parsed = index === 0 ? 0n : previousValue === undefined ? undefined : previousValue + 1n;
+                }
+            }
+            else if (declaration.rawValue.length <= 20 && /^[+-]?\d+$/.test(declaration.rawValue)) {
+                try {
+                    parsed = BigInt(declaration.rawValue);
+                }
+                catch {
+                    parsed = undefined;
+                }
+            }
+            if (parsed === undefined)
+                invalidate("invalid-member-value");
+            else if (isFlags && parsed < 0n)
+                invalidate("negative-flags-value");
+            else if (bounds && (parsed < bounds.minimum || parsed > bounds.maximum))
+                invalidate("out-of-range");
+            previousValue = parsed;
+            if (!declaration.name || !odataSimpleIdentifier(declaration.name)) {
+                invalidate("invalid-member-name");
+                continue;
+            }
+            if (names.has(declaration.name))
+                invalidate("duplicate-member-name");
+            names.add(declaration.name);
+            if (parsed === undefined)
                 continue;
-            const nullable = readAttr(propAttrs, "Nullable");
-            const sridAttr = readAttr(propAttrs, "SRID");
-            const isSpatial = propType.startsWith("Edm.Geography") || propType.startsWith("Edm.Geometry");
-            const info = { name: propName, type: propType };
-            if (nullable !== undefined)
-                info.nullable = nullable !== "false";
-            if (isSpatial)
-                info.isSpatial = true;
-            if (sridAttr !== undefined) {
-                const srid = Number(sridAttr);
-                if (Number.isFinite(srid))
-                    info.srid = srid;
+            const value = underlyingType === "Edm.Int64" || !Number.isSafeInteger(Number(parsed)) ? parsed.toString() : Number(parsed);
+            members.push({ name: declaration.name, value });
+        }
+        enumTypes[name] = {
+            underlyingType,
+            isFlags,
+            members,
+            declaration: declarationReason ? { state: "invalid", reason: declarationReason } : { state: "valid", valueMode },
+        };
+    }
+    const metadata = {
+        entitySets,
+        keys,
+        fields,
+        capabilities,
+    };
+    Object.defineProperty(metadata, ODATA_SOURCE_SCHEMA_PROJECTION_DETAILS, {
+        value: { fields: projectionFields, complexTypes, enumTypes, openTypes },
+        enumerable: true,
+    });
+    Object.defineProperty(metadata, ODATA_SOURCE_SCHEMA_PROJECTION_SAFETY, {
+        value: inspectOdataSourceSchemaProjectionSafety(xml),
+        enumerable: true,
+    });
+    return metadata;
+}
+function inspectOdataSourceSchemaProjectionSafety(xml) {
+    const edmxAttributes = firstXmlStartTagByLocalName(xml, "Edmx");
+    const csdlVersion = edmxAttributes === undefined ? undefined : readAttr(edmxAttributes, "Version");
+    const declarations = new Map();
+    const inheritedTypeNames = new Set();
+    const openComplexTypeNames = new Set();
+    const unqualifiedTypeNames = new Set();
+    for (const schema of xmlElements(xml, "Schema")) {
+        const namespace = readAttr(schema.attributes, "Namespace");
+        for (const kind of ["EntityType", "ComplexType", "EnumType"]) {
+            for (const attributes of xmlStartTags(schema.body, kind)) {
+                const name = readAttr(attributes, "Name");
+                if (!name)
+                    continue;
+                const qualifiedIdentity = `${kind}:${namespace ? `${namespace}.${name}` : name}`;
+                const identities = declarations.get(name) ?? new Map();
+                identities.set(qualifiedIdentity, (identities.get(qualifiedIdentity) ?? 0) + 1);
+                declarations.set(name, identities);
+                if (!namespace)
+                    unqualifiedTypeNames.add(name);
+                if (kind !== "EnumType" && readAttr(attributes, "BaseType"))
+                    inheritedTypeNames.add(name);
+                if (kind === "ComplexType" && readAttr(attributes, "OpenType")?.toLowerCase() === "true") {
+                    openComplexTypeNames.add(name);
+                }
             }
-            props.push(info);
         }
-        fields[name] = props;
     }
-    return { entitySets, keys, fields, capabilities };
+    const ambiguousTypeNames = [...declarations]
+        .filter(([, identities]) => identities.size > 1 || [...identities.values()].some((count) => count > 1))
+        .map(([name]) => name)
+        .sort();
+    return Object.freeze({
+        ...(csdlVersion === undefined ? {} : { csdlVersion }),
+        ambiguousTypeNames: Object.freeze(ambiguousTypeNames),
+        inheritedTypeNames: Object.freeze([...inheritedTypeNames].sort()),
+        openComplexTypeNames: Object.freeze([...openComplexTypeNames].sort()),
+        unqualifiedTypeNames: Object.freeze([...unqualifiedTypeNames].sort()),
+    });
+}
+function odataEnumBounds(underlyingType) {
+    switch (underlyingType) {
+        case "Edm.Byte":
+            return { minimum: 0n, maximum: 255n };
+        case "Edm.SByte":
+            return { minimum: -128n, maximum: 127n };
+        case "Edm.Int16":
+            return { minimum: -32768n, maximum: 32767n };
+        case "Edm.Int32":
+            return { minimum: -2147483648n, maximum: 2147483647n };
+        case "Edm.Int64":
+            return { minimum: -(1n << 63n), maximum: (1n << 63n) - 1n };
+        default:
+            return undefined;
+    }
+}
+function odataSimpleIdentifier(value) {
+    if (value.length > 256)
+        return false;
+    let codePoints = 0;
+    for (const _character of value) {
+        codePoints += 1;
+        if (codePoints > 128)
+            return false;
+    }
+    return /^[\p{L}\p{Nl}_][\p{L}\p{Nl}\p{Nd}\p{Mn}\p{Mc}\p{Pc}\p{Cf}]*$/u.test(value);
+}
+function parseOdataProperties(body) {
+    const props = [];
+    for (const propAttrs of xmlStartTags(body, "Property")) {
+        const propName = readAttr(propAttrs, "Name");
+        const propType = readAttr(propAttrs, "Type");
+        if (!propName || !propType)
+            continue;
+        const nullable = readAttr(propAttrs, "Nullable");
+        const maxLengthAttr = readAttr(propAttrs, "MaxLength");
+        const precisionAttr = readAttr(propAttrs, "Precision");
+        const scaleAttr = readAttr(propAttrs, "Scale");
+        const sridAttr = readAttr(propAttrs, "SRID");
+        const isSpatial = propType.startsWith("Edm.Geography") || propType.startsWith("Edm.Geometry");
+        const info = { name: propName, type: propType };
+        if (nullable !== undefined)
+            info.nullable = nullable !== "false";
+        if (maxLengthAttr?.toLowerCase() === "max")
+            info.maxLength = "max";
+        else if (maxLengthAttr !== undefined) {
+            const maxLength = Number(maxLengthAttr);
+            if (Number.isSafeInteger(maxLength) && maxLength >= 0)
+                info.maxLength = maxLength;
+        }
+        if (precisionAttr !== undefined) {
+            const precision = Number(precisionAttr);
+            if (Number.isSafeInteger(precision) && precision >= 0)
+                info.precision = precision;
+        }
+        if (scaleAttr?.toLowerCase() === "variable" || scaleAttr?.toLowerCase() === "floating") {
+            info.scale = scaleAttr.toLowerCase();
+        }
+        else if (scaleAttr !== undefined) {
+            const scale = Number(scaleAttr);
+            if (Number.isSafeInteger(scale) && scale >= 0)
+                info.scale = scale;
+        }
+        if (isSpatial)
+            info.isSpatial = true;
+        if (sridAttr?.toLowerCase() === "variable")
+            info.srid = "variable";
+        else if (sridAttr !== undefined) {
+            const srid = Number(sridAttr);
+            if (Number.isSafeInteger(srid) && srid >= 0)
+                info.srid = srid;
+        }
+        props.push(info);
+    }
+    return props;
+}
+function legacyOdataFieldInfo(field) {
+    return {
+        name: field.name,
+        type: field.type,
+        ...(field.nullable === undefined ? {} : { nullable: field.nullable }),
+        ...(field.isSpatial === true ? { isSpatial: true } : {}),
+        ...(typeof field.srid === "number" ? { srid: field.srid } : {}),
+    };
 }
 /**
  * Convenience: project the field schema for one entity set into the
@@ -614,12 +798,12 @@ function edmToHonuaFieldType(edm) {
 }
 function parseEntitySetAnnotations(body) {
     const out = {};
-    for (const match of body.matchAll(/<Annotation\s+([^>]*?)(?:\/>|>([\s\S]*?)<\/Annotation>)/g)) {
-        const attrs = match[1] ?? "";
+    for (const element of xmlElements(body, "Annotation")) {
+        const attrs = element.attributes;
         const term = readAttr(attrs, "Term");
         if (!term || !term.includes("Capabilities."))
             continue;
-        const inner = (match[2] ?? "").trim();
+        const inner = element.body.trim();
         const boolValue = readAttr(attrs, "Bool") ??
             matchBool(inner) ??
             matchPropertyValueBool(inner, "Insertable") ??
@@ -672,22 +856,170 @@ function parseEntitySetAnnotations(body) {
     return out;
 }
 function readAttr(attrs, name) {
-    const re = new RegExp(`${name}\\s*=\\s*"([^"]*)"`);
-    const match = re.exec(attrs);
-    return match ? match[1] : undefined;
+    let cursor = 0;
+    while (cursor < attrs.length) {
+        while (cursor < attrs.length && xmlWhitespace(attrs.charCodeAt(cursor)))
+            cursor += 1;
+        if (cursor >= attrs.length || attrs.charCodeAt(cursor) === 47)
+            return undefined;
+        const nameStart = cursor;
+        while (cursor < attrs.length) {
+            const code = attrs.charCodeAt(cursor);
+            if (xmlWhitespace(code) || code === 61 || code === 47 || code === 62)
+                break;
+            cursor += 1;
+        }
+        const attributeName = attrs.slice(nameStart, cursor);
+        while (cursor < attrs.length && xmlWhitespace(attrs.charCodeAt(cursor)))
+            cursor += 1;
+        if (attrs.charCodeAt(cursor) !== 61) {
+            cursor += 1;
+            continue;
+        }
+        cursor += 1;
+        while (cursor < attrs.length && xmlWhitespace(attrs.charCodeAt(cursor)))
+            cursor += 1;
+        const quote = attrs.charCodeAt(cursor);
+        if (quote !== 34 && quote !== 39) {
+            cursor += 1;
+            continue;
+        }
+        const valueStart = ++cursor;
+        while (cursor < attrs.length && attrs.charCodeAt(cursor) !== quote)
+            cursor += 1;
+        if (cursor >= attrs.length)
+            return undefined;
+        if (attributeName === name)
+            return attrs.slice(valueStart, cursor);
+        cursor += 1;
+    }
+    return undefined;
+}
+function* xmlElements(xml, tagName) {
+    const marker = `<${tagName}`;
+    const closing = `</${tagName}>`;
+    let cursor = 0;
+    while (cursor < xml.length) {
+        const start = findXmlTag(xml, marker, cursor);
+        if (start === -1)
+            return;
+        const tagEnd = findXmlTagEnd(xml, start + marker.length);
+        if (tagEnd === -1)
+            return;
+        const attributes = xml.slice(start + marker.length, tagEnd);
+        if (xmlSelfClosing(attributes)) {
+            yield { attributes, body: "" };
+            cursor = tagEnd + 1;
+            continue;
+        }
+        const closeStart = xml.indexOf(closing, tagEnd + 1);
+        if (closeStart === -1)
+            return;
+        yield { attributes, body: xml.slice(tagEnd + 1, closeStart) };
+        cursor = closeStart + closing.length;
+    }
+}
+function* xmlStartTags(xml, tagName) {
+    const marker = `<${tagName}`;
+    let cursor = 0;
+    while (cursor < xml.length) {
+        const start = findXmlTag(xml, marker, cursor);
+        if (start === -1)
+            return;
+        const tagEnd = findXmlTagEnd(xml, start + marker.length);
+        if (tagEnd === -1)
+            return;
+        yield xml.slice(start + marker.length, tagEnd);
+        cursor = tagEnd + 1;
+    }
+}
+function firstXmlStartTagByLocalName(xml, localName) {
+    let cursor = 0;
+    while (cursor < xml.length) {
+        const start = xml.indexOf("<", cursor);
+        if (start === -1)
+            return undefined;
+        const nameStart = start + 1;
+        const first = xml.charCodeAt(nameStart);
+        if (first === 33 || first === 47 || first === 63) {
+            cursor = nameStart + 1;
+            continue;
+        }
+        let nameEnd = nameStart;
+        while (nameEnd < xml.length) {
+            const code = xml.charCodeAt(nameEnd);
+            if (xmlWhitespace(code) || code === 47 || code === 62)
+                break;
+            nameEnd += 1;
+        }
+        const qualifiedName = xml.slice(nameStart, nameEnd);
+        const colon = qualifiedName.lastIndexOf(":");
+        if (qualifiedName.slice(colon + 1) === localName) {
+            const tagEnd = findXmlTagEnd(xml, nameEnd);
+            return tagEnd === -1 ? undefined : xml.slice(nameEnd, tagEnd);
+        }
+        cursor = nameEnd > nameStart ? nameEnd : nameStart + 1;
+    }
+    return undefined;
+}
+function findXmlTag(xml, marker, from) {
+    let cursor = from;
+    while (cursor < xml.length) {
+        const start = xml.indexOf(marker, cursor);
+        if (start === -1)
+            return -1;
+        const boundary = xml.charCodeAt(start + marker.length);
+        if (xmlWhitespace(boundary) || boundary === 47 || boundary === 62)
+            return start;
+        cursor = start + marker.length;
+    }
+    return -1;
+}
+function findXmlTagEnd(xml, from) {
+    let quote = 0;
+    for (let cursor = from; cursor < xml.length; cursor += 1) {
+        const code = xml.charCodeAt(cursor);
+        if (quote !== 0) {
+            if (code === quote)
+                quote = 0;
+        }
+        else if (code === 34 || code === 39) {
+            quote = code;
+        }
+        else if (code === 62) {
+            return cursor;
+        }
+    }
+    return -1;
+}
+function xmlSelfClosing(attributes) {
+    let cursor = attributes.length - 1;
+    while (cursor >= 0 && xmlWhitespace(attributes.charCodeAt(cursor)))
+        cursor -= 1;
+    return cursor >= 0 && attributes.charCodeAt(cursor) === 47;
+}
+function xmlWhitespace(code) {
+    return code === 9 || code === 10 || code === 13 || code === 32;
 }
 function stripNamespace(name) {
     const idx = name.lastIndexOf(".");
     return idx === -1 ? name : name.slice(idx + 1);
 }
 function matchBool(inner) {
-    const m = /<Bool>(true|false)<\/Bool>/.exec(inner);
-    return m ? m[1] : undefined;
+    const element = xmlElements(inner, "Bool").next();
+    if (element.done)
+        return undefined;
+    return element.value.body === "true" || element.value.body === "false" ? element.value.body : undefined;
 }
 function matchPropertyValueBool(inner, property) {
-    const re = new RegExp(`<PropertyValue\\s+Property="${property}"\\s+Bool="(true|false)"`);
-    const match = re.exec(inner);
-    return match ? match[1] : undefined;
+    for (const attributes of xmlStartTags(inner, "PropertyValue")) {
+        if (readAttr(attributes, "Property") !== property)
+            continue;
+        const value = readAttr(attributes, "Bool");
+        if (value === "true" || value === "false")
+            return value;
+    }
+    return undefined;
 }
 const UNSUPPORTED_OPERATOR_RES = [
     { token: "has", re: /\bhas\b/i },

package/core/ogc-features.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ogc-features.d.ts","sourceRoot":"","sources":["../../../src/core/ogc-features.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EACV,0BAA0B,EAC1B,2BAA2B,EAC3B,2BAA2B,EAC3B,iCAAiC,EACjC,uBAAuB,EACvB,uBAAuB,EACvB,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EAEpB,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAoBpB,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,uBAAuB,CAAC,CAQlC;AAED,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,2BAA2B,CAAC,CAQtC;AAED,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,2BAA2B,CAAC,CAQtC;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,0BAA0B,CAAC,CAQrC;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,0BAA0B,CAAC,CAQrC;AAED,wBAAsB,YAAY,CAChC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,iCAAiC,CAAC,CAoC5C;AAED,wBAAsB,UAAU,CAC9B,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,uBAAuB,CAAC,CAYlC;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,uBAAuB,CAAC,CAYlC;AAED,wBAAsB,cAAc,CAClC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,uBAAuB,CAAC,CAelC;AAED,wBAAsB,YAAY,CAChC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,uBAAuB,CAAC,CAelC;AAED,wBAAsB,aAAa,CAAC,SAAS,EAAE,sBAAsB,EAAE,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOnH"}
+{"version":3,"file":"ogc-features.d.ts","sourceRoot":"","sources":["../../../src/core/ogc-features.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EACV,0BAA0B,EAC1B,2BAA2B,EAC3B,2BAA2B,EAC3B,iCAAiC,EACjC,uBAAuB,EACvB,uBAAuB,EACvB,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EAEpB,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAoBpB,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,uBAAuB,CAAC,CAQlC;AAED,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,2BAA2B,CAAC,CAQtC;AAED,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,sBAAsB,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,2BAA2B,CAAC,CAQtC;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,0BAA0B,CAAC,CAQrC;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,0BAA0B,CAAC,CAQrC;AAED,wBAAsB,YAAY,CAChC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,iCAAiC,CAAC,CAuC5C;AAED,wBAAsB,UAAU,CAC9B,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,uBAAuB,CAAC,CAYlC;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,uBAAuB,CAAC,CAYlC;AAED,wBAAsB,cAAc,CAClC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,uBAAuB,CAAC,CAelC;AAED,wBAAsB,YAAY,CAChC,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,uBAAuB,CAAC,CAelC;AAED,wBAAsB,aAAa,CAAC,SAAS,EAAE,sBAAsB,EAAE,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOnH"}

package/core/ogc-features.js

@@ -66,6 +66,9 @@ export async function listOgcItems(transport, request) {
     if (request.filter !== undefined) {
         params.set("filter", request.filter);
     }
+    if (request.filterLang !== undefined) {
+        params.set("filter-lang", request.filterLang);
+    }
     if (request.ids !== undefined) {
         params.set("ids", normalizeCsv(request.ids));
     }