ochre-sdk 0.21.3 → 0.21.5

package/dist/index.d.mts

@@ -689,6 +689,19 @@ type QueryLeaf = {
   propertyVariable: string;
   dataType: "date" | "dateTime";
   propertyValues?: never;
+  value: string;
+  from?: never;
+  to?: never;
+  matchMode: "includes" | "exact";
+  isCaseSensitive: boolean;
+  language: string;
+  isNegated?: boolean;
+} | {
+  target: "property";
+  propertyVariable: string;
+  dataType: "date" | "dateTime";
+  propertyValues?: never;
+  value?: never;
   from: string;
   to?: string;
   matchMode: "includes" | "exact";
@@ -700,6 +713,7 @@ type QueryLeaf = {
   propertyVariable: string;
   dataType: "date" | "dateTime";
   propertyValues?: never;
+  value?: never;
   from?: string;
   to: string;
   matchMode: "includes" | "exact";
@@ -793,9 +807,14 @@ type StylesheetItem = {
     mobile: Array<Style>;
   };
 };
-type WebsitePropertyQueryNode = Query extends infer QueryNode ? QueryNode extends {
+type WebsitePropertyQueryNode = {
   target: "property";
-} ? Omit<QueryNode, "propertyValues" | "from" | "to" | "isNegated"> : never : never;
+  propertyVariable: string;
+  dataType: Exclude<PropertyValueContentType, "coordinate">;
+  matchMode: "includes" | "exact";
+  isCaseSensitive: boolean;
+  language: string;
+};
 type WebsitePropertyQuery = WebsitePropertyQueryNode | {
   and: Array<WebsitePropertyQuery>;
 } | {

package/dist/index.mjs

@@ -783,6 +783,19 @@ const setQueryLeafSchema = z.union([
 		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,
+		dataType: z.enum(["date", "dateTime"]),
+		value: z.never().optional(),
 		from: z.string(),
 		to: z.string().optional(),
 		matchMode: z.enum(["includes", "exact"]),
@@ -794,6 +807,7 @@ const setQueryLeafSchema = z.union([
 		target: z.literal("property"),
 		propertyVariable: uuidSchema,
 		dataType: z.enum(["date", "dateTime"]),
+		value: z.never().optional(),
 		from: z.string().optional(),
 		to: z.string(),
 		matchMode: z.enum(["includes", "exact"]),
@@ -2158,6 +2172,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 (
@@ -2172,6 +2190,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.
 */
@@ -2274,15 +2304,11 @@ 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",
+		predicate: buildTokenizedSearchPredicate({
+			searchableNodesExpression,
+			termsExpression: tokenizedSearchDeclarations.termsVar,
 			isCaseSensitive
-		})}
-    ))`,
+		}),
 		candidateQueryVar
 	};
 }
@@ -2442,6 +2468,75 @@ function buildPropertyStringCandidateBranch(params) {
         )
       )`;
 }
+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 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 getGroupableIncludesValue(query) {
 	switch (query.target) {
 		case "string":
@@ -2451,7 +2546,13 @@ function getGroupableIncludesValue(query) {
 		case "periods":
 		case "bibliography": return query.value;
 		case "property":
-			if (query.dataType !== "string" || query.propertyValues?.length !== 1) return null;
+			if (query.dataType === "string") {
+				if (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;
+			if (query.propertyValues?.length !== 1) return null;
 			return query.propertyValues[0] ?? null;
 	}
 }
@@ -2470,6 +2571,11 @@ function buildContentTargetIncludesGroupMember(params) {
 			matchMode: "includes",
 			isCaseSensitive
 		}),
+		buildTokenPredicate: (termsExpression) => buildTokenizedSearchPredicate({
+			searchableNodesExpression: buildSearchableContentNodesExpression(contentNodesExpression),
+			termsExpression,
+			isCaseSensitive
+		}),
 		buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
 			containerElementName,
 			termExpression,
@@ -2486,6 +2592,11 @@ function buildItemStringIncludesGroupMember(query) {
 			matchMode: "includes",
 			isCaseSensitive: query.isCaseSensitive
 		}),
+		buildTokenPredicate: (termsExpression) => buildTokenizedSearchPredicate({
+			searchableNodesExpression: buildItemStringSearchableNodesExpression(query.language),
+			termsExpression,
+			isCaseSensitive: query.isCaseSensitive
+		}),
 		buildCandidateTermQuery: (termExpression) => `cts:or-query((
         ${buildItemStringIdentificationBranch({
 			termExpression,
@@ -2503,7 +2614,8 @@ function buildItemStringIncludesGroupMember(query) {
 function buildPropertyStringIncludesGroupMember(query) {
 	const propertyVariable = query.propertyVariable;
 	const predicateParts = [];
-	const valueExpression = buildFlattenedContentValuesExpression(`value[not(@inherited="true")]/content[@xml:lang="${query.language}"]`);
+	const propertyContentNodesExpression = `value[not(@inherited="true")]/content[@xml:lang="${query.language}"]`;
+	const valueExpression = buildFlattenedContentValuesExpression(propertyContentNodesExpression);
 	const propertyValue = query.propertyValues[0] ?? "";
 	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
 	return {
@@ -2513,6 +2625,11 @@ function buildPropertyStringIncludesGroupMember(query) {
 			matchMode: "includes",
 			isCaseSensitive: query.isCaseSensitive
 		})]),
+		buildTokenPredicate: (termsExpression) => buildPropertyPredicateExpression([...predicateParts, buildTokenizedSearchPredicate({
+			searchableNodesExpression: buildSearchableContentNodesExpression(propertyContentNodesExpression),
+			termsExpression,
+			isCaseSensitive: query.isCaseSensitive
+		})]),
 		buildCandidateTermQuery: (termExpression) => buildPropertyStringCandidateBranch({
 			termExpression,
 			isCaseSensitive: query.isCaseSensitive,
@@ -2520,6 +2637,31 @@ function buildPropertyStringIncludesGroupMember(query) {
 		})
 	};
 }
+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);
@@ -2558,7 +2700,9 @@ function buildIncludesGroupMember(query) {
 			language: query.language,
 			containerElementName: "image"
 		});
-		case "property": return buildPropertyStringIncludesGroupMember(query);
+		case "property":
+			if (query.dataType === "string") return buildPropertyStringIncludesGroupMember(query);
+			return buildPropertyRawValueOrTextIncludesGroupMember(query);
 	}
 }
 function getCompatibleIncludesGroupLeaves(params) {
@@ -2624,7 +2768,7 @@ function buildIncludesGroupClause(params) {
   then cts:and-query(${termQueriesVar})
   else ()`
 		],
-		predicate: `cts:contains(., ${candidateQueryVar})`,
+		predicate: buildOrPredicate(members.map((member) => member.buildTokenPredicate(tokenizedSearchDeclarations.termsVar))),
 		candidateQueryVar
 	};
 }
@@ -2659,6 +2803,94 @@ function buildPropertyValueAttributePredicate(params) {
 	for (const propertyValue of propertyValues) valuePredicates.push(`value[@${attributeName}=${stringLiteral(propertyValue)}]`);
 	return buildOrPredicate(valuePredicates);
 }
+function buildPropertyRawValueOrTextMatchClause(params) {
+	const { value, matchMode, isCaseSensitive, version, queryKey } = params;
+	const fallbackPredicate = buildPropertyRawValueOrTextRawPredicate({
+		value,
+		matchMode,
+		isCaseSensitive
+	});
+	if (matchMode !== "includes" || version !== 2) return {
+		declarations: [],
+		predicate: fallbackPredicate,
+		candidateQueryVar: null
+	};
+	const tokenizedSearchDeclarations = buildTokenizedSearchDeclarations({
+		value,
+		isCaseSensitive,
+		queryKey
+	});
+	const tokenizedTerms = tokenizeIncludesSearchValue({
+		value,
+		isCaseSensitive
+	});
+	const termQueriesVar = `$query${queryKey}TermQueries`;
+	const candidateQueryVar = `$query${queryKey}CandidateQuery`;
+	if (tokenizedTerms.length === 0) return {
+		declarations: [],
+		predicate: fallbackPredicate,
+		candidateQueryVar: null
+	};
+	return {
+		declarations: [
+			...tokenizedSearchDeclarations.declarations,
+			`let ${termQueriesVar} :=
+  for $term in ${tokenizedSearchDeclarations.termsVar}
+    return ${buildOrCtsQueryExpression([buildPropertyRawValueCandidateBranch({
+				termExpression: "$term",
+				isCaseSensitive
+			}), buildPropertySimpleValueTextCandidateBranch({
+				termExpression: "$term",
+				isCaseSensitive
+			})])}`,
+			`let ${candidateQueryVar} :=
+  if (count(${tokenizedSearchDeclarations.termsVar}) = 1)
+  then ${termQueriesVar}[1]
+  else if (count(${tokenizedSearchDeclarations.termsVar}) gt 1)
+  then cts:and-query(${termQueriesVar})
+  else ()`
+		],
+		predicate: buildPropertyRawValueOrTextTokenPredicate({
+			termsExpression: tokenizedSearchDeclarations.termsVar,
+			isCaseSensitive
+		}),
+		candidateQueryVar
+	};
+}
+function buildPropertyRawValueOrTextClause(params) {
+	const { values, matchMode, isCaseSensitive, version, queryKey } = params;
+	const declarations = [];
+	const valuePredicates = [];
+	const candidateQueryVars = [];
+	for (const [valueIndex, value] of values.entries()) {
+		const compiledClause = buildPropertyRawValueOrTextMatchClause({
+			value,
+			matchMode,
+			isCaseSensitive,
+			version,
+			queryKey: `${queryKey}_${valueIndex + 1}`
+		});
+		declarations.push(...compiledClause.declarations);
+		valuePredicates.push(compiledClause.predicate);
+		if (compiledClause.candidateQueryVar != null) candidateQueryVars.push(compiledClause.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
+	};
+}
 function buildPropertyPredicateExpression(propertyPredicates) {
 	let propertyExpression = ".//properties//property";
 	for (const propertyPredicate of propertyPredicates) propertyExpression += `[${propertyPredicate}]`;
@@ -2715,7 +2947,18 @@ function buildPropertyClause(params) {
 	const propertyVariable = query.propertyVariable;
 	let candidateQueryVar = null;
 	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
-	if (query.dataType === "date" || query.dataType === "dateTime") predicateParts.push(buildDateRangePredicate({
+	if (query.dataType === "date" || query.dataType === "dateTime") if ("value" in query && query.value != null) {
+		const compiledScalarClause = buildPropertyRawValueOrTextClause({
+			values: [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
 	}));
@@ -2729,12 +2972,19 @@ function buildPropertyClause(params) {
 		case "integer":
 		case "decimal":
 		case "time":
-		case "boolean":
-			predicateParts.push(buildPropertyValueAttributePredicate({
-				propertyValues: query.propertyValues,
-				attributeName: "rawValue"
-			}));
+		case "boolean": {
+			const compiledScalarClause = buildPropertyRawValueOrTextClause({
+				values: query.propertyValues,
+				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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ochre-sdk",
-  "version": "0.21.3",
+  "version": "0.21.5",
   "type": "module",
   "license": "MIT",
   "description": "Node.js library for working with OCHRE (Online Cultural and Historical Research Environment) data",
@@ -51,7 +51,7 @@
     "bumpp": "^11.0.1",
     "eslint": "^10.1.0",
     "prettier": "^3.8.1",
-    "tsdown": "^0.21.6",
+    "tsdown": "^0.21.7",
     "typescript": "^6.0.2"
   },
   "scripts": {