ochre-sdk 1.3.11 → 1.3.13

package/dist/xml/schemas.mjs

@@ -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),
@@ -558,10 +564,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) })),
@@ -928,21 +931,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 +979,8 @@ 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

@@ -139,6 +139,8 @@ export type XMLCoordinate = {
   latitude: number;
   longitude: number;
   altitude?: number;
+  WKID?: number;
+  rawValue?: string;
   source?: XMLCoordinatesSource;
 } | {
   type: "plane";
@@ -887,23 +889,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,6 +958,11 @@ export type XMLWebsiteData = {
       metadata: XMLMetadata;
       persistentUrl?: string;
       tree: Array<XMLWebsiteTree>;
+      styleLabels?: {
+        styleLabel?: Array<{
+          valueUuid: string;
+        } & XMLContent>;
+      };
     };
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ochre-sdk",
-  "version": "1.3.11",
+  "version": "1.3.13",
   "type": "module",
   "license": "MIT",
   "description": "Node.js library for working with OCHRE (Online Cultural and Historical Research Environment) data",
@@ -66,8 +66,8 @@
   "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 };