75 lines
2.1 KiB
TypeScript
75 lines
2.1 KiB
TypeScript
import type { FilterCondition } from '../types'
|
|
|
|
type ConditionText = string
|
|
type PropertyValue = string
|
|
|
|
function toStringValue(value: unknown): ConditionText {
|
|
if (value == null) return ''
|
|
if (typeof value === 'string') return value
|
|
return String(value)
|
|
}
|
|
|
|
function conditionList(value: unknown): ConditionText[] | null {
|
|
return Array.isArray(value) ? value.map(toStringValue) : null
|
|
}
|
|
|
|
function textMatchResult(op: FilterCondition['op'], matched: boolean): boolean {
|
|
if (op === 'contains' || op === 'equals') return matched
|
|
if (op === 'not_contains' || op === 'not_equals') return !matched
|
|
return false
|
|
}
|
|
|
|
class PropertyArrayField {
|
|
private readonly values: PropertyValue[]
|
|
private readonly normalizedValues: Set<PropertyValue>
|
|
|
|
constructor(values: PropertyValue[]) {
|
|
this.values = values
|
|
this.normalizedValues = new Set(values.map((value) => value.toLowerCase()))
|
|
}
|
|
|
|
contains(target: ConditionText): boolean {
|
|
return this.normalizedValues.has(target.toLowerCase())
|
|
}
|
|
|
|
equals(target: ConditionText): boolean {
|
|
return this.values.length === 1 && this.contains(target)
|
|
}
|
|
|
|
matchesAny(targets: ConditionText[] | null): boolean {
|
|
return targets?.some((target) => this.contains(target)) ?? false
|
|
}
|
|
|
|
matchesRegex(regex: RegExp): boolean {
|
|
return this.values.some((value) => regex.test(value))
|
|
}
|
|
|
|
isEmpty(): boolean {
|
|
return this.values.length === 0
|
|
}
|
|
}
|
|
|
|
export function evaluatePropertyArrayCondition(
|
|
cond: FilterCondition,
|
|
values: PropertyValue[],
|
|
condVal: ConditionText,
|
|
regex: RegExp | null,
|
|
): boolean {
|
|
const field = new PropertyArrayField(values)
|
|
if (regex) return textMatchResult(cond.op, field.matchesRegex(regex))
|
|
const contains = field.contains(condVal)
|
|
const equals = field.equals(condVal)
|
|
const matchesAny = field.matchesAny(conditionList(cond.value))
|
|
const isEmpty = field.isEmpty()
|
|
return new Map<FilterCondition['op'], boolean>([
|
|
['contains', contains],
|
|
['not_contains', !contains],
|
|
['equals', equals],
|
|
['not_equals', !equals],
|
|
['any_of', matchesAny],
|
|
['none_of', !matchesAny],
|
|
['is_empty', isEmpty],
|
|
['is_not_empty', !isEmpty],
|
|
]).get(cond.op) ?? false
|
|
}
|