crazy-macs/tag-launcher.git

			@@ -202,6 +202,64 @@

			// MARK: - Search Documents

			private enum QuickSearchFieldKind: Int {
			case name = 0
			case tag = 1
			case note = 2
			case bundleIdentifier = 3
			case internalBundleName = 4

			var weight: Double {
			switch self {
			case .name: return 100
			case .tag: return 70
			case .note: return 45
			case .internalBundleName: return 30
			case .bundleIdentifier: return 20
			}
			}
			}

			private enum QuickSearchMatchKind {
			case exact
			case prefix
			case substring
			case acronym
			case fuzzy

			var weight: Double {
			switch self {
			case .exact: return 100
			case .prefix: return 80
			case .substring: return 60
			case .acronym: return 55
			case .fuzzy: return 35
			}
			}
			}

			private struct QuickSearchIndexedField {
			let kind: QuickSearchFieldKind
			let text: String
			let normalized: String
			let acronym: String
			let pinyinCandidates: [String]
			let allowPinyinSubstring: Bool
			let allowPinyinFuzzySubsequence: Bool
			}

			private struct QuickSearchMatchOptions {
			let allowSubstring: Bool
			let allowFuzzySubsequence: Bool
			}

			private struct QuickSearchTokenMatch {
			let score: Double
			let fieldRank: Int
			let fieldKind: QuickSearchFieldKind
			let originalText: String
			}

			struct QuickSearchDocument: Identifiable {
			var id: URL { app.id }
			let app: AppInfo
			@@ -212,6 +270,7 @@
			let bundleIdentifier: String
			let lastOpenedAt: Date?
			let openCount: Int
			fileprivate let searchableFields: [QuickSearchIndexedField]
			}

			struct QuickSearchResult: Identifiable {
			@@ -227,73 +286,30 @@
			}

			enum QuickSearchEngine {
			private enum FieldKind: Int {
			case name = 0
			case tag = 1
			case note = 2
			case bundleIdentifier = 3
			case internalBundleName = 4

			var weight: Double {
			switch self {
			case .name: return 100
			case .tag: return 70
			case .note: return 45
			case .internalBundleName: return 30
			case .bundleIdentifier: return 20
			}
			}
			}

			private enum MatchKind {
			case exact
			case prefix
			case substring
			case acronym
			case fuzzy

			var weight: Double {
			switch self {
			case .exact: return 100
			case .prefix: return 80
			case .substring: return 60
			case .acronym: return 55
			case .fuzzy: return 35
			}
			}
			}

			private struct Field {
			let kind: FieldKind
			let text: String
			let normalized: String
			let acronym: String
			let pinyinCandidates: [String]
			}

			private struct MatchOptions {
			let allowSubstring: Bool
			let allowFuzzySubsequence: Bool
			}

			private struct TokenMatch {
			let score: Double
			let fieldRank: Int
			let fieldKind: FieldKind
			let originalText: String
			}

			static func makeDocuments(apps: [AppInfo], store: TagDatabase.Store) -> [QuickSearchDocument] {
			apps.map { app in
			QuickSearchDocument(
			app: app,
			localizedNames: localizedNames(for: app),
			internalBundleNames: internalBundleNames(for: app),
			let localizedNames = uniqueOrdered(app.localizedNames)
			let internalBundleNames = internalBundleNames(for: app)
			let note = store.appNotes[app.path.path] ?? app.note ?? ""
			let bundleIdentifier = app.bundleIdentifier ?? ""
			let searchableFields = makeSearchableFields(
			appName: app.name,
			localizedNames: localizedNames,
			internalBundleNames: internalBundleNames,
			tagNames: app.tags,
			note: store.appNotes[app.path.path] ?? app.note ?? "",
			bundleIdentifier: app.bundleIdentifier ?? "",
			note: note,
			bundleIdentifier: bundleIdentifier
			)
			return QuickSearchDocument(
			app: app,
			localizedNames: localizedNames,
			internalBundleNames: internalBundleNames,
			tagNames: app.tags,
			note: note,
			bundleIdentifier: bundleIdentifier,
			lastOpenedAt: store.appLastOpenedAt[app.path.path],
			openCount: store.appOpenCounts[app.path.path] ?? 0
			openCount: store.appOpenCounts[app.path.path] ?? 0,
			searchableFields: searchableFields
			)
			}
			}
			@@ -320,7 +336,7 @@
			}

			private static func result(for document: QuickSearchDocument, tokens: [String]) -> QuickSearchResult? {
			let fields = searchableFields(for: document)
			let fields = document.searchableFields
			var textScore: Double = 0
			var bestFieldRank = Int.max
			var matchedTagName: String?
			@@ -353,61 +369,78 @@
			)
			}

			private static func searchableFields(for document: QuickSearchDocument) -> [Field] {
			let names = uniqueOrdered([document.app.name] + document.localizedNames)
			private static func makeSearchableFields(
			appName: String,
			localizedNames: [String],
			internalBundleNames: [String],
			tagNames: [String],
			note: String,
			bundleIdentifier: String
			) -> [QuickSearchIndexedField] {
			let names = uniqueOrdered([appName] + localizedNames)
			let nameFields = names.map {
			Field(
			return QuickSearchIndexedField(
			kind: .name,
			text: $0,
			normalized: normalizeField($0),
			acronym: acronym(for: $0),
			pinyinCandidates: pinyinCandidates(for: $0)
			pinyinCandidates: pinyinCandidates(for: $0, includeLatin: true),
			allowPinyinSubstring: true,
			allowPinyinFuzzySubsequence: true
			)
			}
			let tagFields = document.tagNames.map {
			Field(
			let tagFields = tagNames.map {
			QuickSearchIndexedField(
			kind: .tag,
			text: $0,
			normalized: normalizeField($0),
			acronym: "",
			pinyinCandidates: pinyinCandidates(for: $0)
			pinyinCandidates: pinyinCandidates(for: $0),
			allowPinyinSubstring: false,
			allowPinyinFuzzySubsequence: false
			)
			}
			let noteFields = document.note.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? [] : [
			Field(
			let noteFields = note.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? [] : [
			QuickSearchIndexedField(
			kind: .note,
			text: document.note,
			normalized: normalizeField(document.note),
			text: note,
			normalized: normalizeField(note),
			acronym: "",
			pinyinCandidates: pinyinCandidates(for: document.note)
			pinyinCandidates: pinyinCandidates(for: note),
			allowPinyinSubstring: true,
			allowPinyinFuzzySubsequence: false
			)
			]
			let bundleFields = document.bundleIdentifier.isEmpty ? [] : [
			Field(
			let bundleFields = bundleIdentifier.isEmpty ? [] : [
			QuickSearchIndexedField(
			kind: .bundleIdentifier,
			text: document.bundleIdentifier,
			normalized: normalizeField(document.bundleIdentifier),
			text: bundleIdentifier,
			normalized: normalizeField(bundleIdentifier),
			acronym: "",
			pinyinCandidates: []
			pinyinCandidates: [],
			allowPinyinSubstring: false,
			allowPinyinFuzzySubsequence: false
			)
			]
			let internalBundleNameFields = document.internalBundleNames.map {
			Field(
			let internalBundleNameFields = internalBundleNames.map {
			QuickSearchIndexedField(
			kind: .internalBundleName,
			text: $0,
			normalized: normalizeField($0),
			acronym: "",
			pinyinCandidates: []
			pinyinCandidates: [],
			allowPinyinSubstring: false,
			allowPinyinFuzzySubsequence: false
			)
			}
			return nameFields + tagFields + noteFields + bundleFields + internalBundleNameFields
			}

			private static func match(token: String, field: Field) -> TokenMatch? {
			private static func match(token: String, field: QuickSearchIndexedField) -> QuickSearchTokenMatch? {
			guard let candidate = bestMatchCandidate(token: token, field: field) else { return nil }
			let positionBoost = candidate.0 == .exact ? 0 : max(0, 10 - min(candidate.1, 10))
			let score = field.kind.weight + candidate.0.weight + Double(positionBoost)
			return TokenMatch(
			return QuickSearchTokenMatch(
			score: score,
			fieldRank: field.kind.rawValue,
			fieldKind: field.kind,
			@@ -415,8 +448,8 @@
			)
			}

			private static func bestMatchCandidate(token: String, field: Field) -> (MatchKind, Int)? {
			var candidates: [(MatchKind, Int)] = []
			private static func bestMatchCandidate(token: String, field: QuickSearchIndexedField) -> (QuickSearchMatchKind, Int)? {
			var candidates: [(QuickSearchMatchKind, Int)] = []

			if let textCandidate = matchCandidate(
			token: token,
			@@ -432,7 +465,8 @@
			if let pinyinCandidate = matchPinyinCandidate(
			token: token,
			normalized: pinyin,
			allowSubstring: field.kind == .note
			allowSubstring: field.allowPinyinSubstring,
			allowFuzzySubsequence: field.allowPinyinFuzzySubsequence
			) {
			candidates.append(pinyinCandidate)
			}
			@@ -444,24 +478,24 @@
			}
			}

			private static func matchOptions(for fieldKind: FieldKind) -> MatchOptions {
			private static func matchOptions(for fieldKind: QuickSearchFieldKind) -> QuickSearchMatchOptions {
			switch fieldKind {
			case .name:
			return MatchOptions(allowSubstring: true, allowFuzzySubsequence: true)
			return QuickSearchMatchOptions(allowSubstring: true, allowFuzzySubsequence: true)
			case .tag:
			return MatchOptions(allowSubstring: true, allowFuzzySubsequence: true)
			return QuickSearchMatchOptions(allowSubstring: true, allowFuzzySubsequence: true)
			case .note:
			return MatchOptions(allowSubstring: true, allowFuzzySubsequence: true)
			return QuickSearchMatchOptions(allowSubstring: true, allowFuzzySubsequence: true)
			case .bundleIdentifier, .internalBundleName:
			return MatchOptions(allowSubstring: false, allowFuzzySubsequence: false)
			return QuickSearchMatchOptions(allowSubstring: false, allowFuzzySubsequence: false)
			}
			}

			private static func matchCandidate(
			token: String,
			normalized: String,
			options: MatchOptions
			) -> (MatchKind, Int)? {
			options: QuickSearchMatchOptions
			) -> (QuickSearchMatchKind, Int)? {
			guard !normalized.isEmpty else { return nil }
			if normalized == token {
			return (.exact, 0)
			@@ -481,8 +515,9 @@
			private static func matchPinyinCandidate(
			token: String,
			normalized: String,
			allowSubstring: Bool = false
			) -> (MatchKind, Int)? {
			allowSubstring: Bool = false,
			allowFuzzySubsequence: Bool = false
			) -> (QuickSearchMatchKind, Int)? {
			guard !normalized.isEmpty else { return nil }
			if normalized == token {
			return (.exact, 0)
			@@ -492,6 +527,9 @@
			}
			if allowSubstring, let range = normalized.range(of: token) {
			return (.substring, normalized.distance(from: normalized.startIndex, to: range.lowerBound))
			}
			if allowFuzzySubsequence, token.count >= 3, isSubsequence(token, of: normalized) {
			return (.fuzzy, 10)
			}
			return nil
			}
			@@ -566,8 +604,8 @@
			.lowercased()
			}

			private static func pinyinCandidates(for value: String) -> [String] {
			guard value.range(of: #"\p{Han}"#, options: .regularExpression) != nil else { return [] }
			private static func pinyinCandidates(for value: String, includeLatin: Bool = false) -> [String] {
			guard includeLatin \|\| containsNonLatinLetter(value) else { return [] }
			let mutable = NSMutableString(string: value)
			CFStringTransform(mutable, nil, kCFStringTransformToLatin, false)
			CFStringTransform(mutable, nil, kCFStringTransformStripCombiningMarks, false)
			@@ -585,6 +623,31 @@
			.map(String.init)
			.joined()
			return uniqueOrdered([spaced, compact, initials].filter { !$0.isEmpty })
			}

			private static func containsNonLatinLetter(_ value: String) -> Bool {
			value.unicodeScalars.contains { scalar in
			CharacterSet.letters.contains(scalar) && !isLatinScriptLetter(scalar)
			}
			}

			private static func isLatinScriptLetter(_ scalar: UnicodeScalar) -> Bool {
			switch scalar.value {
			case 0x0041...0x005A, // Basic Latin uppercase
			0x0061...0x007A, // Basic Latin lowercase
			0x00AA,
			0x00BA,
			0x00C0...0x024F, // Latin-1 Supplement, Extended-A/B
			0x1E00...0x1EFF, // Latin Extended Additional
			0x2C60...0x2C7F, // Latin Extended-C
			0xA720...0xA7FF, // Latin Extended-D
			0xAB30...0xAB6F, // Latin Extended-E
			0xFF21...0xFF3A, // Fullwidth Latin uppercase
			0xFF41...0xFF5A: // Fullwidth Latin lowercase
			return true
			default:
			return false
			}
			}

			private static func isSubsequence(_ token: String, of value: String) -> Bool {
			@@ -671,6 +734,7 @@
			let results: [QuickSearchResult]
			let selectedID: URL?
			let focusToken: Int
			let selectionScrollToken: Int
			let isLoading: Bool
			let maxVisibleRows: Int
			let errorMessage: String?
			@@ -678,8 +742,16 @@
			let onHover: (QuickSearchResult) -> Void
			let onLaunch: (QuickSearchResult) -> Void

			@Environment(\.colorScheme) private var colorScheme

			private let panelWidth: CGFloat = 760
			private let rowHeight: CGFloat = 74

			private var panelBackgroundColor: Color {
			colorScheme == .dark
			? Color(red: 0.105, green: 0.110, blue: 0.125).opacity(0.97)
			: Color.white.opacity(0.97)
			}

			var body: some View {
			VStack(alignment: .leading, spacing: 0) {
			@@ -704,17 +776,11 @@
			Divider().opacity(0.35)

			if isLoading {
			HStack(spacing: 10) {
			ProgressView()
			.controlSize(.small)
			Text(tr("quickSearch.loading"))
			.font(.system(size: 15, weight: .medium))
			.foregroundStyle(.secondary)
			Spacer(minLength: 0)
			}
			.padding(.horizontal, 28)
			.padding(.vertical, 24)
			.frame(minHeight: 86)
			QuickSearchMessageRow(
			systemImage: "hourglass",
			message: tr("quickSearch.loading"),
			tint: .secondary
			)
			} else if let errorMessage {
			QuickSearchMessageRow(
			systemImage: "exclamationmark.triangle.fill",
			@@ -753,8 +819,8 @@
			.padding(.vertical, 10)
			}
			.frame(height: CGFloat(min(results.count, maxVisibleRows)) * (rowHeight + 2) + 20)
			.onChange(of: selectedID) { _, id in
			guard let id else { return }
			.onChange(of: selectionScrollToken) { _, _ in
			guard let id = selectedID else { return }
			withAnimation(.easeOut(duration: 0.08)) {
			scrollProxy.scrollTo(id, anchor: .center)
			}
			@@ -765,7 +831,7 @@
			.frame(width: panelWidth)
			.background(
			RoundedRectangle(cornerRadius: 34, style: .continuous)
			.fill(.regularMaterial)
			.fill(panelBackgroundColor)
			.shadow(color: .black.opacity(0.18), radius: 36, y: 18)
			)
			.overlay(
			@@ -790,7 +856,7 @@
			.cornerRadius(10)

			VStack(alignment: .leading, spacing: 4) {
			Text(result.app.name)
			Text(result.app.displayName)
			.font(.system(size: 20, weight: .semibold))
			.foregroundStyle(.primary)
			.lineLimit(1)
			@@ -854,7 +920,7 @@
			}

			private var accessibilityText: String {
			[result.app.name, detailText].compactMap { $0 }.joined(separator: ", ")
			[result.app.displayName, detailText].compactMap { $0 }.joined(separator: ", ")
			}
			}

			@@ -899,11 +965,10 @@
			field.placeholderString = placeholder
			field.delegate = context.coordinator
			field.onCommand = onCommand
			context.coordinator.onCommand = onCommand
			field.setAccessibilityLabel(tr("quickSearch.inputAccessibility"))
			context.coordinator.field = field
			DispatchQueue.main.async {
			field.window?.makeFirstResponder(field)
			}
			requestFocus(field)
			return field
			}

			@@ -913,11 +978,19 @@
			}
			field.placeholderString = placeholder
			field.onCommand = onCommand
			context.coordinator.onCommand = onCommand
			if context.coordinator.lastFocusToken != focusToken {
			context.coordinator.lastFocusToken = focusToken
			DispatchQueue.main.async {
			field.window?.makeFirstResponder(field)
			}
			requestFocus(field)
			}
			}

			private func requestFocus(_ field: QuickSearchNativeTextField) {
			DispatchQueue.main.async { [weak field] in
			guard let field,
			field.window?.firstResponder !== field
			else { return }
			field.window?.makeFirstResponder(field)
			}
			}

			@@ -928,6 +1001,7 @@
			final class Coordinator: NSObject, NSTextFieldDelegate {
			var text: Binding<String>
			var lastFocusToken = 0
			var onCommand: ((QuickSearchCommand) -> Void)?
			weak var field: NSTextField?

			init(text: Binding<String>) {
			@@ -938,6 +1012,28 @@
			guard let field = obj.object as? NSTextField else { return }
			text.wrappedValue = field.stringValue
			}

			func control(_ control: NSControl, textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {
			switch commandSelector {
			case #selector(NSResponder.moveUp(_:)):
			onCommand?(.moveUp)
			return true
			case #selector(NSResponder.moveDown(_:)):
			onCommand?(.moveDown)
			return true
			case #selector(NSResponder.insertNewline(_:)):
			onCommand?(.submit)
			return true
			case #selector(NSResponder.insertNewlineIgnoringFieldEditor(_:)):
			onCommand?(.submit)
			return true
			case #selector(NSResponder.cancelOperation(_:)):
			onCommand?(.dismiss)
			return true
			default:
			return false
			}
			}
			}
			}