@bagelink/vue 1.15.267 → 1.15.271

package/src/i18n/locales/it.json

@@ -77,13 +77,17 @@
       "ew": "Finisce con",
       "pr": "Presente",
       "in": "Nella lista",
-      "nin": "Non nella lista"
+      "nin": "Non nella lista",
+      "between": "Tra"
     },
     "placeholders": {
       "selectField": "Seleziona campo",
       "selectOption": "Seleziona opzione",
       "selectDate": "Seleziona data",
-      "enterValue": "Valore"
+      "enterValue": "Valore",
+      "from": "Da",
+      "to": "A",
+      "commaSeparated": "Valori separati da virgole"
     },
     "buttons": {
       "addCondition": "Aggiungi condizione",
@@ -270,5 +274,8 @@
   "addToCalendar": {
     "addTo": "Aggiungi a {name}",
     "addToCalendar": "Aggiungi al calendario"
+  },
+  "guidedHelp": {
+    "hint": "La guida è sempre disponibile sul punto interrogativo."
   }
 }

package/src/i18n/locales/ru.json

@@ -77,13 +77,17 @@
       "ew": "Заканчивается на",
       "pr": "Присутствует",
       "in": "В списке",
-      "nin": "Не в списке"
+      "nin": "Не в списке",
+      "between": "Между"
     },
     "placeholders": {
       "selectField": "Выберите поле",
       "selectOption": "Выберите вариант",
       "selectDate": "Выберите дату",
-      "enterValue": "Значение"
+      "enterValue": "Значение",
+      "from": "От",
+      "to": "До",
+      "commaSeparated": "Значения через запятую"
     },
     "buttons": {
       "addCondition": "Добавить условие",
@@ -270,5 +274,8 @@
   "addToCalendar": {
     "addTo": "Добавить в {name}",
     "addToCalendar": "Добавить в календарь"
+  },
+  "guidedHelp": {
+    "hint": "Обучение всегда доступно по знаку вопроса."
   }
 }

package/src/utils/queryFilter.ts

@@ -43,8 +43,9 @@ export type ComparisonOperator
 		| 'sw' // starts with
 		| 'ew' // ends with
 		| 'pr' // present (has value)
-		| 'in' // in list — expands to (field eq "a" or field eq "b" …)
-		| 'nin' // not in list — expands to (field ne "a" and field ne "b" …)
+		| 'in' // in list — native: field in ["a","b"] (scalar membership OR array overlap)
+		| 'nin' // not in list — native: field nin ["a","b"]
+		| 'between' // inclusive range — field between [lo, hi] (numbers or dates)
 
 /**
  * SCIM 2.0 logical operators
@@ -79,6 +80,14 @@ function formatValue(value: Primitive): string {
 	return String(value)
 }
 
+/**
+ * Format a list of values into a SCIM bracket literal, e.g. ["a","b",3].
+ * Used by list-value operators (in / nin / between).
+ */
+function formatList(values: Primitive[]): string {
+	return `[${values.map(formatValue).join(', ')}]`
+}
+
 /**
  * Build a SCIM 2.0 query string from conditions array
  *
@@ -110,12 +119,15 @@ export function buildQuery<T extends Record<string, any>>(
 		if (op === 'pr') {
 			parts.push(`${field} pr`)
 		} else if (op === 'in' || op === 'nin') {
+			// Native list membership / array-overlap: field in ["a","b"].
 			const values = Array.isArray(value) ? value : (value != null ? [value] : [])
 			if (values.length === 0) continue
-			const innerOp = op === 'in' ? 'eq' : 'ne'
-			const innerConn = op === 'in' ? 'or' : 'and'
-			const inner = values.map(v => `${field} ${innerOp} ${formatValue(v)}`).join(` ${innerConn} `)
-			parts.push(values.length > 1 ? `(${inner})` : inner)
+			parts.push(`${field} ${op} ${formatList(values)}`)
+		} else if (op === 'between') {
+			// Inclusive range: field between [lo, hi]. Requires exactly two bounds.
+			const bounds = Array.isArray(value) ? value : []
+			if (bounds.length !== 2 || bounds[0] == null || bounds[1] == null) continue
+			parts.push(`${field} between ${formatList(bounds)}`)
 		} else {
 			parts.push(`${field} ${op} ${formatValue(value as Primitive ?? null)}`)
 		}
@@ -210,6 +222,30 @@ export class QueryFilter<T extends Record<string, any>> {
 		return this
 	}
 
+	/**
+	 * In list — native membership / array overlap: field in ["a","b"]
+	 */
+	in<K extends DeepKeyOf<T>>(field: K, values: Primitive[]): this {
+		this.parts.push(`${field as string} in ${formatList(values)}`)
+		return this
+	}
+
+	/**
+	 * Not in list: field nin ["a","b"]
+	 */
+	nin<K extends DeepKeyOf<T>>(field: K, values: Primitive[]): this {
+		this.parts.push(`${field as string} nin ${formatList(values)}`)
+		return this
+	}
+
+	/**
+	 * Inclusive range: field between [lo, hi]
+	 */
+	between<K extends DeepKeyOf<T>>(field: K, lo: number | string, hi: number | string): this {
+		this.parts.push(`${field as string} between ${formatList([lo, hi])}`)
+		return this
+	}
+
 	/**
 	 * AND logical operator
 	 */
@@ -361,8 +397,7 @@ export function range<T extends Record<string, any>>(
 	max: number | string
 ): string {
 	return buildQuery<T>([
-		{ field, op: 'ge', value: min },
-		{ field, op: 'le', value: max, connector: 'and' },
+		{ field, op: 'between', value: [min, max] },
 	])
 }
 
@@ -418,6 +453,9 @@ export function evaluateQuery(query: string, data: Record<string, any>): boolean
 				case 'sw': match = value != null && String(fieldValue).startsWith(String(value)); break
 				case 'ew': match = value != null && String(fieldValue).endsWith(String(value)); break
 				case 'pr': match = fieldValue != null; break
+				case 'in': match = matchesIn(fieldValue, value); break
+				case 'nin': match = !matchesIn(fieldValue, value); break
+				case 'between': match = matchesBetween(fieldValue, value); break
 				default: break
 			}
 
@@ -440,8 +478,30 @@ function getNestedValue(obj: Record<string, any>, path: string): any {
 	return path.split('.').reduce<any>((acc, key) => acc?.[key], obj)
 }
 
-const OPERATORS: ComparisonOperator[] = ['eq', 'ne', 'gt', 'ge', 'lt', 'le', 'co', 'sw', 'ew', 'pr', 'in', 'nin']
+/** in — scalar membership OR array overlap (any shared element). */
+function matchesIn(fieldValue: any, value: Primitive | Primitive[] | undefined): boolean {
+	const candidates = Array.isArray(value) ? value : (value != null ? [value] : [])
+	if (candidates.length === 0) return false
+	if (Array.isArray(fieldValue)) return fieldValue.some(v => candidates.includes(v))
+	return candidates.includes(fieldValue)
+}
+
+/** between [lo, hi] — inclusive range (numbers or comparable strings/dates). */
+function matchesBetween(fieldValue: any, value: Primitive | Primitive[] | undefined): boolean {
+	if (!Array.isArray(value) || value.length !== 2 || fieldValue == null) return false
+	const [lo, hi] = value
+	if (lo == null || hi == null) return false
+	const nLo = Number(lo); const nHi = Number(hi); const nVal = Number(fieldValue)
+	if (!Number.isNaN(nLo) && !Number.isNaN(nHi) && !Number.isNaN(nVal)) {
+		return nVal >= nLo && nVal <= nHi
+	}
+	return String(fieldValue) >= String(lo) && String(fieldValue) <= String(hi)
+}
+
+const OPERATORS: ComparisonOperator[] = ['eq', 'ne', 'gt', 'ge', 'lt', 'le', 'co', 'sw', 'ew', 'pr', 'in', 'nin', 'between']
 const CONNECTORS: LogicalOperator[] = ['and', 'or']
+/** Operators whose value is a bracket list literal. */
+const LIST_OPERATORS: ComparisonOperator[] = ['in', 'nin', 'between']
 
 /**
  * Parse a value string into a Primitive
@@ -460,6 +520,37 @@ function parseValue(valueStr: string): Primitive {
 	return trimmed
 }
 
+/**
+ * Parse a bracket list literal token `["a", "b", 3]` into an array of Primitives.
+ * Splits on top-level commas (ignoring commas inside quoted items).
+ */
+function parseListLiteral(token: string): Primitive[] {
+	let inner = token.trim()
+	if (inner.startsWith('[')) inner = inner.slice(1)
+	if (inner.endsWith(']')) inner = inner.slice(0, -1)
+	if (inner.trim() === '') return []
+
+	const items: string[] = []
+	let current = ''
+	let inQuote = false
+	for (let i = 0; i < inner.length; i++) {
+		const ch = inner[i]
+		if (inQuote) {
+			if (ch === '\\' && inner[i + 1] === '"') { current += '\\"'; i++; continue }
+			if (ch === '"') { current += '"'; inQuote = false; continue }
+			current += ch
+		} else if (ch === '"') {
+			current += '"'; inQuote = true
+		} else if (ch === ',') {
+			items.push(current); current = ''
+		} else {
+			current += ch
+		}
+	}
+	if (current.trim() !== '') items.push(current)
+	return items.map(s => parseValue(s.trim()))
+}
+
 /**
  * Parse a SCIM 2.0 query string into conditions array
  * Supports grouping with parentheses: (a eq 1 or b eq 2) and c eq 3
@@ -551,12 +642,13 @@ function parseTokens<T extends Record<string, any>>(
 			throw new Error(`Invalid operator: ${op}`)
 		}
 
-		let value: Primitive | undefined
+		let value: Primitive | Primitive[] | undefined
 		if (op !== 'pr') {
 			if (i >= end) {
 				throw new Error(`Missing value for operator ${op}`)
 			}
-			value = parseValue(tokens[i++])
+			const raw = tokens[i++]
+			value = LIST_OPERATORS.includes(op) ? parseListLiteral(raw) : parseValue(raw)
 		}
 
 		const condition: FilterCondition<T> = { field, op, value }
@@ -603,6 +695,31 @@ function tokenize(query: string): string[] {
 				i++
 				continue
 			}
+			// Handle a bracket list literal as a SINGLE token: [ ... ].
+			// Consume everything up to the matching ], respecting quotes so a
+			// quoted item containing ] doesn't terminate the list early.
+			if (char === '[') {
+				if (current) { tokens.push(current); current = '' }
+				let literal = '['
+				i++
+				let inStr = false
+				while (i < query.length) {
+					const c = query[i]
+					if (inStr) {
+						if (c === '\\' && query[i + 1] === '"') { literal += '\\"'; i += 2; continue }
+						if (c === '"') inStr = false
+						literal += c
+						i++
+						continue
+					}
+					if (c === '"') { inStr = true; literal += c; i++; continue }
+					literal += c
+					i++
+					if (c === ']') break
+				}
+				tokens.push(literal)
+				continue
+			}
 			// Handle parentheses as separate tokens
 			if (char === '(' || char === ')') {
 				if (current) {