ochre-sdk 1.0.79 → 1.1.1

package/dist/ocr.mjs

@@ -0,0 +1,52 @@
+import { stringLiteral } from "./xquery.mjs";
+//#region src/ocr.ts
+const ALTO_NAMESPACE = "http://www.loc.gov/standards/alto/ns-v2#";
+/**
+* The local names OCHRE serves OCR word elements under
+*
+* OCHRE varies the casing, and serves the elements both in the ALTO namespace
+* and in no namespace at all. Every selector over the layer has to accept all
+* of them: an `xs:QName("String")` narrowing matches 2 of the 18,446 documents
+* carrying an OCR layer, while the ALTO-namespaced `String` matches 14,650.
+*/
+const OCR_WORD_LOCAL_NAMES = ["String", "string"];
+const OCR_WORD_CASE_FOLDED_LOCAL_NAME = "string";
+/**
+* The name of the element wrapping an OCR layer inside an OCHRE document
+* @internal
+*/
+const OCR_LAYER_ELEMENT_NAME = "ocr";
+/**
+* The attribute an OCR word element holds its word in
+*
+* The word is in the attribute rather than in the element's text content.
+* @internal
+*/
+const OCR_WORD_CONTENT_ATTRIBUTE = "CONTENT";
+/**
+* An XQuery sequence of every QName an OCR word element can carry
+*
+* Use with the `cts:element-*` query constructors, which need concrete QNames
+* and cannot match on a case-folded local name the way {@link buildOcrWordPath}
+* does. This has to stay in agreement with that path: a word element the
+* narrowing misses is a document the search silently drops.
+* @internal
+*/
+const OCR_WORD_QNAMES = `(${[...OCR_WORD_LOCAL_NAMES.map((localName) => `fn:QName(${stringLiteral(ALTO_NAMESPACE)}, ${stringLiteral(localName)})`), ...OCR_WORD_LOCAL_NAMES.map((localName) => `xs:QName(${stringLiteral(localName)})`)].join(", ")})`;
+/**
+* Build an XQuery path selecting every OCR word element beneath a node
+*
+* Matches the layer and the word elements on a case-folded `local-name()`
+* rather than a name test, because a name test silently matches nothing when
+* OCHRE varies the casing or serves the elements in a namespace. Word elements
+* are selected at any depth, because the hierarchy between the layer and its
+* words is irregular and is not parsed.
+* @param rootExpression - The XQuery expression to select from
+* @returns The XQuery path
+* @internal
+*/
+function buildOcrWordPath(rootExpression) {
+	return `${rootExpression}//*[lower-case(local-name(.)) = ${stringLiteral("ocr")}]//*[lower-case(local-name(.)) = ${stringLiteral(OCR_WORD_CASE_FOLDED_LOCAL_NAME)}][@${OCR_WORD_CONTENT_ATTRIBUTE}]`;
+}
+//#endregion
+export { OCR_LAYER_ELEMENT_NAME, OCR_WORD_CONTENT_ATTRIBUTE, OCR_WORD_QNAMES, buildOcrWordPath };

package/dist/parsers/helpers.d.mts

@@ -6,14 +6,34 @@ export type FetchFunction = (input: string | URL | globalThis.Request, init?: Re
 export type FetchBaseOptions<TLanguages extends ReadonlyArray<string> | undefined = undefined> = {
   languages?: TLanguages;
   fetch?: FetchFunction;
+  signal?: AbortSignal;
+  timeoutMilliseconds?: number;
 };
 export type FetchRuntimeOptions = FetchBaseOptions<ReadonlyArray<string>>;
 export type FetchLanguages<TLanguages extends ReadonlyArray<string> | undefined> = TLanguages extends readonly [] ? ReadonlyArray<string> : TLanguages extends ReadonlyArray<string> ? TLanguages : ReadonlyArray<string>;
 export type ParserOptions<T extends ReadonlyArray<string>> = {
   languages: T;
+  /**
+   * The language the dataset declares as its default
+   *
+   * Threaded into every {@link MultilingualString} so a read with no language
+   * resolves to the dataset's default rather than whichever language happens to
+   * come first in the payload.
+   */
+  defaultLanguage?: T[number];
 };
 export declare function getParserOptions<T extends ReadonlyArray<string>>(options: ParserOptions<T>): ParserOptions<T>;
-export declare function cleanObject<T extends Record<string, unknown>>(object: T): Partial<T>;
+/**
+ * Drop the keys whose value is undefined
+ *
+ * Constrained to `object` rather than `Record<string, unknown>`, which an
+ * interface never satisfies for want of an index signature. `Object.entries`
+ * cannot be typed precisely, so the one cast that costs is here rather than at
+ * the call site.
+ * @param object - The object to clean
+ * @returns A copy carrying only the defined keys
+ */
+export declare function cleanObject<T extends object>(object: T): Partial<T>;
 export declare function parseLicense(availability: {
   license: XMLString & {
     target?: string;

package/dist/parsers/helpers.mjs

@@ -4,11 +4,25 @@ import { parseXMLContent, parseXMLString } from "./string.mjs";
 //#region src/parsers/helpers.ts
 const FALLBACK_PARSER_OPTIONS = { languages: DEFAULT_LANGUAGES };
 function getParserOptions(options) {
-	return { languages: options.languages };
+	return {
+		languages: options.languages,
+		defaultLanguage: options.defaultLanguage
+	};
 }
+/**
+* Drop the keys whose value is undefined
+*
+* Constrained to `object` rather than `Record<string, unknown>`, which an
+* interface never satisfies for want of an index signature. `Object.entries`
+* cannot be typed precisely, so the one cast that costs is here rather than at
+* the call site.
+* @param object - The object to clean
+* @returns A copy carrying only the defined keys
+*/
 function cleanObject(object) {
+	const entries = Object.entries(object);
 	const cleaned = {};
-	for (const [key, value] of Object.entries(object)) if (value !== void 0) cleaned[key] = value;
+	for (const [key, value] of entries) if (value !== void 0) cleaned[key] = value;
 	return cleaned;
 }
 function parseLicense(availability) {
@@ -29,16 +43,19 @@ function isXMLContent(value) {
 function multilingualFromText(text, options) {
 	const content = {};
 	for (const language of options.languages) content[language] = text;
-	return MultilingualString.fromObject(content, options.languages);
+	return MultilingualString.fromObject(content, options.languages, { defaultLanguage: options.defaultLanguage });
 }
 function parseContentLike(value, options) {
 	if (value == null) return null;
 	if (typeof value === "string") return multilingualFromText(value, options);
 	if (!isXMLContent(value)) return multilingualFromText(parseXMLString(value), options);
-	return parseXMLContent(value, { languages: options.languages });
+	return parseXMLContent(value, {
+		languages: options.languages,
+		defaultLanguage: options.defaultLanguage
+	});
 }
 function parseRequiredContentLike(value, options) {
-	return parseContentLike(value, options) ?? MultilingualString.empty(options.languages);
+	return parseContentLike(value, options) ?? MultilingualString.empty(options.languages, { defaultLanguage: options.defaultLanguage });
 }
 function parseContentLikeText(value, options) {
 	return parseContentLike(value, options)?.getText().trim() ?? "";
@@ -46,7 +63,10 @@ function parseContentLikeText(value, options) {
 function parseStringContent(value, options = FALLBACK_PARSER_OPTIONS) {
 	if (value == null) return "";
 	if (typeof value === "string") return value;
-	if (isXMLContent(value)) return parseXMLContent(value, { languages: options.languages }).getText();
+	if (isXMLContent(value)) return parseXMLContent(value, {
+		languages: options.languages,
+		defaultLanguage: options.defaultLanguage
+	}).getText();
 	return parseXMLString(value).text;
 }
 //#endregion

package/dist/parsers/index.d.mts

@@ -21,14 +21,6 @@ export declare function parseBibliographyList<T extends ReadonlyArray<string>>(r
   bibliography: Array<XMLBibliography>;
 } | undefined, options: ParserOptions<T>): Array<Bibliography<T, "embedded">>;
 export declare function parsePersonList<T extends ReadonlyArray<string>>(rawPersons: Array<XMLPerson> | undefined, options: ParserOptions<T>): Array<Person<T, "embedded">>;
-export declare function parseMetadataLanguages(rawOchre: {
-  metadata: XMLMetadata;
-  languages?: string;
-}): Array<string>;
-export declare function resolveLanguages<T extends ReadonlyArray<string>>(requestedLanguages: T | undefined, metadataLanguages: Array<string>): T;
-export declare function resolveDefaultLanguage<T extends ReadonlyArray<string>>(rawOchre: {
-  metadata: XMLMetadata;
-}, languages: T): T[number];
 export declare function parseMetadata<T extends ReadonlyArray<string>>(rawOchre: {
   uuidBelongsTo: string;
   metadata: XMLMetadata;