ochre-sdk 0.21.4 → 0.21.6

package/dist/index.d.mts

@@ -670,14 +670,15 @@ type SetItemsSort = {
   direction?: SetItemsSortDirection;
   language?: string;
 };
+type QueryPropertyDataType = Exclude<PropertyValueContentType, "coordinate"> | "all";
 /**
  * Represents a leaf query for Set items
  */
 type QueryLeaf = {
   target: "property";
   propertyVariable?: string;
-  dataType: Exclude<Exclude<PropertyValueContentType, "coordinate">, "date" | "dateTime">;
-  propertyValues?: Array<string>;
+  dataType: "all";
+  value: string;
   from?: never;
   to?: never;
   matchMode: "includes" | "exact";
@@ -686,10 +687,9 @@ type QueryLeaf = {
   isNegated?: boolean;
 } | {
   target: "property";
-  propertyVariable: string;
-  dataType: "date" | "dateTime";
-  propertyValues?: never;
-  value: string;
+  propertyVariable?: string;
+  dataType: Exclude<PropertyValueContentType, "coordinate">;
+  value?: string;
   from?: never;
   to?: never;
   matchMode: "includes" | "exact";
@@ -700,7 +700,6 @@ type QueryLeaf = {
   target: "property";
   propertyVariable: string;
   dataType: "date" | "dateTime";
-  propertyValues?: never;
   value?: never;
   from: string;
   to?: string;
@@ -712,7 +711,6 @@ type QueryLeaf = {
   target: "property";
   propertyVariable: string;
   dataType: "date" | "dateTime";
-  propertyValues?: never;
   value?: never;
   from?: string;
   to: string;
@@ -1530,4 +1528,4 @@ declare const DEFAULT_PAGE_SIZE = 48;
  */
 declare function flattenItemProperties<T extends DataCategory = DataCategory, U extends DataCategory | Array<DataCategory> = (T extends "tree" ? Exclude<DataCategory, "tree"> : T extends "set" ? Array<DataCategory> : never)>(item: Item<T, U>): Item<T, U>;
 //#endregion
-export { ApiVersion, Bibliography, Concept, Context, ContextItem, ContextNode, Coordinate, DEFAULT_API_VERSION, DEFAULT_PAGE_SIZE, Data, DataCategory, Event, FileFormat, Gallery, Identification, Image, ImageMap, ImageMapArea, Interpretation, Item, LevelContext, LevelContextItem, License, Link, Metadata, Note, Observation, Period, Person, Property, PropertyContexts, PropertyValue, PropertyValueContent, PropertyValueContentType, PropertyValueQueryItem, PropertyVariable, Query, QueryGroup, QueryLeaf, Resource, Scope, Section, Set, SetAttributeValueQueryItem, SetItemsSort, SetItemsSortDirection, SpatialUnit, Style, StylesheetCategory, StylesheetItem, Text, Tree, WebBlock, WebBlockLayout, WebElement, WebElementComponent, WebImage, WebSegment, WebSegmentItem, WebTitle, Webpage, Website, WebsitePropertyQuery, WebsitePropertyQueryNode, WebsiteType, fetchGallery, fetchItem, fetchSetItems, fetchSetPropertyValues, fetchWebsite, filterProperties, flattenItemProperties, getLeafPropertyValues, getPropertyByLabel, getPropertyByLabelAndValue, getPropertyByLabelAndValues, getPropertyByUuid, getPropertyValueByLabel, getPropertyValueByUuid, getPropertyValuesByLabel, getPropertyValuesByUuid, getUniqueProperties, getUniquePropertyLabels };
+export { ApiVersion, Bibliography, Concept, Context, ContextItem, ContextNode, Coordinate, DEFAULT_API_VERSION, DEFAULT_PAGE_SIZE, Data, DataCategory, Event, FileFormat, Gallery, Identification, Image, ImageMap, ImageMapArea, Interpretation, Item, LevelContext, LevelContextItem, License, Link, Metadata, Note, Observation, Period, Person, Property, PropertyContexts, PropertyValue, PropertyValueContent, PropertyValueContentType, PropertyValueQueryItem, PropertyVariable, Query, QueryGroup, QueryLeaf, QueryPropertyDataType, Resource, Scope, Section, Set, SetAttributeValueQueryItem, SetItemsSort, SetItemsSortDirection, SpatialUnit, Style, StylesheetCategory, StylesheetItem, Text, Tree, WebBlock, WebBlockLayout, WebElement, WebElementComponent, WebImage, WebSegment, WebSegmentItem, WebTitle, Webpage, Website, WebsitePropertyQuery, WebsitePropertyQueryNode, WebsiteType, fetchGallery, fetchItem, fetchSetItems, fetchSetPropertyValues, fetchWebsite, filterProperties, flattenItemProperties, getLeafPropertyValues, getPropertyByLabel, getPropertyByLabelAndValue, getPropertyByLabelAndValues, getPropertyByUuid, getPropertyValueByLabel, getPropertyValueByUuid, getPropertyValuesByLabel, getPropertyValuesByUuid, getUniqueProperties, getUniquePropertyLabels };

package/dist/index.mjs

@@ -757,6 +757,18 @@ const boundsSchema = z.string().transform((str, ctx) => {
 * @internal
 */
 const setQueryLeafSchema = z.union([
+	z.object({
+		target: z.literal("property"),
+		propertyVariable: uuidSchema.optional(),
+		dataType: z.literal("all"),
+		value: z.string(),
+		from: z.never().optional(),
+		to: z.never().optional(),
+		matchMode: z.enum(["includes", "exact"]),
+		isCaseSensitive: z.boolean(),
+		language: z.string().default("eng"),
+		isNegated: z.boolean().optional().default(false)
+	}).strict(),
 	z.object({
 		target: z.literal("property"),
 		propertyVariable: uuidSchema.optional(),
@@ -765,32 +777,24 @@ const setQueryLeafSchema = z.union([
 			"integer",
 			"decimal",
 			"boolean",
-			"time",
-			"IDREF"
+			"IDREF",
+			"date",
+			"dateTime",
+			"time"
 		]),
-		propertyValues: z.array(z.string()).min(1, "At least one property value is required").optional(),
+		value: z.string().optional(),
+		from: z.never().optional(),
+		to: z.never().optional(),
 		matchMode: z.enum(["includes", "exact"]),
 		isCaseSensitive: z.boolean(),
 		language: z.string().default("eng"),
 		isNegated: z.boolean().optional().default(false)
 	}).strict().superRefine((value, ctx) => {
-		if (value.propertyVariable == null && value.propertyValues == null) ctx.addIssue({
+		if (value.propertyVariable == null && value.value == null) ctx.addIssue({
 			code: "custom",
-			message: "Property queries must include at least one propertyVariable or propertyValue"
+			message: "Property queries must include at least one propertyVariable or value"
 		});
 	}),
-	z.object({
-		target: z.literal("property"),
-		propertyVariable: uuidSchema,
-		dataType: z.enum(["date", "dateTime"]),
-		value: z.string(),
-		from: z.never().optional(),
-		to: z.never().optional(),
-		matchMode: z.enum(["includes", "exact"]),
-		isCaseSensitive: z.boolean(),
-		language: z.string().default("eng"),
-		isNegated: z.boolean().optional().default(false)
-	}).strict(),
 	z.object({
 		target: z.literal("property"),
 		propertyVariable: uuidSchema,
@@ -2158,6 +2162,28 @@ const CTS_INCLUDES_STOP_WORDS = [
 ];
 const CTS_INCLUDES_STOP_WORDS_VAR = "$ctsIncludesStopWords";
 const CTS_INCLUDES_TOKEN_SPLIT_REGEX = /\W+/u;
+const CONTENT_TARGET_CONFIGS = {
+	title: {
+		containerElementName: "identification",
+		getContentNodesExpression: (language) => `identification/label/content[@xml:lang="${language}"]`
+	},
+	description: {
+		containerElementName: "description",
+		getContentNodesExpression: (language) => `description/content[@xml:lang="${language}"]`
+	},
+	image: {
+		containerElementName: "image",
+		getContentNodesExpression: (language) => `image/identification/label/content[@xml:lang="${language}"]`
+	},
+	periods: {
+		containerElementName: "period",
+		getContentNodesExpression: (language) => `periods/period/identification/label/content[@xml:lang="${language}"]`
+	},
+	bibliography: {
+		containerElementName: "bibliography",
+		getContentNodesExpression: (language) => `bibliographies/bibliography/identification/label/content[@xml:lang="${language}"]`
+	}
+};
 function tokenizeIncludesSearchValue(params) {
 	const { value, isCaseSensitive } = params;
 	const rawTerms = (isCaseSensitive ? value : value.toLowerCase()).split(CTS_INCLUDES_TOKEN_SPLIT_REGEX);
@@ -2172,6 +2198,10 @@ function buildFlattenedContentValuesExpression(contentNodesExpression) {
 	return `for $content in ${contentNodesExpression}
     return string-join($content//text(), "")`;
 }
+function buildNodeStringValuesExpression(nodesExpression) {
+	return `for $node in ${nodesExpression}
+    return string($node)`;
+}
 function buildSearchableContentNodesExpression(contentNodesExpression) {
 	return `for $content in ${contentNodesExpression}
     return (
@@ -2186,6 +2216,18 @@ function buildCombinedSearchableContentNodesExpression(contentNodesExpressions)
 	if (searchableExpressions.length === 1) return searchableExpressions[0] ?? "()";
 	return `(${searchableExpressions.join(", ")})`;
 }
+function buildTokenizedSearchPredicate(params) {
+	const { searchableNodesExpression, termsExpression, isCaseSensitive } = params;
+	return `(every $term in ${termsExpression}
+  satisfies some $searchNode in (${searchableNodesExpression})
+    satisfies cts:contains(
+      $searchNode,
+      ${buildCtsWordQueryExpression({
+		termExpression: "$term",
+		isCaseSensitive
+	})}
+    ))`;
+}
 /**
 * Build a string match predicate for an XQuery string.
 */
@@ -2252,8 +2294,8 @@ function buildTokenizedSearchDeclarations(params) {
 		termsVar
 	};
 }
-function buildCtsIncludesPredicate(params) {
-	const { searchableNodesExpression, fallbackValueExpression, value, isCaseSensitive, queryKey, buildCandidateTermQuery } = params;
+function buildTokenizedCtsClause(params) {
+	const { value, isCaseSensitive, queryKey, fallbackPredicate, buildTermQueryExpression, buildTokenPredicate } = params;
 	const tokenizedSearchDeclarations = buildTokenizedSearchDeclarations({
 		value,
 		isCaseSensitive,
@@ -2261,12 +2303,6 @@ function buildCtsIncludesPredicate(params) {
 	});
 	const termQueriesVar = `$query${queryKey}TermQueries`;
 	const candidateQueryVar = `$query${queryKey}CandidateQuery`;
-	const fallbackPredicate = buildRawStringMatchPredicate({
-		valueExpression: fallbackValueExpression,
-		value,
-		matchMode: "includes",
-		isCaseSensitive
-	});
 	if (tokenizeIncludesSearchValue({
 		value,
 		isCaseSensitive
@@ -2280,7 +2316,7 @@ function buildCtsIncludesPredicate(params) {
 			...tokenizedSearchDeclarations.declarations,
 			`let ${termQueriesVar} :=
   for $term in ${tokenizedSearchDeclarations.termsVar}
-    return ${buildCandidateTermQuery("$term")}`,
+    return ${buildTermQueryExpression("$term")}`,
 			`let ${candidateQueryVar} :=
   if (count(${tokenizedSearchDeclarations.termsVar}) = 1)
   then ${termQueriesVar}[1]
@@ -2288,18 +2324,30 @@ function buildCtsIncludesPredicate(params) {
   then cts:and-query(${termQueriesVar})
   else ()`
 		],
-		predicate: `(every $term in ${tokenizedSearchDeclarations.termsVar}
-  satisfies some $searchNode in (${searchableNodesExpression})
-    satisfies cts:contains(
-      $searchNode,
-      ${buildCtsWordQueryExpression({
-			termExpression: "$term",
-			isCaseSensitive
-		})}
-    ))`,
+		predicate: buildTokenPredicate(tokenizedSearchDeclarations.termsVar),
 		candidateQueryVar
 	};
 }
+function buildCtsIncludesPredicate(params) {
+	const { searchableNodesExpression, fallbackValueExpression, value, isCaseSensitive, queryKey, buildCandidateTermQuery } = params;
+	return buildTokenizedCtsClause({
+		value,
+		isCaseSensitive,
+		queryKey,
+		fallbackPredicate: buildRawStringMatchPredicate({
+			valueExpression: fallbackValueExpression,
+			value,
+			matchMode: "includes",
+			isCaseSensitive
+		}),
+		buildTermQueryExpression: buildCandidateTermQuery,
+		buildTokenPredicate: (termsExpression) => buildTokenizedSearchPredicate({
+			searchableNodesExpression,
+			termsExpression,
+			isCaseSensitive
+		})
+	});
+}
 /**
 * Build the raw search paths for item-level string search.
 */
@@ -2423,6 +2471,9 @@ function getQueryGroupChildren(query) {
 function getQueryGroupOperator(query) {
 	return "and" in query ? "and" : "or";
 }
+function getContentTargetConfig(target) {
+	return CONTENT_TARGET_CONFIGS[target];
+}
 function buildContentTargetCandidateBranch(params) {
 	const { containerElementName, termExpression, isCaseSensitive, language } = params;
 	return `cts:element-query(xs:QName("${containerElementName}"),
@@ -2456,6 +2507,114 @@ function buildPropertyStringCandidateBranch(params) {
         )
       )`;
 }
+function buildPropertyContentNodesExpression(params) {
+	const { language, excludeInherited } = params;
+	return `${excludeInherited ? `value[not(@inherited="true")]` : "value"}/content[@xml:lang="${language}"]`;
+}
+function buildPropertyRawValueCandidateBranch(params) {
+	const { termExpression, isCaseSensitive } = params;
+	return `cts:element-query(xs:QName("properties"),
+        cts:element-query(xs:QName("property"),
+          cts:element-attribute-word-query(
+            xs:QName("value"),
+            xs:QName("rawValue"),
+            ${termExpression},
+            ${buildCtsQueryOptionsExpression(isCaseSensitive)}
+          )
+        )
+      )`;
+}
+function buildPropertySimpleValueTextCandidateBranch(params) {
+	const { termExpression, isCaseSensitive } = params;
+	return `cts:element-query(xs:QName("properties"),
+        cts:element-query(xs:QName("property"),
+          cts:element-word-query(
+            xs:QName("value"),
+            ${termExpression},
+            ${buildCtsQueryOptionsExpression(isCaseSensitive)}
+          )
+        )
+      )`;
+}
+function buildPropertySimpleValueRawValueExpression() {
+	return buildNodeStringValuesExpression("value/@rawValue");
+}
+function buildPropertySimpleValueTextExpression() {
+	return buildNodeStringValuesExpression("value[not(*)]/text()");
+}
+function buildPropertySimpleValueSearchableNodesExpression() {
+	return "value[not(*)]";
+}
+function buildPropertyContentRawPredicate(params) {
+	const { value, matchMode, isCaseSensitive, language, excludeInherited } = params;
+	return buildRawStringMatchPredicate({
+		valueExpression: buildFlattenedContentValuesExpression(buildPropertyContentNodesExpression({
+			language,
+			excludeInherited
+		})),
+		value,
+		matchMode,
+		isCaseSensitive
+	});
+}
+function buildPropertyRawValueOrTextRawPredicate(params) {
+	const { value, matchMode, isCaseSensitive } = params;
+	return buildOrPredicate([buildRawStringMatchPredicate({
+		valueExpression: buildPropertySimpleValueRawValueExpression(),
+		value,
+		matchMode,
+		isCaseSensitive
+	}), buildRawStringMatchPredicate({
+		valueExpression: buildPropertySimpleValueTextExpression(),
+		value,
+		matchMode,
+		isCaseSensitive
+	})]);
+}
+function buildPropertyRawValueOrTextTokenPredicate(params) {
+	const { termsExpression, isCaseSensitive } = params;
+	const rawValueQuery = `cts:element-attribute-word-query(
+        xs:QName("value"),
+        xs:QName("rawValue"),
+        $term,
+        ${buildCtsQueryOptionsExpression(isCaseSensitive)}
+      )`;
+	const textQuery = `cts:element-word-query(
+        xs:QName("value"),
+        $term,
+        ${buildCtsQueryOptionsExpression(isCaseSensitive)}
+      )`;
+	return `(every $term in ${termsExpression}
+  satisfies some $searchNode in (${buildPropertySimpleValueSearchableNodesExpression()})
+    satisfies (
+      cts:contains($searchNode, ${rawValueQuery})
+      or
+      cts:contains($searchNode, ${textQuery})
+    ))`;
+}
+function buildPropertyContentTokenPredicate(params) {
+	const { termsExpression, isCaseSensitive, language, excludeInherited } = params;
+	return buildTokenizedSearchPredicate({
+		searchableNodesExpression: buildSearchableContentNodesExpression(buildPropertyContentNodesExpression({
+			language,
+			excludeInherited
+		})),
+		termsExpression,
+		isCaseSensitive
+	});
+}
+function buildIncludesGroupMemberFromTokenSource(params) {
+	const { rawPredicate, searchableNodesExpression, isCaseSensitive, buildCandidateTermQuery } = params;
+	return {
+		rawPredicate,
+		buildTokenPredicate: (termsExpression) => buildTokenizedSearchPredicate({
+			searchableNodesExpression,
+			termsExpression,
+			isCaseSensitive
+		}),
+		buildCandidateTermQuery
+	};
+}
 function getGroupableIncludesValue(query) {
 	switch (query.target) {
 		case "string":
@@ -2465,8 +2624,9 @@ function getGroupableIncludesValue(query) {
 		case "periods":
 		case "bibliography": return query.value;
 		case "property":
-			if (query.dataType !== "string" || query.propertyValues?.length !== 1) return null;
-			return query.propertyValues[0] ?? null;
+			if (query.dataType === "IDREF") return null;
+			if (query.dataType === "date" || query.dataType === "dateTime") return "value" in query && query.value != null ? query.value : null;
+			return query.value ?? null;
 	}
 }
 function isCompatibleIncludesGroupQuery(params) {
@@ -2476,30 +2636,36 @@ function isCompatibleIncludesGroupQuery(params) {
 	return queryValue != null && queryValue === value && query.isCaseSensitive === isCaseSensitive && query.language === language;
 }
 function buildContentTargetIncludesGroupMember(params) {
-	const { contentNodesExpression, value, isCaseSensitive, language, containerElementName } = params;
-	return {
+	const { query } = params;
+	const config = getContentTargetConfig(query.target);
+	const contentNodesExpression = config.getContentNodesExpression(query.language);
+	return buildIncludesGroupMemberFromTokenSource({
 		rawPredicate: buildRawStringMatchPredicate({
 			valueExpression: buildFlattenedContentValuesExpression(contentNodesExpression),
-			value,
+			value: query.value,
 			matchMode: "includes",
-			isCaseSensitive
+			isCaseSensitive: query.isCaseSensitive
 		}),
+		searchableNodesExpression: buildSearchableContentNodesExpression(contentNodesExpression),
+		isCaseSensitive: query.isCaseSensitive,
 		buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-			containerElementName,
+			containerElementName: config.containerElementName,
 			termExpression,
-			isCaseSensitive,
-			language
+			isCaseSensitive: query.isCaseSensitive,
+			language: query.language
 		})
-	};
+	});
 }
 function buildItemStringIncludesGroupMember(query) {
-	return {
+	return buildIncludesGroupMemberFromTokenSource({
 		rawPredicate: buildCombinedRawStringMatchPredicate({
 			valueExpressions: buildItemStringSearchPaths(query.language),
 			value: query.value,
 			matchMode: "includes",
 			isCaseSensitive: query.isCaseSensitive
 		}),
+		searchableNodesExpression: buildItemStringSearchableNodesExpression(query.language),
+		isCaseSensitive: query.isCaseSensitive,
 		buildCandidateTermQuery: (termExpression) => `cts:or-query((
         ${buildItemStringIdentificationBranch({
 			termExpression,
@@ -2512,67 +2678,112 @@ function buildItemStringIncludesGroupMember(query) {
 			language: query.language
 		})}
       ))`
-	};
+	});
 }
 function buildPropertyStringIncludesGroupMember(query) {
 	const propertyVariable = query.propertyVariable;
 	const predicateParts = [];
-	const valueExpression = buildFlattenedContentValuesExpression(`value[not(@inherited="true")]/content[@xml:lang="${query.language}"]`);
-	const propertyValue = query.propertyValues[0] ?? "";
+	const propertyValue = query.value;
 	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
-	return {
-		rawPredicate: buildPropertyPredicateExpression([...predicateParts, buildRawStringMatchPredicate({
-			valueExpression,
+	return buildIncludesGroupMemberFromTokenSource({
+		rawPredicate: buildPropertyPredicateExpression([...predicateParts, buildPropertyContentRawPredicate({
 			value: propertyValue,
 			matchMode: "includes",
-			isCaseSensitive: query.isCaseSensitive
+			isCaseSensitive: query.isCaseSensitive,
+			language: query.language,
+			excludeInherited: true
 		})]),
+		searchableNodesExpression: buildPropertyPredicateExpression([...predicateParts, buildSearchableContentNodesExpression(buildPropertyContentNodesExpression({
+			language: query.language,
+			excludeInherited: true
+		}))]),
+		isCaseSensitive: query.isCaseSensitive,
 		buildCandidateTermQuery: (termExpression) => buildPropertyStringCandidateBranch({
 			termExpression,
 			isCaseSensitive: query.isCaseSensitive,
 			language: query.language
 		})
+	});
+}
+function buildPropertyRawValueOrTextIncludesGroupMember(query) {
+	const propertyVariable = query.propertyVariable;
+	const predicateParts = [];
+	const propertyValue = getGroupableIncludesValue(query);
+	if (propertyValue == null) throw new Error("Cannot build a rawValue/text includes group without a search value");
+	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
+	return {
+		rawPredicate: buildPropertyPredicateExpression([...predicateParts, buildPropertyRawValueOrTextRawPredicate({
+			value: propertyValue,
+			matchMode: "includes",
+			isCaseSensitive: query.isCaseSensitive
+		})]),
+		buildTokenPredicate: (termsExpression) => buildPropertyPredicateExpression([...predicateParts, buildPropertyRawValueOrTextTokenPredicate({
+			termsExpression,
+			isCaseSensitive: query.isCaseSensitive
+		})]),
+		buildCandidateTermQuery: (termExpression) => buildOrCtsQueryExpression([buildPropertyRawValueCandidateBranch({
+			termExpression,
+			isCaseSensitive: query.isCaseSensitive
+		}), buildPropertySimpleValueTextCandidateBranch({
+			termExpression,
+			isCaseSensitive: query.isCaseSensitive
+		})])
 	};
 }
-function buildIncludesGroupMember(query) {
-	switch (query.target) {
-		case "string": return buildItemStringIncludesGroupMember(query);
-		case "title": return buildContentTargetIncludesGroupMember({
-			contentNodesExpression: `identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language,
-			containerElementName: "identification"
-		});
-		case "description": return buildContentTargetIncludesGroupMember({
-			contentNodesExpression: `description/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language,
-			containerElementName: "description"
-		});
-		case "periods": return buildContentTargetIncludesGroupMember({
-			contentNodesExpression: `periods/period/identification/label/content[@xml:lang="${query.language}"]`,
+function buildPropertyAllIncludesGroupMember(query) {
+	const propertyVariable = query.propertyVariable;
+	const predicateParts = [];
+	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
+	return {
+		rawPredicate: buildPropertyPredicateExpression([...predicateParts, buildOrPredicate([buildPropertyRawValueOrTextRawPredicate({
 			value: query.value,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language,
-			containerElementName: "period"
-		});
-		case "bibliography": return buildContentTargetIncludesGroupMember({
-			contentNodesExpression: `bibliographies/bibliography/identification/label/content[@xml:lang="${query.language}"]`,
+			matchMode: "includes",
+			isCaseSensitive: query.isCaseSensitive
+		}), buildPropertyContentRawPredicate({
 			value: query.value,
+			matchMode: "includes",
 			isCaseSensitive: query.isCaseSensitive,
 			language: query.language,
-			containerElementName: "bibliography"
-		});
-		case "image": return buildContentTargetIncludesGroupMember({
-			contentNodesExpression: `image/identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
+			excludeInherited: true
+		})])]),
+		buildTokenPredicate: (termsExpression) => buildPropertyPredicateExpression([...predicateParts, buildOrPredicate([buildPropertyRawValueOrTextTokenPredicate({
+			termsExpression,
+			isCaseSensitive: query.isCaseSensitive
+		}), buildPropertyContentTokenPredicate({
+			termsExpression,
 			isCaseSensitive: query.isCaseSensitive,
 			language: query.language,
-			containerElementName: "image"
-		});
-		case "property": return buildPropertyStringIncludesGroupMember(query);
+			excludeInherited: true
+		})])]),
+		buildCandidateTermQuery: (termExpression) => buildOrCtsQueryExpression([
+			buildPropertyRawValueCandidateBranch({
+				termExpression,
+				isCaseSensitive: query.isCaseSensitive
+			}),
+			buildPropertySimpleValueTextCandidateBranch({
+				termExpression,
+				isCaseSensitive: query.isCaseSensitive
+			}),
+			buildPropertyStringCandidateBranch({
+				termExpression,
+				isCaseSensitive: query.isCaseSensitive,
+				language: query.language
+			})
+		])
+	};
+}
+function buildIncludesGroupMember(query) {
+	switch (query.target) {
+		case "string": return buildItemStringIncludesGroupMember(query);
+		case "title":
+		case "description":
+		case "periods":
+		case "bibliography":
+		case "image": return buildContentTargetIncludesGroupMember({ query });
+		case "property":
+			if (query.dataType === "string") return buildPropertyStringIncludesGroupMember(query);
+			if (query.dataType === "all") return buildPropertyAllIncludesGroupMember(query);
+			return buildPropertyRawValueOrTextIncludesGroupMember(query);
 	}
 }
 function getCompatibleIncludesGroupLeaves(params) {
@@ -2609,38 +2820,14 @@ function buildIncludesGroupClause(params) {
 	const groupValue = getGroupableIncludesValue(firstQuery);
 	if (groupValue == null) throw new Error("Cannot build an includes group without a search value");
 	const members = queries.map((query) => buildIncludesGroupMember(query));
-	const tokenizedSearchDeclarations = buildTokenizedSearchDeclarations({
+	return buildTokenizedCtsClause({
 		value: groupValue,
 		isCaseSensitive: firstQuery.isCaseSensitive,
-		queryKey
-	});
-	const tokenizedTerms = tokenizeIncludesSearchValue({
-		value: groupValue,
-		isCaseSensitive: firstQuery.isCaseSensitive
+		queryKey,
+		fallbackPredicate: buildOrPredicate(members.map((member) => member.rawPredicate)),
+		buildTermQueryExpression: (termExpression) => buildOrCtsQueryExpression(members.map((member) => member.buildCandidateTermQuery(termExpression))),
+		buildTokenPredicate: (termsExpression) => buildOrPredicate(members.map((member) => member.buildTokenPredicate(termsExpression)))
 	});
-	const termQueriesVar = `$query${queryKey}TermQueries`;
-	const candidateQueryVar = `$query${queryKey}CandidateQuery`;
-	if (tokenizedTerms.length === 0) return {
-		declarations: [],
-		predicate: buildOrPredicate(members.map((member) => member.rawPredicate)),
-		candidateQueryVar: null
-	};
-	return {
-		declarations: [
-			...tokenizedSearchDeclarations.declarations,
-			`let ${termQueriesVar} :=
-  for $term in ${tokenizedSearchDeclarations.termsVar}
-    return ${buildOrCtsQueryExpression(members.map((member) => member.buildCandidateTermQuery("$term")))}`,
-			`let ${candidateQueryVar} :=
-  if (count(${tokenizedSearchDeclarations.termsVar}) = 1)
-  then ${termQueriesVar}[1]
-  else if (count(${tokenizedSearchDeclarations.termsVar}) gt 1)
-  then cts:and-query(${termQueriesVar})
-  else ()`
-		],
-		predicate: `cts:contains(., ${candidateQueryVar})`,
-		candidateQueryVar
-	};
 }
 /**
 * Build a string match predicate for an XQuery string.
@@ -2668,10 +2855,34 @@ function buildStringMatchClause(params) {
 	};
 }
 function buildPropertyValueAttributePredicate(params) {
-	const { propertyValues, attributeName } = params;
-	const valuePredicates = [];
-	for (const propertyValue of propertyValues) valuePredicates.push(`value[@${attributeName}=${stringLiteral(propertyValue)}]`);
-	return buildOrPredicate(valuePredicates);
+	const { value, attributeName } = params;
+	return `value[@${attributeName}=${stringLiteral(value)}]`;
+}
+function buildPropertyRawValueOrTextMatchClause(params) {
+	const { value, matchMode, isCaseSensitive, version, queryKey } = params;
+	const fallbackPredicate = buildPropertyRawValueOrTextRawPredicate(params);
+	if (matchMode !== "includes" || version !== 2) return {
+		declarations: [],
+		predicate: fallbackPredicate,
+		candidateQueryVar: null
+	};
+	return buildTokenizedCtsClause({
+		value,
+		isCaseSensitive,
+		queryKey,
+		fallbackPredicate,
+		buildTermQueryExpression: (termExpression) => buildOrCtsQueryExpression([buildPropertyRawValueCandidateBranch({
+			termExpression,
+			isCaseSensitive
+		}), buildPropertySimpleValueTextCandidateBranch({
+			termExpression,
+			isCaseSensitive
+		})]),
+		buildTokenPredicate: (termsExpression) => buildPropertyRawValueOrTextTokenPredicate({
+			termsExpression,
+			isCaseSensitive
+		})
+	});
 }
 function buildPropertyPredicateExpression(propertyPredicates) {
 	let propertyExpression = ".//properties//property";
@@ -2680,44 +2891,72 @@ function buildPropertyPredicateExpression(propertyPredicates) {
 }
 function buildPropertyStringValueClause(params) {
 	const { query, version, queryKey } = params;
-	const propertyContentNodesExpression = query.matchMode === "includes" && version === 2 ? `value[not(@inherited="true")]/content[@xml:lang="${query.language}"]` : `value/content[@xml:lang="${query.language}"]`;
-	const declarations = [];
-	const valuePredicates = [];
-	const candidateQueryVars = [];
-	for (const [propertyValueIndex, propertyValue] of query.propertyValues.entries()) {
-		const compiledStringClause = buildStringMatchClause({
-			contentNodesExpression: propertyContentNodesExpression,
-			value: propertyValue,
-			matchMode: query.matchMode,
+	return buildStringMatchClause({
+		contentNodesExpression: buildPropertyContentNodesExpression({
+			language: query.language,
+			excludeInherited: query.matchMode === "includes" && version === 2
+		}),
+		value: query.value,
+		matchMode: query.matchMode,
+		isCaseSensitive: query.isCaseSensitive,
+		version,
+		queryKey,
+		buildCandidateTermQuery: (termExpression) => buildPropertyStringCandidateBranch({
+			termExpression,
 			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey: `${queryKey}_${propertyValueIndex + 1}`,
-			buildCandidateTermQuery: (termExpression) => buildPropertyStringCandidateBranch({
+			language: query.language
+		})
+	});
+}
+function buildPropertyAllValueClause(params) {
+	const { query, version, queryKey } = params;
+	const excludeInheritedContent = query.matchMode === "includes" && version === 2;
+	const fallbackPredicate = buildOrPredicate([buildPropertyRawValueOrTextRawPredicate({
+		value: query.value,
+		matchMode: query.matchMode,
+		isCaseSensitive: query.isCaseSensitive
+	}), buildPropertyContentRawPredicate({
+		value: query.value,
+		matchMode: query.matchMode,
+		isCaseSensitive: query.isCaseSensitive,
+		language: query.language,
+		excludeInherited: excludeInheritedContent
+	})]);
+	if (query.matchMode !== "includes" || version !== 2) return {
+		declarations: [],
+		predicate: fallbackPredicate,
+		candidateQueryVar: null
+	};
+	return buildTokenizedCtsClause({
+		value: query.value,
+		isCaseSensitive: query.isCaseSensitive,
+		queryKey,
+		fallbackPredicate,
+		buildTermQueryExpression: (termExpression) => buildOrCtsQueryExpression([
+			buildPropertyRawValueCandidateBranch({
+				termExpression,
+				isCaseSensitive: query.isCaseSensitive
+			}),
+			buildPropertySimpleValueTextCandidateBranch({
+				termExpression,
+				isCaseSensitive: query.isCaseSensitive
+			}),
+			buildPropertyStringCandidateBranch({
 				termExpression,
 				isCaseSensitive: query.isCaseSensitive,
 				language: query.language
 			})
-		});
-		declarations.push(...compiledStringClause.declarations);
-		valuePredicates.push(compiledStringClause.predicate);
-		if (compiledStringClause.candidateQueryVar != null) candidateQueryVars.push(compiledStringClause.candidateQueryVar);
-	}
-	let candidateQueryVar = null;
-	if (candidateQueryVars.length > 0) {
-		const candidateQueriesExpression = `(${candidateQueryVars.join(", ")})`;
-		candidateQueryVar = `$query${queryKey}CandidateQuery`;
-		declarations.push(`let ${candidateQueryVar} :=
-  if (count(${candidateQueriesExpression}) = 1)
-  then ${candidateQueriesExpression}[1]
-  else if (count(${candidateQueriesExpression}) gt 1)
-  then cts:or-query(${candidateQueriesExpression})
-  else ()`);
-	}
-	return {
-		declarations,
-		predicate: buildOrPredicate(valuePredicates),
-		candidateQueryVar
-	};
+		]),
+		buildTokenPredicate: (termsExpression) => buildOrPredicate([buildPropertyRawValueOrTextTokenPredicate({
+			termsExpression,
+			isCaseSensitive: query.isCaseSensitive
+		}), buildPropertyContentTokenPredicate({
+			termsExpression,
+			isCaseSensitive: query.isCaseSensitive,
+			language: query.language,
+			excludeInherited: true
+		})])
+	});
 }
 /**
 * Build a property predicate for an XQuery string.
@@ -2729,27 +2968,55 @@ function buildPropertyClause(params) {
 	const propertyVariable = query.propertyVariable;
 	let candidateQueryVar = null;
 	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
-	if (query.dataType === "date" || query.dataType === "dateTime") if ("value" in query && query.value != null) predicateParts.push(`value/@rawValue = ${stringLiteral(query.value)}`);
-	else predicateParts.push(buildDateRangePredicate({
+	if (query.dataType === "date" || query.dataType === "dateTime") if ("value" in query && query.value != null) {
+		const compiledScalarClause = buildPropertyRawValueOrTextMatchClause({
+			value: query.value,
+			matchMode: query.matchMode,
+			isCaseSensitive: query.isCaseSensitive,
+			version,
+			queryKey
+		});
+		declarations.push(...compiledScalarClause.declarations);
+		predicateParts.push(compiledScalarClause.predicate);
+		candidateQueryVar = compiledScalarClause.candidateQueryVar;
+	} else predicateParts.push(buildDateRangePredicate({
 		from: query.from,
 		to: query.to
 	}));
-	else if (query.propertyValues != null) switch (query.dataType) {
+	else if (query.value != null) switch (query.dataType) {
 		case "IDREF":
 			predicateParts.push(buildPropertyValueAttributePredicate({
-				propertyValues: query.propertyValues,
+				value: query.value,
 				attributeName: "uuid"
 			}));
 			break;
+		case "all": {
+			const compiledAllClause = buildPropertyAllValueClause({
+				query,
+				version,
+				queryKey
+			});
+			declarations.push(...compiledAllClause.declarations);
+			predicateParts.push(compiledAllClause.predicate);
+			candidateQueryVar = compiledAllClause.candidateQueryVar;
+			break;
+		}
 		case "integer":
 		case "decimal":
 		case "time":
-		case "boolean":
-			predicateParts.push(buildPropertyValueAttributePredicate({
-				propertyValues: query.propertyValues,
-				attributeName: "rawValue"
-			}));
+		case "boolean": {
+			const compiledScalarClause = buildPropertyRawValueOrTextMatchClause({
+				value: query.value,
+				matchMode: query.matchMode,
+				isCaseSensitive: query.isCaseSensitive,
+				version,
+				queryKey
+			});
+			declarations.push(...compiledScalarClause.declarations);
+			predicateParts.push(compiledScalarClause.predicate);
+			candidateQueryVar = compiledScalarClause.candidateQueryVar;
 			break;
+		}
 		case "string": {
 			const compiledStringClause = buildPropertyStringValueClause({
 				query,
@@ -2779,76 +3046,27 @@ function buildQueryClause(params) {
 			version,
 			queryKey
 		});
-		case "title": return buildStringMatchClause({
-			contentNodesExpression: `identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-				containerElementName: "identification",
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
-		case "description": return buildStringMatchClause({
-			contentNodesExpression: `description/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-				containerElementName: "description",
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
-		case "periods": return buildStringMatchClause({
-			contentNodesExpression: `periods/period/identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-				containerElementName: "period",
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
-		case "bibliography": return buildStringMatchClause({
-			contentNodesExpression: `bibliographies/bibliography/identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-				containerElementName: "bibliography",
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
-		case "image": return buildStringMatchClause({
-			contentNodesExpression: `image/identification/label/content[@xml:lang="${query.language}"]`,
-			value: query.value,
-			matchMode: query.matchMode,
-			isCaseSensitive: query.isCaseSensitive,
-			version,
-			queryKey,
-			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-				containerElementName: "image",
-				termExpression,
+		case "title":
+		case "description":
+		case "periods":
+		case "bibliography":
+		case "image": {
+			const config = getContentTargetConfig(query.target);
+			return buildStringMatchClause({
+				contentNodesExpression: config.getContentNodesExpression(query.language),
+				value: query.value,
+				matchMode: query.matchMode,
 				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
+				version,
+				queryKey,
+				buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
+					containerElementName: config.containerElementName,
+					termExpression,
+					isCaseSensitive: query.isCaseSensitive,
+					language: query.language
+				})
+			});
+		}
 		case "property": return buildPropertyClause({
 			query,
 			version,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ochre-sdk",
-  "version": "0.21.4",
+  "version": "0.21.6",
   "type": "module",
   "license": "MIT",
   "description": "Node.js library for working with OCHRE (Online Cultural and Historical Research Environment) data",