@octane-xplat/ui 0.7.3 → 0.10.0

package/dist/web/power-search-config.js

@@ -0,0 +1,566 @@
+import { powerSearchTranslate } from "./power-search-strings.js";
+import { hookSlots, useMemo } from "octane";
+//#region src/power-search-config.ts
+/** Shared, platform-neutral PowerSearch logic — config builders, internal
+*  lookup maps, the field typeahead source, value formatting, operator label
+*  resolution, and client-side `applyFilters` matching. Ports
+*  `usePowerSearchConfig`/`useInternalConfig`/`usePowerSearchSource`/
+*  `formatFilterValue`/`resolveOperatorLabel`/`resolveDateTimeRangePart` from
+*  upstream `packages/core/src/PowerSearch/`. */
+/** Display string for an operator: `label` verbatim, `i18nKey` through the
+*  catalog (`powerSearchTranslate` by default — pass an app translator to
+*  localize). */
+function resolveOperatorLabel(operator, t = powerSearchTranslate) {
+	if ("label" in operator && operator.label !== void 0) return operator.label;
+	return t(operator.i18nKey);
+}
+var SECONDS_BY_UNIT = {
+	second: 1,
+	minute: 60,
+	hour: 3600,
+	day: 86400,
+	week: 604800,
+	month: 2592e3,
+	year: 31536e3
+};
+/** Resolves a range part against one caller-supplied instant. */
+function resolveDateTimeRangePart(part, nowSeconds = Date.now() / 1e3) {
+	switch (part.type) {
+		case "NOW": return Math.floor(nowSeconds);
+		case "ABSOLUTE": return part.unixSeconds;
+		case "RELATIVE": return Math.floor(nowSeconds - part.backValue * SECONDS_BY_UNIT[part.unit]);
+	}
+}
+/** Pure factory — components wrap it in `useMemo` when they want stability. */
+function createInternalConfig(config) {
+	const fieldMap = /* @__PURE__ */ new Map();
+	const operatorMap = /* @__PURE__ */ new Map();
+	for (const field of config.fields) {
+		fieldMap.set(field.key, field);
+		const opMap = /* @__PURE__ */ new Map();
+		for (const op of field.operators) opMap.set(op.key, op);
+		operatorMap.set(field.key, opMap);
+	}
+	return {
+		config,
+		getField: (key) => fieldMap.get(key),
+		getOperator: (fieldKey, operatorKey) => operatorMap.get(fieldKey)?.get(operatorKey),
+		getDefaultOperator: (fieldKey) => {
+			const field = fieldMap.get(fieldKey);
+			if (!field) return;
+			if (field.defaultOperator) return operatorMap.get(fieldKey)?.get(field.defaultOperator);
+			return field.operators[0];
+		},
+		getVisibleFields: () => config.fields,
+		getVisibleOperators: (fieldKey) => fieldMap.get(fieldKey)?.operators ?? []
+	};
+}
+function truncate(str, maxLength) {
+	const chars = [...str];
+	if (chars.length <= maxLength) return str;
+	const keep = Math.max(maxLength - 1, 0);
+	return chars.slice(0, keep).join("") + "…";
+}
+function formatEnumLabel(value, enumValues) {
+	return enumValues.find((v) => v.value === value)?.label ?? value;
+}
+function formatNumber(value, locale, units) {
+	const formatted = new Intl.NumberFormat(locale).format(value);
+	return units ? `${formatted} ${units}` : formatted;
+}
+function formatDateAbsolute(unixSeconds, locale, timezoneID) {
+	const options = {
+		year: "numeric",
+		month: "short",
+		day: "numeric",
+		hour: "numeric",
+		minute: "2-digit",
+		...timezoneID ? { timeZone: timezoneID } : {},
+		calendar: "gregory"
+	};
+	return new Intl.DateTimeFormat(locale, options).format(unixSeconds * 1e3);
+}
+/** String form of a filter value for token pills and summaries. */
+function formatFilterValue(_config, operatorValue, filterValue, maxLength, t = powerSearchTranslate, locale, timezoneID) {
+	switch (filterValue.type) {
+		case "empty": return "";
+		case "string": return truncate(filterValue.value, maxLength);
+		case "integer": return formatNumber(filterValue.value, locale, operatorValue.type === "integer" ? operatorValue.units : void 0);
+		case "float": return formatNumber(filterValue.value, locale, operatorValue.type === "float" ? operatorValue.units : void 0);
+		case "enum":
+			if (operatorValue.type === "enum") return truncate(formatEnumLabel(filterValue.value, operatorValue.values), maxLength);
+			return truncate(filterValue.value, maxLength);
+		case "string_list": {
+			const items = filterValue.value;
+			if (items.length === 0) return "";
+			if (items.length === 1) return truncate(items[0], maxLength);
+			const joined = items.join(", ");
+			if (joined.length <= maxLength) return joined;
+			return t("@astryx.powersearch.valueEditor.itemsCount", { count: items.length });
+		}
+		case "enum_list": {
+			const items = filterValue.value;
+			if (items.length === 0) return "";
+			if (operatorValue.type === "enum_list") {
+				const labels = items.map((v) => formatEnumLabel(v, operatorValue.values));
+				if (labels.length === 1) return truncate(labels[0], maxLength);
+				const joined = labels.join(", ");
+				if (joined.length <= maxLength) return joined;
+				return t("@astryx.powersearch.valueEditor.itemsCount", { count: labels.length });
+			}
+			if (items.length === 1) return truncate(items[0], maxLength);
+			return t("@astryx.powersearch.valueEditor.itemsCount", { count: items.length });
+		}
+		case "entity_list": {
+			const entities = filterValue.value;
+			if (entities.length === 0) return "";
+			if (entities.length === 1) return truncate(entities[0].label, maxLength);
+			const joined = entities.map((e) => e.label).join(", ");
+			if (joined.length <= maxLength) return joined;
+			return t("@astryx.powersearch.valueEditor.entitiesCount", { count: entities.length });
+		}
+		case "time": return filterValue.value;
+		case "date_absolute": return truncate(formatDateAbsolute(filterValue.unixSeconds, locale, timezoneID), maxLength);
+		case "date_relative": return filterValue.value;
+		case "date_range": return t("@astryx.powersearch.valueEditor.dateRange");
+		case "custom":
+			if (operatorValue.type === "custom") return truncate(operatorValue.getString(filterValue.value), maxLength);
+			return filterValue.value;
+		case "nested": {
+			const count = filterValue.value.length;
+			return t("@astryx.powersearch.valueEditor.filtersCount", { count });
+		}
+		default: return "";
+	}
+}
+function resolveValueMatches(op, rawValue) {
+	const opType = op.value.type;
+	if (opType === "string") return [{
+		displayValue: rawValue,
+		filterValue: {
+			type: "string",
+			value: rawValue
+		},
+		quoted: true
+	}];
+	if (opType === "string_list") return [{
+		displayValue: rawValue,
+		filterValue: {
+			type: "string_list",
+			value: [rawValue]
+		},
+		quoted: true
+	}];
+	if (opType === "enum") {
+		const lower = rawValue.toLowerCase();
+		return op.value.values.filter((item) => item.label.toLowerCase().includes(lower)).map((item) => ({
+			displayValue: item.label,
+			filterValue: {
+				type: "enum",
+				value: item.value
+			},
+			quoted: false
+		}));
+	}
+	if (opType === "enum_list") {
+		const lower = rawValue.toLowerCase();
+		return op.value.values.filter((item) => item.label.toLowerCase().includes(lower)).map((item) => ({
+			displayValue: item.label,
+			filterValue: {
+				type: "enum_list",
+				value: [item.value]
+			},
+			quoted: false
+		}));
+	}
+	return [];
+}
+function buildFieldItems(config) {
+	const ungrouped = [];
+	const groups = /* @__PURE__ */ new Map();
+	for (const field of config.getVisibleFields()) {
+		const defaultOp = config.getDefaultOperator(field.key);
+		const item = {
+			id: field.key,
+			label: field.label,
+			auxiliaryData: {
+				fieldKey: field.key,
+				operatorKey: defaultOp?.key,
+				group: field.group
+			}
+		};
+		if (field.group != null) {
+			if (!groups.has(field.group)) groups.set(field.group, []);
+			groups.get(field.group).push(item);
+		} else ungrouped.push(item);
+	}
+	return [...ungrouped, ...[...groups.values()].flat()];
+}
+/** The field/operator/value suggestion source behind the main input —
+*  `search(query)` ranks field labels, field+operator combos, value matches,
+*  and the free-text content-search entry; `bootstrap()` lists every field. */
+function createPowerSearchSource(config, maxTypedResults, t = powerSearchTranslate) {
+	const allItems = buildFieldItems(config);
+	const opLabel = (op) => resolveOperatorLabel(op, t);
+	return {
+		search(query) {
+			const lower = query.toLowerCase().trim();
+			if (lower === "") return allItems;
+			const results = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const field of config.getVisibleFields()) {
+				if (field.typeaheadMinQueryLength != null && lower.length < field.typeaheadMinQueryLength) continue;
+				if (field.label.toLowerCase().includes(lower) || field.typeaheadAliases?.some((alias) => alias.toLowerCase().includes(lower))) {
+					const defaultOp = config.getDefaultOperator(field.key);
+					if (!seen.has(field.key)) {
+						seen.add(field.key);
+						results.push({
+							id: field.key,
+							label: field.label,
+							auxiliaryData: {
+								fieldKey: field.key,
+								operatorKey: defaultOp?.key
+							}
+						});
+					}
+				}
+				for (const op of field.operators) if (`${field.label} ${opLabel(op)}`.toLowerCase().includes(lower)) {
+					const id = `${field.key}:${op.key}`;
+					if (!seen.has(id)) {
+						seen.add(id);
+						results.push({
+							id,
+							label: `${field.label} ${opLabel(op)}`,
+							auxiliaryData: {
+								fieldKey: field.key,
+								operatorKey: op.key
+							}
+						});
+					}
+				}
+			}
+			for (const field of config.getVisibleFields()) {
+				if (field.isValueMatchAllowed === false) continue;
+				const fieldLabel = field.label.toLowerCase();
+				let hasExactOperatorMatch = false;
+				for (const op of field.operators) {
+					const prefix = `${fieldLabel} ${opLabel(op).toLowerCase()} `;
+					if (lower.startsWith(prefix) && lower.length > prefix.length) {
+						const matches = resolveValueMatches(op, query.slice(prefix.length));
+						if (matches.length > 0) hasExactOperatorMatch = true;
+						for (const match of matches) {
+							const id = `${field.key}:${op.key}:value:${match.displayValue}`;
+							if (!seen.has(id)) {
+								seen.add(id);
+								results.push({
+									id,
+									label: `${field.label} ${opLabel(op)} ${match.quoted ? `"${match.displayValue}"` : match.displayValue}`,
+									auxiliaryData: {
+										fieldKey: field.key,
+										operatorKey: op.key,
+										filterValue: match.filterValue
+									}
+								});
+							}
+						}
+					}
+				}
+				const fieldPrefix = `${fieldLabel} `;
+				if (!hasExactOperatorMatch && lower.startsWith(fieldPrefix) && lower.length > fieldPrefix.length) {
+					const remainder = lower.slice(fieldPrefix.length);
+					if (!field.operators.some((op) => opLabel(op).toLowerCase().startsWith(remainder))) {
+						const rawValue = query.slice(fieldPrefix.length);
+						for (const op of field.operators) for (const match of resolveValueMatches(op, rawValue)) {
+							const id = `${field.key}:${op.key}:value:${match.displayValue}`;
+							if (!seen.has(id)) {
+								seen.add(id);
+								results.push({
+									id,
+									label: `${field.label} ${opLabel(op)} ${match.quoted ? `"${match.displayValue}"` : match.displayValue}`,
+									auxiliaryData: {
+										fieldKey: field.key,
+										operatorKey: op.key,
+										filterValue: match.filterValue
+									}
+								});
+							}
+						}
+					}
+				}
+			}
+			const contentFieldKey = config.config.contentSearchFieldKey;
+			const hasExactMatch = config.getVisibleFields().some((f) => f.label.toLowerCase() === lower || f.operators.some((op) => `${f.label} ${opLabel(op)}`.toLowerCase() === lower));
+			if (contentFieldKey && !hasExactMatch) {
+				const contentField = config.getField(contentFieldKey);
+				const contentOp = config.getDefaultOperator(contentFieldKey);
+				if (contentField && contentOp) results.unshift({
+					id: `__content_search__:${query}`,
+					label: `"${query}"`,
+					auxiliaryData: {
+						fieldKey: contentFieldKey,
+						operatorKey: contentOp.key,
+						filterValue: {
+							type: "string",
+							value: query
+						}
+					}
+				});
+			}
+			return results.slice(0, maxTypedResults);
+		},
+		bootstrap() {
+			return allItems;
+		}
+	};
+}
+var StringOps = {
+	CONTAINS: "contains",
+	NOT_CONTAINS: "not_contains",
+	STARTS_WITH: "starts_with",
+	NOT_STARTS_WITH: "not_starts_with",
+	ENDS_WITH: "ends_with",
+	NOT_ENDS_WITH: "not_ends_with",
+	IS: "is",
+	IS_NOT: "is_not"
+};
+var NumberOps = {
+	EQUALS: "equals",
+	NOT_EQUALS: "not_equals",
+	GREATER_THAN: "greater_than",
+	LESS_THAN: "less_than",
+	GREATER_THAN_OR_EQUAL: "greater_than_or_equal",
+	LESS_THAN_OR_EQUAL: "less_than_or_equal"
+};
+var DateOps = {
+	BEFORE: "before",
+	AFTER: "after",
+	BETWEEN: "between"
+};
+var BooleanOps = {
+	IS_TRUE: "is_true",
+	IS_FALSE: "is_false"
+};
+var EnumOps = {
+	IS: "is",
+	IS_NOT: "is_not"
+};
+var ListOps = {
+	IS_ANY_OF: "is_any_of",
+	IS_NONE_OF: "is_none_of"
+};
+var op = (key, i18nKey, value) => ({
+	key,
+	i18nKey,
+	value
+});
+function buildField(def) {
+	const label = def.label ?? def.key;
+	switch (def.type) {
+		case "string": return {
+			key: def.key,
+			label,
+			defaultOperator: StringOps.CONTAINS,
+			operators: [
+				op(StringOps.CONTAINS, "@astryx.powersearch.operator.contains", { type: "string" }),
+				op(StringOps.NOT_CONTAINS, "@astryx.powersearch.operator.notContains", { type: "string" }),
+				op(StringOps.STARTS_WITH, "@astryx.powersearch.operator.startsWith", { type: "string" }),
+				op(StringOps.NOT_STARTS_WITH, "@astryx.powersearch.operator.notStartsWith", { type: "string" }),
+				op(StringOps.ENDS_WITH, "@astryx.powersearch.operator.endsWith", { type: "string" }),
+				op(StringOps.NOT_ENDS_WITH, "@astryx.powersearch.operator.notEndsWith", { type: "string" }),
+				op(StringOps.IS, "@astryx.powersearch.operator.is", { type: "string" }),
+				op(StringOps.IS_NOT, "@astryx.powersearch.operator.isNot", { type: "string" })
+			]
+		};
+		case "number": return {
+			key: def.key,
+			label,
+			defaultOperator: NumberOps.EQUALS,
+			operators: [
+				op(NumberOps.EQUALS, "@astryx.powersearch.operator.equals", { type: "float" }),
+				op(NumberOps.NOT_EQUALS, "@astryx.powersearch.operator.notEquals", { type: "float" }),
+				op(NumberOps.GREATER_THAN, "@astryx.powersearch.operator.greaterThan", { type: "float" }),
+				op(NumberOps.LESS_THAN, "@astryx.powersearch.operator.lessThan", { type: "float" }),
+				op(NumberOps.GREATER_THAN_OR_EQUAL, "@astryx.powersearch.operator.greaterThanOrEqual", { type: "float" }),
+				op(NumberOps.LESS_THAN_OR_EQUAL, "@astryx.powersearch.operator.lessThanOrEqual", { type: "float" })
+			]
+		};
+		case "date": return {
+			key: def.key,
+			label,
+			defaultOperator: DateOps.AFTER,
+			operators: [
+				op(DateOps.BEFORE, "@astryx.powersearch.operator.before", { type: "date_absolute" }),
+				op(DateOps.AFTER, "@astryx.powersearch.operator.after", { type: "date_absolute" }),
+				op(DateOps.BETWEEN, "@astryx.powersearch.operator.between", { type: "date_range" })
+			]
+		};
+		case "boolean": return {
+			key: def.key,
+			label,
+			defaultOperator: BooleanOps.IS_TRUE,
+			operators: [op(BooleanOps.IS_TRUE, "@astryx.powersearch.operator.isTrue", { type: "empty" }), op(BooleanOps.IS_FALSE, "@astryx.powersearch.operator.isFalse", { type: "empty" })]
+		};
+		case "enum": {
+			const values = def.enumValues ?? [];
+			return {
+				key: def.key,
+				label,
+				defaultOperator: EnumOps.IS,
+				operators: [op(EnumOps.IS, "@astryx.powersearch.operator.is", {
+					type: "enum",
+					values
+				}), op(EnumOps.IS_NOT, "@astryx.powersearch.operator.isNot", {
+					type: "enum",
+					values
+				})]
+			};
+		}
+		case "enum_list": {
+			const values = def.enumValues ?? [];
+			return {
+				key: def.key,
+				label,
+				defaultOperator: ListOps.IS_ANY_OF,
+				operators: [op(ListOps.IS_ANY_OF, "@astryx.powersearch.operator.isAnyOf", {
+					type: "enum_list",
+					values
+				}), op(ListOps.IS_NONE_OF, "@astryx.powersearch.operator.isNoneOf", {
+					type: "enum_list",
+					values
+				})]
+			};
+		}
+		case "string_list": return {
+			key: def.key,
+			label,
+			defaultOperator: ListOps.IS_ANY_OF,
+			operators: [op(ListOps.IS_ANY_OF, "@astryx.powersearch.operator.isAnyOf", { type: "string_list" }), op(ListOps.IS_NONE_OF, "@astryx.powersearch.operator.isNoneOf", { type: "string_list" })]
+		};
+	}
+}
+function toUnixSeconds(value) {
+	return value instanceof Date ? Math.floor(value.getTime() / 1e3) : value;
+}
+function toStringValues(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value) && value.every((item) => typeof item === "string")) return value;
+	return null;
+}
+var stringOpHandlers = {
+	[StringOps.CONTAINS]: (s, t) => s.includes(t),
+	[StringOps.NOT_CONTAINS]: (s, t) => !s.includes(t),
+	[StringOps.STARTS_WITH]: (s, t) => s.startsWith(t),
+	[StringOps.NOT_STARTS_WITH]: (s, t) => !s.startsWith(t),
+	[StringOps.ENDS_WITH]: (s, t) => s.endsWith(t),
+	[StringOps.NOT_ENDS_WITH]: (s, t) => !s.endsWith(t),
+	[StringOps.IS]: (s, t) => s === t,
+	[StringOps.IS_NOT]: (s, t) => s !== t
+};
+var numberOpHandlers = {
+	[NumberOps.EQUALS]: (n, t) => n === t,
+	[NumberOps.NOT_EQUALS]: (n, t) => n !== t,
+	[NumberOps.GREATER_THAN]: (n, t) => n > t,
+	[NumberOps.LESS_THAN]: (n, t) => n < t,
+	[NumberOps.GREATER_THAN_OR_EQUAL]: (n, t) => n >= t,
+	[NumberOps.LESS_THAN_OR_EQUAL]: (n, t) => n <= t
+};
+/** Whether one record satisfies one filter — client-side matching used by
+*  `applyFilters`. Types without a local predicate (time, date_relative,
+*  entity_list, custom, nested) pass through like upstream. */
+function matchesFilter(row, filter) {
+	const fieldValue = row[filter.field];
+	const { operator, value: filterValue } = filter;
+	switch (filterValue.type) {
+		case "empty":
+			if (operator === BooleanOps.IS_TRUE) return Boolean(fieldValue) === true;
+			if (operator === BooleanOps.IS_FALSE) return Boolean(fieldValue) === false;
+			return true;
+		case "string": {
+			if (typeof fieldValue !== "string") return false;
+			const handler = stringOpHandlers[operator];
+			if (handler) return handler(fieldValue.toLowerCase(), filterValue.value.toLowerCase());
+			return true;
+		}
+		case "integer":
+		case "float": {
+			if (typeof fieldValue !== "number") return false;
+			const handler = numberOpHandlers[operator];
+			if (handler) return handler(fieldValue, filterValue.value);
+			return true;
+		}
+		case "date_absolute": {
+			if (!(fieldValue instanceof Date) && typeof fieldValue !== "number") return false;
+			const ts = toUnixSeconds(fieldValue);
+			if (operator === DateOps.BEFORE) return ts < filterValue.unixSeconds;
+			if (operator === DateOps.AFTER) return ts > filterValue.unixSeconds;
+			return true;
+		}
+		case "date_range": {
+			if (!(fieldValue instanceof Date) && typeof fieldValue !== "number") return false;
+			const ts = toUnixSeconds(fieldValue);
+			if (operator === DateOps.BETWEEN) {
+				const nowSeconds = Date.now() / 1e3;
+				const start = resolveDateTimeRangePart(filterValue.value.start, nowSeconds);
+				const end = resolveDateTimeRangePart(filterValue.value.end, nowSeconds);
+				return ts >= start && ts <= end;
+			}
+			return true;
+		}
+		case "enum":
+			if (typeof fieldValue !== "string") return false;
+			if (operator === EnumOps.IS) return fieldValue === filterValue.value;
+			if (operator === EnumOps.IS_NOT) return fieldValue !== filterValue.value;
+			return true;
+		case "enum_list":
+		case "string_list": {
+			const values = toStringValues(fieldValue);
+			if (values == null) return false;
+			if (operator === ListOps.IS_ANY_OF) return values.some((v) => filterValue.value.includes(v));
+			if (operator === ListOps.IS_NONE_OF) return values.every((v) => !filterValue.value.includes(v));
+			return true;
+		}
+		case "time":
+		case "date_relative":
+		case "entity_list":
+		case "custom":
+		case "nested": return true;
+	}
+}
+/**
+* Build a `PowerSearchConfig` and a matching `applyFilters` from simplified
+* field definitions.
+*
+* @example
+* ```
+* const defs = [
+*   { key: 'name', type: 'string', label: 'Name' },
+*   { key: 'age', type: 'number', label: 'Age' },
+*   { key: 'active', type: 'boolean', label: 'Active' },
+* ] as const;
+* const { config, applyFilters } = createPowerSearchConfig(defs);
+* const filtered = applyFilters(filters, data);
+* ```
+*/
+function createPowerSearchConfig(definitions, configName) {
+	const config = {
+		name: configName ?? "PowerSearchConfig",
+		fields: definitions.map(buildField)
+	};
+	function applyFilters(filters, data) {
+		if (filters.length === 0) return [...data];
+		return data.filter((row) => filters.every((f) => matchesFilter(row, f)));
+	}
+	return {
+		config,
+		applyFilters
+	};
+}
+/** Memoized `createPowerSearchConfig` for component bodies. */
+function usePowerSearchConfig(definitions, configName) {
+	return useMemo(() => createPowerSearchConfig(definitions, configName), [definitions, configName], _h$2);
+}
+var _hs$ = /* @__PURE__ */ hookSlots(3);
+_hs$ + 1;
+var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
+//#endregion
+export { createInternalConfig, createPowerSearchConfig, createPowerSearchSource, formatDateAbsolute, formatFilterValue, matchesFilter, resolveDateTimeRangePart, resolveOperatorLabel, usePowerSearchConfig };

package/dist/web/power-search-strings.js

@@ -0,0 +1,74 @@
+//#region src/power-search-strings.ts
+/** Default English strings for the PowerSearch family — the portable stand-in
+*  for Astryx's `@astryx.powersearch.*` / `@astryx.moreMenu.*` catalog keys.
+*  There is no i18n provider seam in this build: `label` operator variants are
+*  verbatim, `i18nKey` variants resolve through this map, and an unknown key
+*  falls back to its final path segment. `{count}` plurals collapse to the
+*  English one/other rule. */
+var STRINGS = {
+	"@astryx.powersearch.label": "Search",
+	"@astryx.powersearch.placeholder": "Search…",
+	"@astryx.powersearch.resultCount": "{count, plural, one {# result} other {# results}}",
+	"@astryx.powersearch.editor.field": "Field",
+	"@astryx.powersearch.editor.operator": "Operator",
+	"@astryx.powersearch.editor.addFilter": "+ Add filter",
+	"@astryx.powersearch.editor.removeFilter": "Remove filter",
+	"@astryx.powersearch.editor.groupOperator": "Group operator",
+	"@astryx.powersearch.editor.group": "Group",
+	"@astryx.powersearch.editor.delete": "Delete",
+	"@astryx.powersearch.editor.cancel": "Cancel",
+	"@astryx.powersearch.editor.apply": "Apply",
+	"@astryx.powersearch.valueEditor.value": "Value",
+	"@astryx.powersearch.valueEditor.values": "Values",
+	"@astryx.powersearch.valueEditor.time": "Time",
+	"@astryx.powersearch.valueEditor.date": "Date",
+	"@astryx.powersearch.valueEditor.relativeDate": "Relative date",
+	"@astryx.powersearch.valueEditor.startDate": "Start date",
+	"@astryx.powersearch.valueEditor.endDate": "End date",
+	"@astryx.powersearch.valueEditor.entities": "Entities",
+	"@astryx.powersearch.valueEditor.searchPlaceholder": "Search…",
+	"@astryx.powersearch.valueEditor.enterValuePlaceholder": "Enter value…",
+	"@astryx.powersearch.valueEditor.addValuesPlaceholder": "Add values…",
+	"@astryx.powersearch.valueEditor.enterNumberPlaceholder": "Enter number…",
+	"@astryx.powersearch.valueEditor.selectValuesPlaceholder": "Select values…",
+	"@astryx.powersearch.valueEditor.dateRange": "date range",
+	"@astryx.powersearch.valueEditor.itemsCount": "{count, plural, one {# item} other {# items}}",
+	"@astryx.powersearch.valueEditor.entitiesCount": "{count, plural, one {# entity} other {# entities}}",
+	"@astryx.powersearch.valueEditor.filtersCount": "{count, plural, one {# filter} other {# filters}}",
+	"@astryx.powersearch.operator.contains": "contains",
+	"@astryx.powersearch.operator.notContains": "does not contain",
+	"@astryx.powersearch.operator.startsWith": "starts with",
+	"@astryx.powersearch.operator.notStartsWith": "does not start with",
+	"@astryx.powersearch.operator.endsWith": "ends with",
+	"@astryx.powersearch.operator.notEndsWith": "does not end with",
+	"@astryx.powersearch.operator.is": "is",
+	"@astryx.powersearch.operator.isNot": "is not",
+	"@astryx.powersearch.operator.equals": "is",
+	"@astryx.powersearch.operator.notEquals": "is not",
+	"@astryx.powersearch.operator.greaterThan": "is greater than",
+	"@astryx.powersearch.operator.lessThan": "is less than",
+	"@astryx.powersearch.operator.greaterThanOrEqual": "is greater than or equal to",
+	"@astryx.powersearch.operator.lessThanOrEqual": "is less than or equal to",
+	"@astryx.powersearch.operator.before": "is before",
+	"@astryx.powersearch.operator.after": "is after",
+	"@astryx.powersearch.operator.between": "is between",
+	"@astryx.powersearch.operator.isTrue": "is true",
+	"@astryx.powersearch.operator.isFalse": "is false",
+	"@astryx.powersearch.operator.isAnyOf": "is any of",
+	"@astryx.powersearch.operator.isNoneOf": "is none of",
+	"@astryx.moreMenu.label": "More options"
+};
+/** Catalog lookup with a `{count, plural, ...}` subset. Not exported as a
+*  general i18n facility — PowerSearch internals only. */
+var powerSearchTranslate = (key, params) => {
+	let text = STRINGS[key];
+	if (text == null) return (key.split(".").pop() ?? key).replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+	if (params?.count != null) {
+		const count = params.count;
+		text = text.replace(/\{count, plural, one \{([^}]*)\} other \{([^}]*)\}\}/g, (_m, one, other) => count === 1 ? one : other);
+		text = text.replace(/\{count, number\}|#/g, String(count));
+	}
+	return text;
+};
+//#endregion
+export { powerSearchTranslate };