ochre-sdk 0.22.4 → 0.22.6

package/dist/index.d.mts

@@ -776,7 +776,11 @@ type LevelContext = {
 type PropertyContexts = {
   flatten: Array<LevelContext>;
   suppress: Array<LevelContext>;
-  filter: Array<LevelContext>;
+  filter: Array<LevelContext & {
+    isInlineDisplayed: boolean;
+    isSidebarDisplayed: boolean;
+    isSidebarOpen: boolean;
+  }>;
   sort: Array<LevelContext>;
   detail: Array<LevelContext>;
   download: Array<LevelContext>;

package/dist/index.mjs

@@ -1018,7 +1018,7 @@ function parseMetadata(metadata) {
 * @param contextItem - Raw context item data from OCHRE format
 * @returns Parsed ContextItem object
 */
-function parseContextItem(contextItem) {
+function parseContextItem$1(contextItem) {
 	return {
 		uuid: contextItem.uuid,
 		publicationDateTime: parseOptionalDate(contextItem.publicationDateTime),
@@ -1035,9 +1035,9 @@ function parseContextItem(contextItem) {
 function parseContext(context) {
 	return {
 		nodes: ensureArray(context.context).map((ctx) => ({
-			tree: parseContextItem(ctx.tree),
-			project: parseContextItem(ctx.project),
-			spatialUnit: "spatialUnit" in ctx && ctx.spatialUnit ? ensureArray(ctx.spatialUnit).map((element) => parseContextItem(element)) : []
+			tree: parseContextItem$1(ctx.tree),
+			project: parseContextItem$1(ctx.project),
+			spatialUnit: "spatialUnit" in ctx && ctx.spatialUnit ? ensureArray(ctx.spatialUnit).map((element) => parseContextItem$1(element)) : []
 		})),
 		displayPath: context.displayPath
 	};
@@ -2167,54 +2167,121 @@ const CTS_INCLUDES_STOP_WORDS = new Set([
 	"the",
 	"to"
 ]);
+const CTS_INCLUDES_TOKEN_WORD_REGEX = /^\p{L}+$/u;
+const CTS_INCLUDES_TOKEN_REGEX = /[\p{L}\p{N}*?]+/gu;
 const CTS_INCLUDES_TOKEN_SPLIT_REGEX = /\W+/u;
-const CONTENT_TARGET_CONTAINER_ELEMENTS = {
-	title: "identification",
-	description: "description",
-	image: "image",
-	periods: "period",
-	bibliography: "bibliography"
+const CONTENT_TARGET_CONTENT_ELEMENT_PATHS = {
+	title: [
+		"identification",
+		"label",
+		"content"
+	],
+	description: ["description", "content"],
+	image: [
+		"image",
+		"identification",
+		"label",
+		"content"
+	],
+	periods: [
+		"periods",
+		"period",
+		"identification",
+		"label",
+		"content"
+	],
+	bibliography: [
+		"bibliographies",
+		"bibliography",
+		"identification",
+		"label",
+		"content"
+	]
 };
 function tokenizeIncludesSearchValue(params) {
 	const { value, isCaseSensitive } = params;
-	const rawTerms = (isCaseSensitive ? value : value.toLowerCase()).split(CTS_INCLUDES_TOKEN_SPLIT_REGEX);
+	const rawTerms = (isCaseSensitive ? value : value.toLowerCase()).match(CTS_INCLUDES_TOKEN_REGEX) ?? [];
 	const terms = [];
 	for (const term of rawTerms) {
+		if (term.includes("*") || term.includes("?")) {
+			if (term.replaceAll("*", "").replaceAll("?", "") !== "") terms.push(term);
+			continue;
+		}
 		const normalizedTerm = term.toLowerCase();
 		if (normalizedTerm !== "" && !CTS_INCLUDES_STOP_WORDS.has(normalizedTerm)) terms.push(term);
 	}
 	return terms;
 }
+function tokenizeExactPhraseSearchValue(params) {
+	const { value, isCaseSensitive } = params;
+	const rawTerms = (isCaseSensitive ? value : value.toLowerCase()).split(CTS_INCLUDES_TOKEN_SPLIT_REGEX);
+	const terms = [];
+	for (const term of rawTerms) if (term !== "") terms.push(term);
+	return terms;
+}
+function hasWildcardCharacters(value) {
+	return value.includes("*") || value.includes("?");
+}
+function getWildcardStrippedValue(value) {
+	return value.replaceAll("*", "").replaceAll("?", "");
+}
+function shouldUseStemmedTextSearch(value) {
+	const wildcardStrippedValue = getWildcardStrippedValue(value);
+	return wildcardStrippedValue.length >= 3 && CTS_INCLUDES_TOKEN_WORD_REGEX.test(wildcardStrippedValue);
+}
 function buildCtsMatchOptionsExpression(params) {
-	const { isCaseSensitive } = params;
-	return `(${[
+	const { matchMode, isCaseSensitive, queryFamily, language, isWildcarded } = params;
+	const { isStemmed } = params;
+	const options = [
 		isCaseSensitive ? "case-sensitive" : "case-insensitive",
-		"diacritic-insensitive",
-		"punctuation-insensitive",
-		"whitespace-insensitive",
-		"unstemmed",
-		"unwildcarded"
-	].map((option) => stringLiteral(option)).join(", ")})`;
+		matchMode === "exact" ? "diacritic-sensitive" : "diacritic-insensitive",
+		matchMode === "exact" ? "punctuation-sensitive" : "punctuation-insensitive",
+		matchMode === "exact" ? "whitespace-sensitive" : "whitespace-insensitive"
+	];
+	if (matchMode === "exact") options.push("unstemmed", "unwildcarded");
+	else if (queryFamily === "text") {
+		options.push(isStemmed ? "stemmed" : "unstemmed", isWildcarded ? "wildcarded" : "unwildcarded");
+		if (isStemmed && language != null && language !== "") options.push(`lang=${language}`);
+	} else options.push("unstemmed", isWildcarded ? "wildcarded" : "unwildcarded");
+	return `(${options.map((option) => stringLiteral(option)).join(", ")})`;
 }
 function buildCtsWordQueryExpression(params) {
-	const { value, matchMode, isCaseSensitive } = params;
+	const { value, matchMode, isCaseSensitive, queryFamily, language } = params;
+	const isWildcarded = matchMode === "includes" && hasWildcardCharacters(value);
+	const isStemmed = matchMode === "includes" && queryFamily === "text" && !isWildcarded && shouldUseStemmedTextSearch(value);
 	return `cts:word-query(${stringLiteral(value)}, ${buildCtsMatchOptionsExpression({
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		queryFamily,
+		language,
+		isWildcarded,
+		isStemmed
 	})})`;
 }
 function buildCtsElementWordQueryExpression(params) {
-	const { elementName, value, matchMode, isCaseSensitive } = params;
+	const { elementName, value, matchMode, isCaseSensitive, queryFamily, language } = params;
+	const isWildcarded = matchMode === "includes" && hasWildcardCharacters(value);
+	const isStemmed = matchMode === "includes" && queryFamily === "text" && !isWildcarded && shouldUseStemmedTextSearch(value);
 	return `cts:element-word-query(xs:QName("${elementName}"), ${stringLiteral(value)}, ${buildCtsMatchOptionsExpression({
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		queryFamily,
+		language,
+		isWildcarded,
+		isStemmed
 	})})`;
 }
 function buildCtsElementAttributeWordQueryExpression(params) {
-	const { elementName, attributeName, value, matchMode, isCaseSensitive } = params;
+	const { elementName, attributeName, value, matchMode, isCaseSensitive, queryFamily, language } = params;
+	const isWildcarded = matchMode === "includes" && hasWildcardCharacters(value);
+	const isStemmed = matchMode === "includes" && queryFamily === "text" && !isWildcarded && shouldUseStemmedTextSearch(value);
 	return `cts:element-attribute-word-query(xs:QName("${elementName}"), xs:QName("${attributeName}"), ${stringLiteral(value)}, ${buildCtsMatchOptionsExpression({
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		queryFamily,
+		language,
+		isWildcarded,
+		isStemmed
 	})})`;
 }
 function buildCtsElementValueQueryExpression(params) {
@@ -2236,21 +2303,36 @@ function buildPlainElementAttributeValueQueryExpression(params) {
 	return `cts:element-attribute-value-query(xs:QName("${elementName}"), xs:QName("${attributeName}"), ${stringLiteral(value)})`;
 }
 function buildSearchableContentTextQueryExpression(params) {
-	const { value, matchMode, isCaseSensitive } = params;
-	if (matchMode === "exact") return buildCtsWordQueryExpression({
-		value,
-		matchMode,
-		isCaseSensitive
-	});
+	const { value, matchMode, isCaseSensitive, language } = params;
+	if (matchMode === "exact") {
+		const phraseTerms = tokenizeExactPhraseSearchValue({
+			value,
+			isCaseSensitive
+		});
+		if (phraseTerms.length > 1) return buildAndCtsQueryExpressionInternal(phraseTerms.map((term) => buildCtsWordQueryExpression({
+			value: term,
+			matchMode,
+			isCaseSensitive
+		})));
+		return buildCtsWordQueryExpression({
+			value,
+			matchMode,
+			isCaseSensitive
+		});
+	}
 	return buildOrCtsQueryExpressionInternal([buildCtsElementWordQueryExpression({
 		elementName: "string",
 		value,
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		queryFamily: "text",
+		language
 	}), buildCtsWordQueryExpression({
 		value,
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		queryFamily: "text",
+		language
 	})]);
 }
 function buildNestedElementQuery(elementNames, queryExpression) {
@@ -2308,7 +2390,8 @@ function buildValueContentInnerQuery(params) {
 	return buildNestedElementQuery(["content"], buildAndCtsQueryExpressionInternal([buildContentLanguageQuery(language), buildSearchableContentTextQueryExpression({
 		value,
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		language
 	})]));
 }
 function buildValueDirectTextInnerQuery(params) {
@@ -2321,7 +2404,8 @@ function buildValueDirectTextInnerQuery(params) {
 		elementName: "value",
 		value,
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		queryFamily: "raw"
 	});
 	return buildAndCtsQueryExpressionInternal([buildNotCtsQueryExpression(buildNestedElementQuery(["content"], "cts:true-query()")), directTextQuery]);
 }
@@ -2338,7 +2422,8 @@ function buildValueRawValueInnerQuery(params) {
 		attributeName: "rawValue",
 		value,
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		queryFamily: "raw"
 	});
 }
 function buildNotesQueryExpression(params) {
@@ -2357,20 +2442,24 @@ function buildNotesQueryExpression(params) {
 		attributeName: "title",
 		value,
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		queryFamily: "text",
+		language
 	}), buildSearchableContentTextQueryExpression({
 		value,
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		language
 	})])]));
 }
 function buildContentTargetQueryExpression(params) {
 	const { target, value, matchMode, isCaseSensitive, language } = params;
-	const containerElement = CONTENT_TARGET_CONTAINER_ELEMENTS[target];
-	return buildNestedElementQuery([containerElement], buildAndCtsQueryExpressionInternal([buildContentLanguageQuery(language), buildSearchableContentTextQueryExpression({
+	const contentElementPath = CONTENT_TARGET_CONTENT_ELEMENT_PATHS[target];
+	return buildNestedElementQuery(contentElementPath, buildAndCtsQueryExpressionInternal([buildContentLanguageQuery(language), buildSearchableContentTextQueryExpression({
 		value,
 		matchMode,
-		isCaseSensitive
+		isCaseSensitive,
+		language
 	})]));
 }
 function buildPropertyQueryExpression(params) {
@@ -2414,6 +2503,27 @@ function buildPropertyScalarQueryExpression(params) {
 }
 function buildPropertyAllQueryExpression(params) {
 	const { query, value, matchMode } = params;
+	if (matchMode === "includes") return buildPropertyQueryExpression({
+		propertyVariable: query.propertyVariable,
+		queryExpression: buildNestedElementQuery(["value"], buildAndCtsQueryExpressionInternal([buildValueNotIdRefQuery(), buildOrCtsQueryExpressionInternal([
+			buildValueContentInnerQuery({
+				language: query.language,
+				value,
+				matchMode,
+				isCaseSensitive: query.isCaseSensitive
+			}),
+			buildValueRawValueInnerQuery({
+				value,
+				matchMode,
+				isCaseSensitive: query.isCaseSensitive
+			}),
+			buildValueDirectTextInnerQuery({
+				value,
+				matchMode,
+				isCaseSensitive: query.isCaseSensitive
+			})
+		])]))
+	});
 	return buildPropertyQueryExpression({
 		propertyVariable: query.propertyVariable,
 		queryExpression: buildNestedElementQuery(["value"], buildAndCtsQueryExpressionInternal([buildValueNotIdRefQuery(), buildCtsWordQueryExpression({
@@ -2541,6 +2651,11 @@ function buildLeafQueryExpression(query) {
 		value: searchValue,
 		isCaseSensitive: query.isCaseSensitive
 	});
+	const fullValueQueryExpression = buildLeafValueQueryExpression({
+		query,
+		value: searchValue,
+		matchMode: "exact"
+	});
 	if (terms.length === 0) return "cts:false-query()";
 	const termQueryExpressions = [];
 	for (const term of terms) termQueryExpressions.push(buildLeafValueQueryExpression({
@@ -2548,7 +2663,9 @@ function buildLeafQueryExpression(query) {
 		value: term,
 		matchMode: "includes"
 	}));
-	return buildAndCtsQueryExpressionInternal(termQueryExpressions);
+	const tokenizedQueryExpression = buildAndCtsQueryExpressionInternal(termQueryExpressions);
+	if (terms.length === 1) return tokenizedQueryExpression;
+	return buildOrCtsQueryExpressionInternal([fullValueQueryExpression, tokenizedQueryExpression]);
 }
 function getGroupableIncludesValue(query) {
 	if (query.matchMode !== "includes" || query.isNegated === true) return null;
@@ -2589,11 +2706,18 @@ function getCompatibleIncludesGroupLeaves(query) {
 	return leafQueries;
 }
 function buildIncludesGroupMember(query) {
-	return { buildTermQuery: (term) => buildLeafValueQueryExpression({
-		query,
-		value: term,
-		matchMode: "includes"
-	}) };
+	return {
+		buildTermQuery: (term) => buildLeafValueQueryExpression({
+			query,
+			value: term,
+			matchMode: "includes"
+		}),
+		buildFullValueQuery: (value) => buildLeafValueQueryExpression({
+			query,
+			value,
+			matchMode: "exact"
+		})
+	};
 }
 function buildIncludesGroupQueryExpression(queries) {
 	const firstQuery = queries[0];
@@ -2607,12 +2731,16 @@ function buildIncludesGroupQueryExpression(queries) {
 	if (terms.length === 0) return "cts:false-query()";
 	const members = queries.map((query) => buildIncludesGroupMember(query));
 	const perTermQueryExpressions = [];
+	const fullValueFieldQueryExpressions = [];
+	for (const member of members) fullValueFieldQueryExpressions.push(member.buildFullValueQuery(groupValue));
 	for (const term of terms) {
 		const fieldQueryExpressions = [];
 		for (const member of members) fieldQueryExpressions.push(member.buildTermQuery(term));
 		perTermQueryExpressions.push(buildOrCtsQueryExpressionInternal(fieldQueryExpressions));
 	}
-	return buildAndCtsQueryExpressionInternal(perTermQueryExpressions);
+	const tokenizedGroupQueryExpression = buildAndCtsQueryExpressionInternal(perTermQueryExpressions);
+	if (terms.length === 1) return tokenizedGroupQueryExpression;
+	return buildOrCtsQueryExpressionInternal([buildOrCtsQueryExpressionInternal(fullValueFieldQueryExpressions), tokenizedGroupQueryExpression]);
 }
 function buildQueryNode(query) {
 	if (isQueryLeaf(query)) {
@@ -3585,10 +3713,13 @@ function parseAllOptionContexts(options) {
 	function handleContexts(v) {
 		return parseContexts(v != null ? ensureArray(v) : []);
 	}
+	function handleFilterContexts(v) {
+		return parseFilterContexts(v != null ? ensureArray(v) : []);
+	}
 	return {
 		flatten: handleContexts(options.flattenContexts),
 		suppress: handleContexts(options.suppressContexts),
-		filter: handleContexts(options.filterContexts),
+		filter: handleFilterContexts(options.filterContexts),
 		sort: handleContexts(options.sortContexts),
 		detail: handleContexts(options.detailContexts),
 		download: handleContexts(options.downloadContexts),
@@ -4791,12 +4922,11 @@ function parseWebsiteProperties(properties, websiteTree, sidebar) {
 	if ("styleOptions" in websiteTree && websiteTree.styleOptions != null) returnProperties.options.stylesheets.properties = parseStylesheets(ensureArray(websiteTree.styleOptions.style));
 	return returnProperties;
 }
-function parseContexts(contexts) {
-	const contextsParsed = [];
-	for (const mainContext of contexts) for (const contextItemToParse of ensureArray(mainContext.context)) {
-		const levelsToParse = ensureArray(contextItemToParse.levels.level);
-		let type = "";
-		const levels = levelsToParse.map((level) => {
+function parseContextItem(contextItemToParse) {
+	const levelsToParse = ensureArray(contextItemToParse.levels.level);
+	let type = "";
+	return {
+		context: levelsToParse.map((level) => {
 			let variableUuid = "";
 			let valueUuid = null;
 			if (typeof level === "string") {
@@ -4813,13 +4943,56 @@ function parseContexts(contexts) {
 				variableUuid,
 				valueUuid
 			};
-		});
-		contextsParsed.push({
-			context: levels,
-			type,
-			identification: parseIdentification(contextItemToParse.identification)
-		});
+		}),
+		type,
+		identification: parseIdentification(contextItemToParse.identification)
+	};
+}
+function parseFilterContextDisplay(filterOption) {
+	switch (filterOption) {
+		case "inline-displayed": return {
+			isInlineDisplayed: true,
+			isSidebarDisplayed: false,
+			isSidebarOpen: false
+		};
+		case "inline-sidebar-displayed-closed": return {
+			isInlineDisplayed: true,
+			isSidebarDisplayed: true,
+			isSidebarOpen: false
+		};
+		case "inline-sidebar-displayed-open": return {
+			isInlineDisplayed: true,
+			isSidebarDisplayed: true,
+			isSidebarOpen: true
+		};
+		case "sidebar-displayed-closed": return {
+			isInlineDisplayed: false,
+			isSidebarDisplayed: true,
+			isSidebarOpen: false
+		};
+		case "sidebar-displayed-open": return {
+			isInlineDisplayed: false,
+			isSidebarDisplayed: true,
+			isSidebarOpen: true
+		};
+		default: return {
+			isInlineDisplayed: false,
+			isSidebarDisplayed: false,
+			isSidebarOpen: false
+		};
 	}
+}
+function parseContexts(contexts) {
+	const contextsParsed = [];
+	for (const mainContext of contexts) for (const contextItemToParse of ensureArray(mainContext.context)) contextsParsed.push(parseContextItem(contextItemToParse));
+	return contextsParsed;
+}
+function parseFilterContexts(contexts) {
+	const contextsParsed = [];
+	for (const mainContext of contexts) for (const contextItemToParse of ensureArray(mainContext.context)) contextsParsed.push({
+		...parseContextItem(contextItemToParse),
+		...parseFilterContextDisplay(contextItemToParse.filterOption)
+	});
 	return contextsParsed;
 }
 function parseWebsite(websiteTree, metadata, belongsTo, { version = 2 } = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ochre-sdk",
-  "version": "0.22.4",
+  "version": "0.22.6",
   "type": "module",
   "license": "MIT",
   "description": "Node.js library for working with OCHRE (Online Cultural and Historical Research Environment) data",
@@ -49,11 +49,11 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^8.1.0",
+    "@antfu/eslint-config": "^8.1.1",
     "@types/node": "^24.12.2",
     "bumpp": "^11.0.1",
     "eslint": "^10.2.0",
-    "prettier": "^3.8.1",
+    "prettier": "^3.8.2",
     "tsdown": "^0.21.7",
     "typescript": "^6.0.2",
     "vitest": "^4.1.4"