@bagelink/vue 1.6.47 → 1.6.51

package/src/utils/useSearch.ts

@@ -17,7 +17,7 @@ const htmlReplacers = {
  * @returns Plain text without HTML tags
  */
 export function clearHtml(value?: string) {
-	if (!value) {return ''}
+	if (!value) { return '' }
 	return Object.entries(htmlReplacers)
 		.reduce(
 			(
@@ -52,7 +52,7 @@ function getValueByPath(obj: any, path: string): any {
 	let result = obj
 
 	for (const key of keys) {
-		if (null === result || result === undefined || 'object' !== typeof result) {
+		if (result === null || result === undefined || typeof result !== 'object') {
 			return undefined
 		}
 		result = result[key]
@@ -71,7 +71,7 @@ function getValueByPath(obj: any, path: string): any {
 function calculateRelevance(stringValue: string, searchTerms: string[]): number {
 	let score = 0
 
-	if (0 === stringValue.length) {return 0}
+	if (stringValue.length === 0) { return 0 }
 
 	// Track matched character count for density calculation
 	let totalMatchedChars = 0
@@ -138,7 +138,7 @@ export interface SearchResult<T> {
  * @returns True if the value is a primitive
  */
 function isPrimitive(value: any): boolean {
-	return 'string' === typeof value || 'number' === typeof value || 'boolean' === typeof value
+	return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
 }
 
 /**
@@ -147,10 +147,10 @@ function isPrimitive(value: any): boolean {
  * @returns String representation or empty string if value can't be converted
  */
 function toSearchableString(value: any): string {
-	if (null === value || value === undefined) {return ''}
-	if ('string' === typeof value) {return clearHtml(value)}
-	if ('number' === typeof value || 'boolean' === typeof value) {return String(value)}
-	if ('object' === typeof value && value instanceof Date) {return value.toISOString()}
+	if (value === null || value === undefined) { return '' }
+	if (typeof value === 'string') { return clearHtml(value) }
+	if (typeof value === 'number' || typeof value === 'boolean') { return String(value) }
+	if (typeof value === 'object' && value instanceof Date) { return value.toISOString() }
 	return ''
 }
 
@@ -168,14 +168,14 @@ export function searchItems<T>(params: SearchItemParams<T>): T[] {
 	const itemsArray = toValue(items) || []
 
 	// Return all items if search is empty or doesn't meet minimum character threshold
-	if (!searchValue || searchValue.length < minChars) {return itemsArray}
+	if (!searchValue || searchValue.length < minChars) { return itemsArray }
 
 	// Split search term into individual words for better matching
 	const searchTerms = normalizeText(searchValue)
 		.split(/\s+/)
-		.filter(term => 1 < term.length)
+		.filter(term => term.length > 1)
 
-	if (0 === searchTerms.length) {return itemsArray}
+	if (searchTerms.length === 0) { return itemsArray }
 
 	// ---- Field weight configuration ----
 	// Default field weights for common fields
@@ -209,7 +209,7 @@ export function searchItems<T>(params: SearchItemParams<T>): T[] {
 		// First check custom weights
 		if (path in fieldWeights) {
 			const customWeight = fieldWeights[path]
-			if ('number' === typeof customWeight) {
+			if (typeof customWeight === 'number') {
 				return customWeight
 			}
 		}
@@ -231,13 +231,13 @@ export function searchItems<T>(params: SearchItemParams<T>): T[] {
 	 * @returns Array of flattened key paths
 	 */
 	function collectAllKeys(obj: any, prefix = ''): string[] {
-		if (!obj || 'object' !== typeof obj) {return []}
+		if (!obj || typeof obj !== 'object') { return [] }
 
 		return Object.keys(obj).flatMap((key) => {
 			const value = obj[key]
 			const newPrefix = prefix ? `${prefix}.${key}` : key
 
-			if (value && 'object' === typeof value && !Array.isArray(value)) {
+			if (value && typeof value === 'object' && !Array.isArray(value)) {
 				// Recurse for nested objects
 				return [newPrefix, ...collectAllKeys(value, newPrefix)]
 			}
@@ -281,7 +281,7 @@ export function searchItems<T>(params: SearchItemParams<T>): T[] {
 			const value = getValueByPath(item, String(keyPath))
 
 			// Skip null/undefined values
-			if (null === value || value === undefined) {continue}
+			if (value === null || value === undefined) { continue }
 
 			// CASE 3.1: Handle array field values
 			if (Array.isArray(value)) {
@@ -299,7 +299,7 @@ export function searchItems<T>(params: SearchItemParams<T>): T[] {
 			}
 
 			// CASE 3.2: Handle object fields (skip and process their properties separately)
-			if ('object' === typeof value && !isPrimitive(value)) {
+			if (typeof value === 'object' && !isPrimitive(value)) {
 				continue
 			}
 
@@ -322,19 +322,19 @@ export function searchItems<T>(params: SearchItemParams<T>): T[] {
 	})
 
 	// Filter items with non-zero relevance
-	const nonZeroItems = scoredItems.filter(([, score]) => 0 < score)
+	const nonZeroItems = scoredItems.filter(([, score]) => score > 0)
 
 	// Apply dynamic threshold based on score distribution
 	let filteredItems = nonZeroItems
-	if (0 < nonZeroItems.length) {
+	if (nonZeroItems.length > 0) {
 		const maxScore = Math.max(...nonZeroItems.map(([, score]) => score))
 
 		// If we have very high relevance items, filter out low relevance noise
-		if (5 < maxScore) {
+		if (maxScore > 5) {
 			// Items below 25% of max score are considered low relevance
 			const threshold = maxScore * 0.25
 			filteredItems = nonZeroItems.filter(([, score]) => score >= threshold)
-		} else if (2 < maxScore) {
+		} else if (maxScore > 2) {
 			// For medium relevance results, use a lower threshold
 			const threshold = maxScore * 0.15
 			filteredItems = nonZeroItems.filter(([, score]) => score >= threshold)
@@ -384,8 +384,8 @@ export function useSearch<T>(
 	// Check if first argument is an array or ref (simplified usage)
 	// If it's a params object, it won't have these characteristics
 	const isArray = Array.isArray(paramsOrItems)
-	const isFunction = 'function' === typeof paramsOrItems
-	const isObject = 'object' === typeof paramsOrItems && null !== paramsOrItems 
+	const isFunction = typeof paramsOrItems === 'function'
+	const isObject = typeof paramsOrItems === 'object' && paramsOrItems !== null
 	const isRef = isObject && 'value' in paramsOrItems && !('items' in paramsOrItems)
 
 	const isSimplifiedUsage = isArray || isFunction || isRef
@@ -416,14 +416,14 @@ export function useSearch<T>(
 			() => toValue(searchTerm),
 			async (newTerm) => {
 				// Clear previous timeout if it exists
-				if (null !== debounceTimeout) {
+				if (debounceTimeout !== null) {
 					clearTimeout(debounceTimeout)
 				}
 
-				const term = 'string' === typeof newTerm ? newTerm : ''
+				const term = typeof newTerm === 'string' ? newTerm : ''
 
 				// Allow initial/default fetch when minChars === 0 (including empty term)
-				if (term.length < minChars && 0 < minChars) {
+				if (term.length < minChars && minChars > 0) {
 					serverResults.value = []
 					return
 				}
@@ -454,11 +454,11 @@ export function useSearch<T>(
 
 		// If using server-side search
 		if (serverSearch) {
-			if (term && 'string' === typeof term && term.length >= minChars) {
+			if (term && typeof term === 'string' && term.length >= minChars) {
 				return serverResults.value as T[]
 			}
 			// If minChars is 0, allow default server results when empty
-			if (0 === minChars) {return serverResults.value as T[]}
+			if (minChars === 0) { return serverResults.value as T[] }
 		}
 
 		// Otherwise use client-side filtering
@@ -467,10 +467,10 @@ export function useSearch<T>(
 	// Create computed references
 	const results = computed(() => getFilteredResults())
 	const resultCount = computed(() => results.value.length)
-	const hasResults = computed(() => 0 < resultCount.value)
+	const hasResults = computed(() => resultCount.value > 0)
 	const isSearching = computed(() => {
 		const term = getSearchTermValue()
-		return !!term && 'string' === typeof term && term.length >= minChars
+		return !!term && typeof term === 'string' && term.length >= minChars
 	})
 
 	const result: SearchResult<T> = {

package/vite.config.ts

@@ -1,7 +1,6 @@
 import { resolve } from 'node:path'
 // import { fileURLToPath, URL } from 'node:url'
 import vue from '@vitejs/plugin-vue'
-import ReactivityTransform from '@vue-macros/reactivity-transform/vite'
 import { defineConfig } from 'vite'
 import dts from 'vite-plugin-dts'
 import tsconfigPaths from 'vite-tsconfig-paths'
@@ -11,7 +10,6 @@ const indexDir = resolve(import.meta.dirname, 'src')
 export default defineConfig(() => ({
 	plugins: [
 		tsconfigPaths({ root: indexDir, }),
-		ReactivityTransform(),
 		vue(),
 		dts({
 			entryRoot: indexDir,