ochre-sdk 1.3.12 → 1.3.14

package/dist/xml/schemas.mjs

@@ -2,7 +2,7 @@ import { readArrayProperty } from "../reflection.mjs";
 import { isPseudoUuid } from "../schemas.mjs";
 import { parseDateTime } from "./dates.mjs";
 import * as v from "valibot";
-//#region src/xml/schemas.ts
+// src/xml/schemas.ts
 function getXMLStringPayload(value) {
 	return typeof value === "string" ? value : value.payload ?? null;
 }
@@ -191,6 +191,8 @@ const XMLCoordinate = v.variant("type", [v.object({
 	latitude: XMLNumber,
 	longitude: XMLNumber,
 	altitude: XMLOptionalNumber,
+	WKID: XMLOptionalNumber,
+	rawValue: v.optional(v.string("XMLCoordinates: rawValue is string and optional")),
 	source: v.optional(XMLCoordinatesSource)
 }, "XMLCoordinates: Shape error"), v.object({
 	type: v.literal("plane", "XMLCoordinates: type is plane"),
@@ -205,6 +207,10 @@ const XMLCoordinate = v.variant("type", [v.object({
 	source: v.optional(XMLCoordinatesSource)
 }, "XMLCoordinates: Shape error")], "XMLCoordinates: Shape error");
 const XMLCoordinates = v.object({ coord: v.array(XMLCoordinate) }, "XMLCoordinates: Shape error");
+const XMLMapData = v.optional(v.object({ geoJSON: v.object({
+	multiPolygon: v.object({ payload: v.string("XMLMapData: multiPolygon is string and required") }),
+	EPSG: XMLNumber
+}) }, "XMLMapData: mapData is object with geoJSON"));
 const XMLImage = v.object({
 	publicationDateTime: v.optional(customDateTime("XMLImage: publicationDateTime is not a valid datetime")),
 	identification: v.optional(XMLIdentification),
@@ -215,6 +221,16 @@ const XMLImage = v.object({
 	fileSize: XMLOptionalNumber,
 	payload: v.optional(v.string("XMLImage: payload is string and optional"))
 }, "XMLImage: Shape error");
+const XMLDownloadOptions = v.object({ option: v.array(v.object({
+	type: v.picklist([
+		"highQualityImage",
+		"iiifManifest",
+		"document",
+		"ocr"
+	], "XMLDownloadOptions: type is highQualityImage, iiifManifest, document, or ocr"),
+	href: v.pipe(v.string("XMLDownloadOptions: href is string and required"), v.url("XMLDownloadOptions: href is not a valid URL")),
+	fileFormat: v.string("XMLDownloadOptions: fileFormat is string and required")
+}, "XMLDownloadOptions: option is object with type, href, and fileFormat")) }, "XMLDownloadOptions: Shape error");
 const XMLImageMapArea = v.object({
 	uuid: v.pipe(v.string("XMLImageMapArea: uuid is string and required"), v.check(isPseudoUuid, "XMLImageMapArea: uuid is not a valid pseudo-UUID")),
 	publicationDateTime: v.optional(customDateTime("XMLImageMapArea: publicationDateTime is not a valid datetime")),
@@ -481,6 +497,7 @@ const XMLBibliography = v.object({
 		publicationDateTime: v.optional(customDateTime("XMLBibliography: publicationDateTime is not a valid datetime"))
 	}, "XMLBibliography: sourceDocument is object with uuid and payload")),
 	image: v.optional(XMLImage),
+	downloadOptions: v.optional(XMLDownloadOptions),
 	publicationInfo: v.optional(v.object({
 		publishers: v.optional(v.union([v.object({ publisher: v.array(v.lazy(() => XMLPerson)) }), v.object({ publishers: v.object({ person: v.array(v.lazy(() => XMLPerson)) }) })])),
 		startDate: v.optional(v.object({
@@ -550,6 +567,7 @@ const XMLObservation = v.object({
 		v.lazy(() => XMLDataItem),
 		v.array(v.union([v.lazy(() => XMLLink), v.lazy(() => XMLDataItem)]))
 	])),
+	downloadOptions: v.optional(XMLDownloadOptions),
 	notes: v.optional(v.object({ note: v.array(XMLNote) })),
 	properties: v.optional(v.object({ property: v.array(XMLProperty) })),
 	bibliographies: v.optional(v.object({ bibliography: v.array(XMLBibliography) }))
@@ -558,10 +576,7 @@ const XMLSpatialUnit = v.object({
 	...XMLBaseItem.entries,
 	image: v.optional(XMLImage),
 	coordinates: v.optional(XMLCoordinates),
-	mapData: v.optional(v.object({ geoJSON: v.object({
-		multiPolygon: v.object({ payload: v.string("XMLSpatialUnit: multiPolygon is string and required") }),
-		EPSG: XMLNumber
-	}) }, "XMLSpatialUnit: mapData is object with geoJSON")),
+	mapData: XMLMapData,
 	observations: v.optional(v.object({ observation: v.array(XMLObservation) })),
 	observation: v.optional(v.array(XMLObservation)),
 	properties: v.optional(v.object({ property: v.array(XMLProperty) })),
@@ -644,6 +659,7 @@ const XMLResource = v.object({
 	width: XMLOptionalNumber,
 	image: v.optional(XMLImage),
 	imagemap: v.optional(XMLImageMap),
+	downloadOptions: v.optional(XMLDownloadOptions),
 	document: XMLOptionalContent,
 	coordinates: v.optional(XMLCoordinates),
 	periods: v.optional(v.object({ period: v.array(XMLPeriod) })),
@@ -928,21 +944,39 @@ const XMLSetItems = v.intersect([XMLItemLinks, v.object({
 	pageSize: XMLNumber
 }, "XMLSetItems: Shape error")]);
 const XMLSetItemsData = v.object({ result: v.object({ ochre: v.object({ items: XMLSetItems }, "XMLSetItemsData: ochre") }) }, "XMLSetItemsData: Shape error");
-const XMLSetItemLocation = v.object({
-	uuid: v.string("XMLSetItemLocation: uuid is string and required"),
-	category: v.string("XMLSetItemLocation: category is string and required"),
-	publicationDateTime: v.optional(customDateTime("XMLSetItemLocation: publicationDateTime is not a valid datetime")),
+const XMLItemLocation = v.object({
+	uuid: v.string("XMLItemLocation: uuid is string and required"),
+	category: v.string("XMLItemLocation: category is string and required"),
+	scopeUuid: v.string("XMLItemLocation: scopeUuid is string and required"),
+	publicationDateTime: v.optional(customDateTime("XMLItemLocation: publicationDateTime is not a valid datetime")),
 	identification: XMLIdentification,
 	coordinates: v.optional(XMLCoordinates),
+	mapData: XMLMapData,
 	value: v.optional(v.array(v.intersect([v.object({
-		variable: v.string("XMLSetItemLocation: value variable is string and required"),
-		uuid: v.string("XMLSetItemLocation: value uuid is string and required")
-	}, "XMLSetItemLocation: value is object with variable and uuid"), XMLContent])))
-}, "XMLSetItemLocation: Shape error");
-const XMLSetItemLocationsData = v.object({ result: v.object({ ochre: v.object({ items: v.object({
+		variable: v.string("XMLItemLocation: value variable is string and required"),
+		uuid: v.string("XMLItemLocation: value uuid is string and required")
+	}, "XMLItemLocation: value is object with variable and uuid"), XMLContent])))
+}, "XMLItemLocation: Shape error");
+const XMLItemLocationsData = v.object({ result: v.object({ ochre: v.object({ items: v.object({
 	totalCount: XMLNumber,
-	itemLocation: v.optional(v.array(XMLSetItemLocation, "XMLSetItemLocationsData: itemLocation is array of XMLSetItemLocation"))
-}, "XMLSetItemLocationsData: items is object with totalCount") }, "XMLSetItemLocationsData: ochre") }) }, "XMLSetItemLocationsData: Shape error");
+	itemLocation: v.optional(v.array(XMLItemLocation, "XMLItemLocationsData: itemLocation is array of XMLItemLocation"))
+}, "XMLItemLocationsData: items is object with totalCount") }, "XMLItemLocationsData: ochre") }) }, "XMLItemLocationsData: Shape error");
+const XMLMapLayer = v.object({
+	uuid: v.string("XMLMapLayer: uuid is string and required"),
+	category: v.string("XMLMapLayer: category is string and required"),
+	type: v.optional(v.string("XMLMapLayer: type is string and optional")),
+	href: v.optional(v.string("XMLMapLayer: href is string and optional")),
+	WKID: XMLOptionalNumber,
+	identification: XMLIdentification
+}, "XMLMapLayer: Shape error");
+const XMLMapSource = v.object({
+	uuid: v.string("XMLMapSource: uuid is string and required"),
+	category: v.string("XMLMapSource: category is string and required"),
+	WKID: XMLOptionalNumber,
+	identification: XMLIdentification,
+	mapLayer: v.optional(v.array(XMLMapLayer, "XMLMapSource: mapLayer is array of XMLMapLayer"))
+}, "XMLMapSource: Shape error");
+const XMLMapSourcesData = v.object({ result: v.object({ ochre: v.object({ mapSources: v.object({ mapSource: v.optional(v.array(XMLMapSource, "XMLMapSourcesData: mapSource is array of XMLMapSource")) }, "XMLMapSourcesData: mapSources is object") }, "XMLMapSourcesData: ochre") }) }, "XMLMapSourcesData: Shape error");
 const XMLData = v.object({ result: v.object({ ochre: v.intersect([v.object({
 	uuid: v.pipe(v.string("XMLData: uuid is string and required"), v.check(isPseudoUuid, "XMLData: uuid is not a valid pseudo-UUID")),
 	belongsTo: v.string("XMLData: belongsTo is string and required"),
@@ -958,7 +992,7 @@ const XMLWebsiteData = v.object({ result: v.object({ ochre: v.object({
 	publicationDateTime: customDateTime("XMLWebsiteData: publicationDateTime is not a valid datetime"),
 	metadata: XMLMetadata,
 	persistentUrl: v.optional(v.pipe(v.string("XMLWebsiteData: persistentUrl is string and optional"), v.url("XMLWebsiteData: persistentUrl is not a valid URL"))),
-	tree: v.array(XMLWebsiteTree)
+	tree: v.array(XMLWebsiteTree),
+	styleLabels: v.optional(v.object({ styleLabel: v.optional(v.array(v.intersect([v.object({ valueUuid: v.string("XMLWebsiteData: styleLabel valueUuid is string and required") }, "XMLWebsiteData: styleLabel is object with valueUuid"), XMLContent]))) }))
 }, "XMLWebsiteData: ochre is object with website tree") }, "XMLWebsiteData: result is object with ochre") }, "XMLWebsiteData: Shape error");
-//#endregion
-export { XMLData, XMLDataItem, XMLGalleryData, XMLItemLinksData, XMLLink, XMLSetItemLocationsData, XMLSetItemsData, XMLWebsiteData };
+export { XMLData, XMLDataItem, XMLGalleryData, XMLItemLinksData, XMLItemLocationsData, XMLLink, XMLMapSourcesData, XMLSetItemsData, XMLWebsiteData };

package/dist/xml/types.d.mts

@@ -1,4 +1,3 @@
-//#region src/xml/types.d.ts
 export type XMLItemCategory = "tree" | "bibliography" | "spatialUnit" | "concept" | "period" | "person" | "propertyVariable" | "variable" | "propertyValue" | "value" | "text" | "resource" | "set";
 export type XMLRecursiveItemCategory = Exclude<XMLItemCategory, "tree" | "person" | "propertyVariable" | "propertyValue" | "set">;
 /**
@@ -139,6 +138,8 @@ export type XMLCoordinate = {
   latitude: number;
   longitude: number;
   altitude?: number;
+  WKID?: number;
+  rawValue?: string;
   source?: XMLCoordinatesSource;
 } | {
   type: "plane";
@@ -165,6 +166,13 @@ export type XMLImage = {
   fileSize?: number;
   payload?: string;
 };
+export type XMLDownloadOptions = {
+  option: Array<{
+    type: "highQualityImage" | "iiifManifest" | "document" | "ocr";
+    href: string;
+    fileFormat: string;
+  }>;
+};
 export type XMLImageMapArea = {
   uuid: string;
   publicationDateTime?: Date;
@@ -254,6 +262,7 @@ export type XMLBibliography = Partial<XMLBaseItem> & {
     publicationDateTime?: Date;
   };
   image?: XMLImage;
+  downloadOptions?: XMLDownloadOptions;
   publicationInfo?: {
     publishers?: {
       publisher: Array<XMLPerson>;
@@ -432,6 +441,7 @@ export type XMLObservation = {
   };
   links?: XMLLink;
   reverseLinks?: XMLLink | XMLDataItem | Array<XMLLink | XMLDataItem>;
+  downloadOptions?: XMLDownloadOptions;
   notes?: {
     note: Array<XMLNote>;
   };
@@ -544,6 +554,7 @@ export type XMLResource = XMLBaseItem & {
   width?: number;
   image?: XMLImage;
   imagemap?: XMLImageMap;
+  downloadOptions?: XMLDownloadOptions;
   document?: XMLContent;
   coordinates?: XMLCoordinates;
   periods?: {
@@ -887,23 +898,49 @@ export type XMLSetItemsData = {
     };
   };
 };
-export type XMLSetItemLocation = {
+export type XMLItemLocation = {
   uuid: string;
   category: string;
+  scopeUuid: string;
   publicationDateTime?: Date;
   identification: XMLIdentification;
   coordinates?: XMLCoordinates;
+  mapData?: XMLSpatialUnit["mapData"];
   value?: Array<{
     variable: string;
     uuid: string;
   } & XMLContent>;
 };
-export type XMLSetItemLocationsData = {
+export type XMLItemLocationsData = {
   result: {
     ochre: {
       items: {
         totalCount: number;
-        itemLocation?: Array<XMLSetItemLocation>;
+        itemLocation?: Array<XMLItemLocation>;
+      };
+    };
+  };
+};
+export type XMLMapLayer = {
+  uuid: string;
+  category: string;
+  type?: string;
+  href?: string;
+  WKID?: number;
+  identification: XMLIdentification;
+};
+export type XMLMapSource = {
+  uuid: string;
+  category: string;
+  WKID?: number;
+  identification: XMLIdentification;
+  mapLayer?: Array<XMLMapLayer>;
+};
+export type XMLMapSourcesData = {
+  result: {
+    ochre: {
+      mapSources: {
+        mapSource?: Array<XMLMapSource>;
       };
     };
   };
@@ -930,8 +967,12 @@ export type XMLWebsiteData = {
       metadata: XMLMetadata;
       persistentUrl?: string;
       tree: Array<XMLWebsiteTree>;
+      styleLabels?: {
+        styleLabel?: Array<{
+          valueUuid: string;
+        } & XMLContent>;
+      };
     };
   };
 };
-export type XMLHeadingItemCategory = Exclude<XMLItemCategory, "tree" | "bibliography" | "spatialUnit" | "concept" | "period">;
-//#endregion
+export type XMLHeadingItemCategory = Exclude<XMLItemCategory, "tree" | "bibliography" | "spatialUnit" | "concept" | "period">;

package/dist/xquery.d.mts

@@ -1,4 +1,3 @@
-//#region src/xquery.d.ts
 /**
  * Build a string literal for an XQuery string
  * @param value - The string value to escape
@@ -74,5 +73,4 @@ export declare function compileOchreQuery(parameters: {
   declarations?: ReadonlyArray<string>;
   body: (context: OchreQueryContext) => string;
   contentLanguage?: OchreContentLanguage | null;
-}): string;
-//#endregion
+}): string;

package/dist/xquery.mjs

@@ -1,5 +1,5 @@
 import { DEFAULT_LANGUAGES } from "./constants.mjs";
-//#region src/xquery.ts
+// src/xquery.ts
 /**
 * Build a string literal for an XQuery string
 * @param value - The string value to escape
@@ -137,5 +137,4 @@ ${contentLanguage == null ? bodyExpression : `local:select-language((
 ${bodyExpression}
 ), ${stringLiteral(contentLanguage.language)}, ${stringLiteral(contentLanguage.fallbackLanguage)})`}`;
 }
-//#endregion
 export { OCHRE_RESPONSE_PADDING, compileOchreQuery, getContentLanguage, stringLiteral };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ochre-sdk",
-  "version": "1.3.12",
+  "version": "1.3.14",
   "type": "module",
   "license": "MIT",
   "description": "Node.js library for working with OCHRE (Online Cultural and Historical Research Environment) data",
@@ -45,7 +45,8 @@
     "dist"
   ],
   "dependencies": {
-    "fast-equals": "^6.1.1",
+    "@nodable/entities": "^3.1.0",
+    "fast-equals": "^6.2.1",
     "fast-xml-parser": "^5.11.2",
     "valibot": "^1.5.0"
   },
@@ -53,21 +54,21 @@
     "@antfu/eslint-config": "^9.5.1",
     "@types/node": "^24.19.2",
     "bumpp": "^12.3.0",
-    "eslint": "^10.12.0",
+    "eslint": "^10.13.0",
     "eslint-plugin-erasable-syntax-only": "^0.7.2",
     "eslint-plugin-slop": "^0.1.3",
     "eslint-plugin-sonarjs": "^4.2.2",
-    "knip": "^6.41.0",
-    "oxfmt": "^0.73.0",
+    "knip": "^6.42.1",
+    "oxfmt": "^0.74.0",
     "tsdown": "^0.23.1",
     "typescript": "^6.0.3",
-    "vitest": "^5.0.4"
+    "vitest": "^5.0.5"
   },
   "scripts": {
     "dev": "tsdown src/index.ts --watch",
     "build": "tsdown",
-    "lint": "knip && eslint --concurrency auto .",
-    "lint:fix": "knip --fix && eslint --concurrency auto --fix .",
+    "lint": "knip && eslint .",
+    "lint:fix": "knip --fix && eslint --fix .",
     "format": "oxfmt --check",
     "format:fix": "oxfmt",
     "check-types": "tsc --noEmit",

package/dist/fetchers/set/item-locations.d.mts

@@ -1,35 +0,0 @@
-import { Query, SetItemLocation } from "../../types/index.mjs";
-import { FetchBaseOptions, FetchLanguages } from "../../parsers/helpers.mjs";
-//#region src/fetchers/set/item-locations.d.ts
-/**
- * Fetches the location of every Set item that matches a query, without paging
- *
- * Each item carries only its identification, its publication date, its coordinates and the values of
- * the requested property variables (inherited values included), which is what a
- * map needs to draw and colour every match while a list pages through the same
- * query with {@link fetchSetItems}.
- *
- * @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.propertyVariableUuids - The property variables whose values each item should carry
- * @param options - Options for the fetch
- * @param options.fetch - The fetch function to use
- * @returns The item locations, or an error if the fetch/parse fails
- */
-export declare function fetchSetItemLocations<const TLanguages extends ReadonlyArray<string> | undefined = undefined>(parameters: {
-  setScopeUuids: Array<string>;
-  queries?: Query | null;
-  propertyVariableUuids?: Array<string>;
-}, options?: FetchBaseOptions<TLanguages>): Promise<{
-  totalCount: number;
-  items: Array<SetItemLocation<FetchLanguages<TLanguages>>>;
-  error: null;
-  detailedError: null;
-} | {
-  totalCount: null;
-  items: null;
-  error: string;
-  detailedError: string;
-}>;
-//#endregion

package/dist/fetchers/set/item-locations.mjs

@@ -1,83 +0,0 @@
-import { normalizeItemCategory } from "../../categories.mjs";
-import { getErrorOutput } from "../../errors.mjs";
-import { requestOchre } from "../request.mjs";
-import { setItemLocationsParametersSchema } from "../../schemas.mjs";
-import { parseRequiredContentLike } from "../../parsers/helpers.mjs";
-import { parseRequestedLanguages, resolveContentLanguages } from "../../parsers/languages.mjs";
-import { parseCoordinates, parseIdentification } from "../../parsers/index.mjs";
-import { XMLSetItemLocationsData } from "../../xml/schemas.mjs";
-import { getContentLanguage, stringLiteral } from "../../xquery.mjs";
-import { compileContainerItemsQuery } from "../../query.mjs";
-import * as v from "valibot";
-//#region src/fetchers/set/item-locations.ts
-async function fetchSetItemLocations(parameters, options) {
-	try {
-		const { setScopeUuids, belongsToCollectionScopeUuids, queries, propertyVariableUuids } = v.parse(setItemLocationsParametersSchema, parameters);
-		const output = await requestOchre({
-			xquery: compileContainerItemsQuery({
-				container: "set",
-				scopeUuids: setScopeUuids,
-				belongsToCollectionScopeUuids,
-				queries,
-				contentLanguage: getContentLanguage(options),
-				body: ({ items }) => `  let $propertyVariableUuids := (${Array.from(propertyVariableUuids, (uuid) => stringLiteral(uuid)).join(", ")})
-
-  return <items totalCount="{count(${items})}">{
-    for $item in ${items}
-    return <itemLocation uuid="{$item/@uuid}" category="{local-name($item)}">{
-      $item/@publicationDateTime,
-      $item/identification,
-      $item/coordinates,
-      for $value in $item//properties//property[label/@uuid = $propertyVariableUuids]/value[@uuid]
-      return <value variable="{$value/../label/@uuid}" uuid="{$value/@uuid}">{$value/content}</value>
-    }</itemLocation>
-  }</items>`
-			}),
-			schema: XMLSetItemLocationsData,
-			label: "OCHRE Set item locations",
-			options
-		});
-		const languages = resolveContentLanguages(output.result.ochre.items, parseRequestedLanguages(options?.languages));
-		const itemsByUuid = /* @__PURE__ */ new Map();
-		const itemLocations = output.result.ochre.items.itemLocation ?? [];
-		for (const itemLocation of itemLocations) {
-			const category = normalizeItemCategory(itemLocation.category);
-			if (category == null || itemsByUuid.has(itemLocation.uuid)) continue;
-			const propertyValues = [];
-			const seenPropertyValues = /* @__PURE__ */ new Set();
-			const values = itemLocation.value ?? [];
-			for (const value of values) {
-				const key = `${value.variable}:${value.uuid}`;
-				if (seenPropertyValues.has(key)) continue;
-				seenPropertyValues.add(key);
-				propertyValues.push({
-					variableUuid: value.variable,
-					valueUuid: value.uuid,
-					label: parseRequiredContentLike(value, { languages })
-				});
-			}
-			itemsByUuid.set(itemLocation.uuid, {
-				uuid: itemLocation.uuid,
-				category,
-				publicationDateTime: itemLocation.publicationDateTime ?? null,
-				identification: parseIdentification(itemLocation.identification, { languages }),
-				coordinates: parseCoordinates(itemLocation.coordinates, { languages }),
-				propertyValues
-			});
-		}
-		return {
-			totalCount: output.result.ochre.items.totalCount,
-			items: itemsByUuid.values().toArray(),
-			error: null,
-			detailedError: null
-		};
-	} catch (error) {
-		return {
-			totalCount: null,
-			items: null,
-			...getErrorOutput(error, "Failed to fetch Set item locations")
-		};
-	}
-}
-//#endregion
-export { fetchSetItemLocations };