ochre-sdk 1.0.53 → 1.0.55

package/dist/constants.mjs

@@ -22,6 +22,7 @@ const XML_ARRAY_TAGS = [
 	"author",
 	"event",
 	"interpretation",
+	"interpreter",
 	"observation",
 	"observer",
 	"heading",
@@ -61,13 +62,12 @@ const XML_PARSER_OPTIONS = {
 	textNodeName: "payload",
 	stopNodes: ["*.referenceFormatDiv", "*.citationFormatSpan"],
 	htmlEntities: true,
-	isArray(tagName, jPath, isLeafNode, isAttribute) {
+	isArray(tagName, _, __, isAttribute) {
 		if (isAttribute) return false;
-		if (XML_ARRAY_TAGS.includes(tagName)) return true;
-		return false;
+		return XML_ARRAY_TAGS.includes(tagName);
 	},
-	attributeValueProcessor: (attrName, attrValue) => {
-		if (attrValue.startsWith("xs:")) return attrValue.replace("xs:", "");
+	attributeValueProcessor: (_, attributeValue) => {
+		if (attributeValue.startsWith("xs:")) return attributeValue.replace("xs:", "");
 		return null;
 	}
 };

package/dist/fetchers/gallery.d.mts

@@ -5,17 +5,17 @@ import { FetchBaseOptions, FetchLanguages } from "../parsers/helpers.mjs";
 /**
  * Fetches and parses a gallery from the OCHRE API
  *
- * @param params - The parameters for the fetch
- * @param params.uuid - The UUID of the gallery
- * @param params.filter - The filter to apply to the gallery
- * @param params.page - The page number to fetch
- * @param params.perPage - The number of items per page
+ * @param parameters - The parameters for the fetch
+ * @param parameters.uuid - The UUID of the gallery
+ * @param parameters.filter - The filter to apply to the gallery
+ * @param parameters.page - The page number to fetch
+ * @param parameters.perPage - The number of items per page
  * @param options - The options for the fetch
  * @param options.languages - Language codes to parse. Inline arrays preserve literal types automatically.
  * @param options.fetch - The fetch function to use
  * @returns The parsed gallery or an error message if the fetch/parse fails
  */
-declare function fetchGallery<const TLanguages extends ReadonlyArray<string> | undefined = undefined>(params: {
+declare function fetchGallery<const TLanguages extends ReadonlyArray<string> | undefined = undefined>(parameters: {
   uuid: string;
   filter?: string;
   page: number;

package/dist/fetchers/gallery.mjs

@@ -1,5 +1,5 @@
 import { DEFAULT_LANGUAGES, XML_PARSER_OPTIONS } from "../constants.mjs";
-import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../utils.mjs";
+import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../utilities.mjs";
 import { gallerySchema, iso639_3Schema } from "../schemas.mjs";
 import { restoreXMLMetadata } from "../xml/metadata.mjs";
 import { parseGallery } from "../parsers/index.mjs";
@@ -8,9 +8,7 @@ import * as v from "valibot";
 import { XMLParser } from "fast-xml-parser";
 //#region src/fetchers/gallery.ts
 function parseLanguages(languages) {
-	const parsedLanguages = [];
-	for (const language of languages) parsedLanguages.push(v.parse(iso639_3Schema, language));
-	return parsedLanguages;
+	return Array.from(languages, (language) => v.parse(iso639_3Schema, language));
 }
 function isRecord(value) {
 	return typeof value === "object" && value !== null;
@@ -35,8 +33,8 @@ function resolveGalleryLanguages(data, requestedLanguages) {
 	collectContentLanguages(data.result.ochre.gallery, languages);
 	return languages.size > 0 ? [...languages] : [...DEFAULT_LANGUAGES];
 }
-function buildXQuery(params) {
-	const { uuid, filter, page, perPage } = params;
+function buildXQuery(parameters) {
+	const { uuid, filter, page, perPage } = parameters;
 	const start = (page - 1) * perPage + 1;
 	const filterLiteral = stringLiteral(filter?.trim() ?? "");
 	return `<ochre>{
@@ -55,9 +53,9 @@ function buildXQuery(params) {
   }</gallery>
 }</ochre>`;
 }
-async function fetchGallery(params, options) {
+async function fetchGallery(parameters, options) {
 	try {
-		const { uuid, filter, page, perPage } = v.parse(gallerySchema, params);
+		const { uuid, filter, page, perPage } = v.parse(gallerySchema, parameters);
 		const requestedLanguages = options?.languages == null ? [] : parseLanguages(options.languages);
 		const response = await (options?.fetch ?? fetch)("https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?xquery&xsl=none&lang=\"*\"", {
 			method: "POST",

package/dist/fetchers/item-children.mjs

@@ -1,5 +1,5 @@
 import { DEFAULT_LANGUAGES, XML_PARSER_OPTIONS } from "../constants.mjs";
-import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../utils.mjs";
+import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../utilities.mjs";
 import { iso639_3Schema, uuidSchema } from "../schemas.mjs";
 import { restoreXMLMetadata } from "../xml/metadata.mjs";
 import { parseLinkedItems } from "../parsers/index.mjs";
@@ -21,9 +21,7 @@ const ITEM_COLLECTION_CATEGORIES = [
 	"set"
 ];
 function parseLanguages(languages) {
-	const parsedLanguages = [];
-	for (const language of languages) parsedLanguages.push(v.parse(iso639_3Schema, language));
-	return parsedLanguages;
+	return Array.from(languages, (language) => v.parse(iso639_3Schema, language));
 }
 function isRecord(value) {
 	return typeof value === "object" && value !== null;
@@ -50,8 +48,7 @@ function resolveItemChildrenLanguages(data, requestedLanguages) {
 }
 function buildXQuery(uuid, category) {
 	const categories = category == null ? ITEM_COLLECTION_CATEGORIES : typeof category === "string" ? [category] : category;
-	const collectionQueries = [];
-	for (const possibleCategory of categories) collectionQueries.push(`cts:search(fn:collection("ochre/${possibleCategory}")/ochre, $uuid-query)`);
+	const collectionQueries = Array.from(categories, (possibleCategory) => `cts:search(fn:collection("ochre/${possibleCategory}")/ochre, $uuid-query)`);
 	return `xquery version "1.0-ml";
 
 declare function local:item-children($nodes as node()*) as node()* {

package/dist/fetchers/item-links.mjs

@@ -1,5 +1,5 @@
 import { DEFAULT_LANGUAGES, XML_PARSER_OPTIONS } from "../constants.mjs";
-import { createSchemaValidationError, getErrorOutput } from "../utils.mjs";
+import { createSchemaValidationError, getErrorOutput } from "../utilities.mjs";
 import { iso639_3Schema, uuidSchema } from "../schemas.mjs";
 import { restoreXMLMetadata } from "../xml/metadata.mjs";
 import { parseLinkedItems } from "../parsers/index.mjs";
@@ -8,9 +8,7 @@ import * as v from "valibot";
 import { XMLParser } from "fast-xml-parser";
 //#region src/fetchers/item-links.ts
 function parseLanguages(languages) {
-	const parsedLanguages = [];
-	for (const language of languages) parsedLanguages.push(v.parse(iso639_3Schema, language));
-	return parsedLanguages;
+	return Array.from(languages, (language) => v.parse(iso639_3Schema, language));
 }
 function isRecord(value) {
 	return typeof value === "object" && value !== null;

package/dist/fetchers/item.mjs

@@ -1,5 +1,5 @@
 import { XML_PARSER_OPTIONS } from "../constants.mjs";
-import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../utils.mjs";
+import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../utilities.mjs";
 import { iso639_3Schema, uuidSchema } from "../schemas.mjs";
 import { restoreXMLMetadata } from "../xml/metadata.mjs";
 import { parseItem } from "../parsers/index.mjs";
@@ -12,7 +12,15 @@ function isItemContainerCategory(category) {
 	return category === "tree" || category === "set";
 }
 function isItemCategoryWithEmbeddedItems(category) {
-	return category === "tree" || category === "bibliography" || category === "concept" || category === "spatialUnit" || category === "period" || category === "resource" || category === "set";
+	return [
+		"tree",
+		"bibliography",
+		"concept",
+		"spatialUnit",
+		"period",
+		"resource",
+		"set"
+	].includes(category);
 }
 function isItemWithEmbeddedItems(item) {
 	return isItemCategoryWithEmbeddedItems(item.category);
@@ -35,8 +43,7 @@ function buildOmitEmbeddedItemsXQuery(uuid, category) {
 		"set"
 	] : typeof category === "string" ? [category] : category;
 	for (const possibleCategory of categories) if (!collectionCategories.includes(possibleCategory)) collectionCategories.push(possibleCategory);
-	const collectionQueries = [];
-	for (const collectionCategory of collectionCategories) collectionQueries.push(`cts:search(fn:collection("ochre/${collectionCategory}")/ochre, $uuid-query)`);
+	const collectionQueries = Array.from(collectionCategories, (collectionCategory) => `cts:search(fn:collection("ochre/${collectionCategory}")/ochre, $uuid-query)`);
 	return `xquery version "1.0-ml";
 
 let $uuid := ${stringLiteral(uuid)}
@@ -73,9 +80,7 @@ function omitEmbeddedItems(item) {
 * Validate language codes while preserving literal tuple inference.
 */
 function parseLanguages(languages) {
-	const parsedLanguages = [];
-	for (const language of languages) parsedLanguages.push(v.parse(iso639_3Schema, language));
-	return parsedLanguages;
+	return Array.from(languages, (language) => v.parse(iso639_3Schema, language));
 }
 /**
 * Defines a reusable languages tuple with validation and literal type inference.

package/dist/fetchers/set/items.d.mts

@@ -6,19 +6,19 @@ type FetchSetItemsCategory<TContainedItemCategories extends ReadonlyArray<SetIte
 /**
  * Fetches and parses Set items from the OCHRE API
  *
- * @param params - The parameters for the fetch
- * @param params.setScopeUuids - The Set scope UUIDs to filter by
- * @param params.queries - Recursive query tree used to filter matching items
- * @param params.sort - Optional sorting configuration applied before pagination.
+ * @param parameters - The parameters for the fetch
+ * @param parameters.setScopeUuids - The Set scope UUIDs to filter by
+ * @param parameters.queries - Recursive query tree used to filter matching items
+ * @param parameters.sort - Optional sorting configuration applied before pagination.
  * For propertyValue sorting, dataType is required and the sort key uses the first valid leaf value (value[not(@i)]).
- * @param params.page - The page number (1-indexed)
- * @param params.pageSize - The number of items per page
+ * @param parameters.page - The page number (1-indexed)
+ * @param parameters.pageSize - The number of items per page
  * @param containedItemCategories - The categories of the items to fetch
  * @param options - Options for the fetch
  * @param options.fetch - The fetch function to use
  * @returns The parsed Set items or null if the fetch/parse fails
  */
-declare function fetchSetItems<const TContainedItemCategories extends ReadonlyArray<SetItemCategory> | undefined = undefined, const TLanguages extends ReadonlyArray<string> | undefined = undefined>(params: {
+declare function fetchSetItems<const TContainedItemCategories extends ReadonlyArray<SetItemCategory> | undefined = undefined, const TLanguages extends ReadonlyArray<string> | undefined = undefined>(parameters: {
   setScopeUuids: Array<string>;
   queries?: Query | null;
   sort?: SetItemsSort;

package/dist/fetchers/set/items.mjs

@@ -1,6 +1,6 @@
 import { BELONGS_TO_COLLECTION_UUID, DEFAULT_LANGUAGES, XML_PARSER_OPTIONS } from "../../constants.mjs";
-import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../../utils.mjs";
-import { iso639_3Schema, setItemsParamsSchema } from "../../schemas.mjs";
+import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../../utilities.mjs";
+import { iso639_3Schema, setItemsParametersSchema } from "../../schemas.mjs";
 import { restoreXMLMetadata } from "../../xml/metadata.mjs";
 import { parseSetItems } from "../../parsers/index.mjs";
 import { XMLSetItemsData } from "../../xml/schemas.mjs";
@@ -9,9 +9,7 @@ import * as v from "valibot";
 import { XMLParser } from "fast-xml-parser";
 //#region src/fetchers/set/items.ts
 function parseLanguages(languages) {
-	const parsedLanguages = [];
-	for (const language of languages) parsedLanguages.push(v.parse(iso639_3Schema, language));
-	return parsedLanguages;
+	return Array.from(languages, (language) => v.parse(iso639_3Schema, language));
 }
 function isRecord(value) {
 	return typeof value === "object" && value !== null;
@@ -73,8 +71,8 @@ function buildPropertyValueStringSortKeyExpression(sort) {
         where string-length($candidate) gt 0
         return $candidate)[1])`;
 }
-function buildPropertyValueTypedSortKeyExpression(params) {
-	const { sort, dataType } = params;
+function buildPropertyValueTypedSortKeyExpression(parameters) {
+	const { sort, dataType } = parameters;
 	const propertyValuePath = buildPropertyValueValuePath(sort);
 	switch (dataType) {
 		case "integer": return `(for $v in ${propertyValuePath}
@@ -100,9 +98,9 @@ function buildPropertyValueTypedSortKeyExpression(params) {
         return xs:dateTime($candidate))[1]`;
 	}
 }
-function buildPropertyValueOrderByClause(params) {
-	const { dataType, direction } = params;
-	return dataType === "string" || dataType === "IDREF" ? buildStringOrderByClause(direction) : buildTypedOrderByClause(direction);
+function buildPropertyValueOrderByClause(parameters) {
+	const { dataType, direction } = parameters;
+	return (dataType === "string" || dataType === "IDREF" ? buildStringOrderByClause : buildTypedOrderByClause)(direction);
 }
 function buildOrderedItemsClause(sort) {
 	if (sort.target === "none") return "let $orderedItems := $items";
@@ -126,18 +124,18 @@ function buildOrderedItemsClause(sort) {
 }
 /**
 * Build an XQuery string to fetch Set items from the OCHRE API
-* @param params - The parameters for the fetch
-* @param params.setScopeUuids - An array of Set scope UUIDs to filter by
-* @param params.belongsToCollectionScopeUuids - An array of collection scope UUIDs to filter by
-* @param params.queries - Recursive query tree used to filter matching items
-* @param params.sort - Optional sorting configuration applied before pagination.
+* @param parameters - The parameters for the fetch
+* @param parameters.setScopeUuids - An array of Set scope UUIDs to filter by
+* @param parameters.belongsToCollectionScopeUuids - An array of collection scope UUIDs to filter by
+* @param parameters.queries - Recursive query tree used to filter matching items
+* @param parameters.sort - Optional sorting configuration applied before pagination.
 * For propertyValue sorting, dataType is required and the sort key uses the first valid leaf value (value[not(@i)]).
-* @param params.page - The page number (1-indexed)
-* @param params.pageSize - The number of items per page
+* @param parameters.page - The page number (1-indexed)
+* @param parameters.pageSize - The number of items per page
 * @returns An XQuery string
 */
-function buildXQuery(params) {
-	const { queries, sort, setScopeUuids, belongsToCollectionScopeUuids, page, pageSize } = params;
+function buildXQuery(parameters) {
+	const { queries, sort, setScopeUuids, belongsToCollectionScopeUuids, page, pageSize } = parameters;
 	const startPosition = (page - 1) * pageSize + 1;
 	const setScopeDeclaration = `declare variable $setScopeUuids := (${setScopeUuids.map((uuid) => stringLiteral(uuid)).join(", ")});`;
 	const baseItemsExpression = "doc()/ochre/set[@uuid = $setScopeUuids]/items/*";
@@ -165,9 +163,9 @@ ${itemsClause}
   }</items>
 }</ochre>`;
 }
-async function fetchSetItems(params, containedItemCategories, options) {
+async function fetchSetItems(parameters, containedItemCategories, options) {
 	try {
-		const { setScopeUuids, belongsToCollectionScopeUuids, queries, sort, page, pageSize } = v.parse(setItemsParamsSchema, params);
+		const { setScopeUuids, belongsToCollectionScopeUuids, queries, sort, page, pageSize } = v.parse(setItemsParametersSchema, parameters);
 		const requestedLanguages = options?.languages == null ? [] : parseLanguages(options.languages);
 		const xquery = buildXQuery({
 			setScopeUuids,
@@ -199,7 +197,7 @@ async function fetchSetItems(params, containedItemCategories, options) {
 		});
 		const itemsByUuid = /* @__PURE__ */ new Map();
 		for (const item of items) if (!itemsByUuid.has(item.uuid)) itemsByUuid.set(item.uuid, item);
-		const uniqueItems = [...itemsByUuid.values()];
+		const uniqueItems = itemsByUuid.values().toArray();
 		return {
 			totalCount: output.result.ochre.items.totalCount,
 			page: output.result.ochre.items.page,

package/dist/fetchers/set/property-values.d.mts

@@ -4,19 +4,19 @@ import { PropertyValueQueryItem, Query, SetAttributeValueQueryItem } from "../..
 /**
  * Fetches and parses Set property values from the OCHRE API
  *
- * @param params - The parameters for the fetch
- * @param params.setScopeUuids - An array of set scope UUIDs to filter by
- * @param params.queries - Recursive query tree used to filter matching items
- * @param params.attributes - Whether to return values for bibliographies and periods
- * @param params.attributes.bibliographies - Whether to return values for bibliographies
- * @param params.attributes.periods - Whether to return values for periods
- * @param params.isLimitedToLeafPropertyValues - Whether to limit the property values to leaf property values
+ * @param parameters - The parameters for the fetch
+ * @param parameters.setScopeUuids - An array of set scope UUIDs to filter by
+ * @param parameters.queries - Recursive query tree used to filter matching items
+ * @param parameters.attributes - Whether to return values for bibliographies and periods
+ * @param parameters.attributes.bibliographies - Whether to return values for bibliographies
+ * @param parameters.attributes.periods - Whether to return values for periods
+ * @param parameters.isLimitedToLeafPropertyValues - Whether to limit the property values to leaf property values
  * @param options - Options for the fetch
  * @param options.fetch - The fetch function to use
  * @returns Parsed Set property values and requested attribute values.
  * Returns empty arrays/objects when no matches are found, and null outputs on fetch/parse errors.
  */
-declare function fetchSetPropertyValues(params: {
+declare function fetchSetPropertyValues(parameters: {
   setScopeUuids: Array<string>;
   queries?: Query | null;
   attributes?: {

package/dist/fetchers/set/property-values.mjs

@@ -1,7 +1,7 @@
 import { BELONGS_TO_COLLECTION_UUID, DEFAULT_LANGUAGES, XML_PARSER_OPTIONS } from "../../constants.mjs";
-import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../../utils.mjs";
+import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../../utilities.mjs";
 import { MultilingualString } from "../../parsers/multilingual.mjs";
-import { setPropertyValuesParamsSchema } from "../../schemas.mjs";
+import { setPropertyValuesParametersSchema } from "../../schemas.mjs";
 import { parseXMLContent } from "../../parsers/string.mjs";
 import { buildAndCtsQueryExpression, buildBelongsToCollectionQueryExpression, buildQueryPlan } from "../../query.mjs";
 import * as v from "valibot";
@@ -58,9 +58,9 @@ function sortAttributeValues(values) {
 		return a.content.localeCompare(b.content);
 	});
 }
-const countSchema = v.pipe(v.optional(v.union([v.number(), v.string()]), 1), v.transform((val) => {
-	if (val === "") return 1;
-	const count = Number(val);
+const countSchema = v.pipe(v.optional(v.union([v.number(), v.string()]), 1), v.transform((value) => {
+	if (value === "") return 1;
+	const count = Number(value);
 	return Number.isFinite(count) ? count : 1;
 }));
 const propertyValueLabelStringSchema = v.object({ payload: v.optional(v.string(), "") });
@@ -69,10 +69,12 @@ const propertyValueLabelContentSchema = v.object({
 	string: v.array(propertyValueLabelStringSchema)
 });
 function getPropertyFacetSelectorsFromQueries(queries) {
-	const propertyFacetSelectors = /* @__PURE__ */ new Map();
 	if (queries == null) return [];
+	const propertyFacetSelectors = /* @__PURE__ */ new Map();
 	const pendingQueries = [queries];
-	for (const query of pendingQueries) {
+	while (pendingQueries.length > 0) {
+		const query = pendingQueries.shift();
+		if (query == null) continue;
 		if ("target" in query) {
 			if (query.target !== "property") continue;
 			if (query.propertyVariable != null) {
@@ -86,7 +88,7 @@ function getPropertyFacetSelectorsFromQueries(queries) {
 		}
 		pendingQueries.push(..."and" in query ? query.and : query.or);
 	}
-	return [...propertyFacetSelectors.values()];
+	return propertyFacetSelectors.values().toArray();
 }
 function getItemFilterQueriesFromPropertyValueQueries(queries) {
 	if (queries == null) return null;
@@ -118,37 +120,37 @@ const propertyValueQueryItemSchema = v.pipe(v.object({
 	rawValue: v.optional(v.string()),
 	payload: v.optional(v.string()),
 	content: v.optional(v.array(propertyValueLabelContentSchema))
-}), v.transform((val) => {
-	const dataType = normalizePropertyValueDataType(val.dataType);
-	const label = parsePropertyValueLabel(val.content, val.payload);
+}), v.transform((value) => {
+	const dataType = normalizePropertyValueDataType(value.dataType);
+	const label = parsePropertyValueLabel(value.content, value.payload);
 	const returnValue = {
-		uuid: val.uuid !== "" ? val.uuid : null,
-		scope: val.scope,
-		variableUuid: val.variableUuid != null && val.variableUuid !== "" ? val.variableUuid : null,
-		count: val.count,
-		globalCount: val.globalCount ?? null,
+		uuid: value.uuid !== "" ? value.uuid : null,
+		scope: value.scope,
+		variableUuid: value.variableUuid != null && value.variableUuid !== "" ? value.variableUuid : null,
+		count: value.count,
+		globalCount: value.globalCount ?? null,
 		dataType,
 		content: null,
 		label
 	};
 	switch (dataType) {
 		case "IDREF":
-			returnValue.content = val.uuid !== "" ? val.uuid : null;
+			returnValue.content = value.uuid !== "" ? value.uuid : null;
 			break;
 		case "integer":
 		case "decimal":
 		case "time":
-			if (val.rawValue != null && val.rawValue !== "") {
-				const numericContent = Number(val.rawValue);
+			if (value.rawValue != null && value.rawValue !== "") {
+				const numericContent = Number(value.rawValue);
 				returnValue.content = Number.isNaN(numericContent) ? null : numericContent;
 			}
 			break;
 		case "boolean":
-			returnValue.content = parsePropertyValueBooleanContent(val.rawValue);
+			returnValue.content = parsePropertyValueBooleanContent(value.rawValue);
 			break;
 		default: {
 			const labelText = label?.getText() ?? null;
-			returnValue.content = val.rawValue != null && val.rawValue !== "" ? val.rawValue.toString() : labelText;
+			returnValue.content = value.rawValue != null && value.rawValue !== "" ? value.rawValue : labelText;
 			break;
 		}
 	}
@@ -159,10 +161,10 @@ const attributeValueQueryItemSchema = v.pipe(v.object({
 	count: countSchema,
 	content: v.optional(v.string()),
 	payload: v.optional(v.string())
-}), v.transform((val) => ({
-	attributeType: val.attributeType,
-	count: val.count,
-	content: val.content != null && val.content !== "" ? val.content : val.payload != null && val.payload !== "" ? val.payload : null
+}), v.transform((value) => ({
+	attributeType: value.attributeType,
+	count: value.count,
+	content: value.content != null && value.content !== "" ? value.content : value.payload != null && value.payload !== "" ? value.payload : null
 })));
 /**
 * Schema for the property values OCHRE API response
@@ -174,19 +176,19 @@ const responseSchema = v.object({ result: v.object({ ochre: v.object({
 }) }) });
 /**
 * Build an XQuery string to fetch property values from the OCHRE API
-* @param params - The parameters for the fetch
-* @param params.setScopeUuids - An array of set scope UUIDs to filter by
-* @param params.belongsToCollectionScopeUuids - An array of collection scope UUIDs to filter by
-* @param params.queries - Recursive query tree used to filter matching items
-* @param params.propertyFacetSelectors - Property variable/relation selectors to aggregate, if any
-* @param params.attributes - Whether to return values for bibliographies and periods
-* @param params.attributes.bibliographies - Whether to return values for bibliographies
-* @param params.attributes.periods - Whether to return values for periods
-* @param params.isLimitedToLeafPropertyValues - Whether to limit the property values to leaf property values
+* @param parameters - The parameters for the fetch
+* @param parameters.setScopeUuids - An array of set scope UUIDs to filter by
+* @param parameters.belongsToCollectionScopeUuids - An array of collection scope UUIDs to filter by
+* @param parameters.queries - Recursive query tree used to filter matching items
+* @param parameters.propertyFacetSelectors - Property variable/relation selectors to aggregate, if any
+* @param parameters.attributes - Whether to return values for bibliographies and periods
+* @param parameters.attributes.bibliographies - Whether to return values for bibliographies
+* @param parameters.attributes.periods - Whether to return values for periods
+* @param parameters.isLimitedToLeafPropertyValues - Whether to limit the property values to leaf property values
 * @returns An XQuery string
 */
-function buildXQuery(params) {
-	const { setScopeUuids, belongsToCollectionScopeUuids, queries, propertyFacetSelectors, attributes, isLimitedToLeafPropertyValues } = params;
+function buildXQuery(parameters) {
+	const { setScopeUuids, belongsToCollectionScopeUuids, queries, propertyFacetSelectors, attributes, isLimitedToLeafPropertyValues } = parameters;
 	const setScopeDeclaration = `declare variable $setScopeUuids := (${setScopeUuids.map((uuid) => stringLiteral(uuid)).join(", ")});`;
 	const baseItemsExpression = "doc()/ochre/set[@uuid = $setScopeUuids]/items/*";
 	const compiledQueryPlan = buildQueryPlan({ queries: getItemFilterQueriesFromPropertyValueQueries(queries) });
@@ -416,21 +418,21 @@ return (${returnedSequences.join(", ")})
 /**
 * Fetches and parses Set property values from the OCHRE API
 *
-* @param params - The parameters for the fetch
-* @param params.setScopeUuids - An array of set scope UUIDs to filter by
-* @param params.queries - Recursive query tree used to filter matching items
-* @param params.attributes - Whether to return values for bibliographies and periods
-* @param params.attributes.bibliographies - Whether to return values for bibliographies
-* @param params.attributes.periods - Whether to return values for periods
-* @param params.isLimitedToLeafPropertyValues - Whether to limit the property values to leaf property values
+* @param parameters - The parameters for the fetch
+* @param parameters.setScopeUuids - An array of set scope UUIDs to filter by
+* @param parameters.queries - Recursive query tree used to filter matching items
+* @param parameters.attributes - Whether to return values for bibliographies and periods
+* @param parameters.attributes.bibliographies - Whether to return values for bibliographies
+* @param parameters.attributes.periods - Whether to return values for periods
+* @param parameters.isLimitedToLeafPropertyValues - Whether to limit the property values to leaf property values
 * @param options - Options for the fetch
 * @param options.fetch - The fetch function to use
 * @returns Parsed Set property values and requested attribute values.
 * Returns empty arrays/objects when no matches are found, and null outputs on fetch/parse errors.
 */
-async function fetchSetPropertyValues(params, options) {
+async function fetchSetPropertyValues(parameters, options) {
 	try {
-		const { setScopeUuids, belongsToCollectionScopeUuids, queries, attributes, isLimitedToLeafPropertyValues } = v.parse(setPropertyValuesParamsSchema, params);
+		const { setScopeUuids, belongsToCollectionScopeUuids, queries, attributes, isLimitedToLeafPropertyValues } = v.parse(setPropertyValuesParametersSchema, parameters);
 		const propertyFacetSelectors = getPropertyFacetSelectorsFromQueries(queries);
 		if (propertyFacetSelectors.length === 0 && !attributes.bibliographies && !attributes.periods) return {
 			propertyValues: [],
@@ -505,7 +507,7 @@ async function fetchSetPropertyValues(params, options) {
 			});
 		}
 		return {
-			propertyValues: sortPropertyValues([...flattenedPropertyValuesByKey.values()]),
+			propertyValues: sortPropertyValues(flattenedPropertyValuesByKey.values().toArray()),
 			propertyValuesByPropertyVariableUuid,
 			attributeValues: {
 				bibliographies: attributes.bibliographies ? sortAttributeValues(attributeValuesByType.bibliographies) : null,

package/dist/fetchers/website-metadata.mjs

@@ -1,5 +1,5 @@
 import { XML_PARSER_OPTIONS } from "../constants.mjs";
-import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../utils.mjs";
+import { createSchemaValidationError, getErrorOutput, stringLiteral } from "../utilities.mjs";
 import { iso639_3Schema } from "../schemas.mjs";
 import { restoreXMLMetadata } from "../xml/metadata.mjs";
 import { parseStringLike } from "../parsers/helpers.mjs";
@@ -34,7 +34,7 @@ function parseWebsiteMetadata(data, options) {
 		} }
 	};
 }
-function buildXQuery(params) {
+function buildXQuery(parameters) {
 	return String.raw`xquery version "1.0-ml";
 
 declare function local:resource-items($resources) {
@@ -118,8 +118,8 @@ declare function local:metadata-tree($tree, $target-slug, $slug-prefix) {
     }
 };
 
-let $website := collection("ochre/tree")/ochre[tree/identification/abbreviation/content/string = ${stringLiteral(params.abbreviation)}][1]
-let $target-slug := ${stringLiteral(params.slug)}
+let $website := collection("ochre/tree")/ochre[tree/identification/abbreviation/content/string = ${stringLiteral(parameters.abbreviation)}][1]
+let $target-slug := ${stringLiteral(parameters.slug)}
 return
   <ochre>{
     $website/@uuid,
@@ -133,11 +133,10 @@ return
 }
 async function fetchWebsiteMetadata(abbreviation, options) {
 	try {
-		const cleanAbbreviation = abbreviation.trim().toLocaleLowerCase("en-US");
 		if (options?.slug == null) throw new Error("Website metadata slug is required");
+		const cleanAbbreviation = abbreviation.trim().toLocaleLowerCase("en-US");
 		const slug = options.slug.trim().replaceAll(/^\/+|\/+$/g, "");
-		const requestedLanguages = [];
-		for (const language of options.languages ?? []) requestedLanguages.push(v.parse(iso639_3Schema, language));
+		const requestedLanguages = Array.from(options.languages ?? [], (language) => v.parse(iso639_3Schema, language));
 		const response = await (options.fetch ?? fetch)("https://ochre.lib.uchicago.edu/ochre/v2/ochre.php?xquery&xsl=none&lang=\"*\"", {
 			method: "POST",
 			body: buildXQuery({

package/dist/fetchers/website.mjs

@@ -1,5 +1,5 @@
 import { XML_PARSER_OPTIONS } from "../constants.mjs";
-import { createSchemaValidationError, getErrorOutput } from "../utils.mjs";
+import { createSchemaValidationError, getErrorOutput } from "../utilities.mjs";
 import { restoreXMLMetadata } from "../xml/metadata.mjs";
 import { XMLWebsiteData } from "../xml/schemas.mjs";
 import { parseWebsite } from "../parsers/website/index.mjs";