Function matchesTextFilter

app/composables/useStructuredFilters.ts:211–278

(pkg: NpmSearchResult, text: string, scope: SearchScope)

  // Filter predicates
  function matchesTextFilter(pkg: NpmSearchResult, text: string, scope: SearchScope): boolean {
    if (!text) return true

    const pkgName = pkg.package.name.toLowerCase()
    const pkgDescription = (pkg.package.description ?? '').toLowerCase()
    const pkgKeywords = (pkg.package.keywords ?? []).map(k => k.toLowerCase())

    // When scope is 'all', parse and handle operators
    if (scope === 'all') {
      const parsed = parseSearchOperators(text)

      // If operators are present, use structured matching
      if (hasSearchOperators(parsed)) {
        // All specified operators must match (AND logic between operator types)
        // Within each operator, any value can match (OR logic within operator)

        if (parsed.name?.length) {
          const nameMatches = parsed.name.some(n => pkgName.includes(n.toLowerCase()))
          if (!nameMatches) return false
        }

        if (parsed.description?.length) {
          const descMatches = parsed.description.some(d => pkgDescription.includes(d.toLowerCase()))
          if (!descMatches) return false
        }

        if (parsed.keywords?.length) {
          const kwMatches = parsed.keywords.some(kw =>
            pkgKeywords.some(pk => pk.includes(kw.toLowerCase())),
          )
          if (!kwMatches) return false
        }

        // If there's remaining text, it must match somewhere
        if (parsed.text) {
          const textLower = parsed.text.toLowerCase()
          const textMatches =
            pkgName.includes(textLower) ||
            pkgDescription.includes(textLower) ||
            pkgKeywords.some(k => k.includes(textLower))
          if (!textMatches) return false
        }

        return true
      }

      // No operators - fall through to standard 'all' search
      const lower = text.toLowerCase()
      return (
        pkgName.includes(lower) ||
        pkgDescription.includes(lower) ||
        pkgKeywords.some(k => k.includes(lower))
      )
    }

    // Non-'all' scopes - simple matching
    const lower = text.toLowerCase()
    switch (scope) {