@bagelink/vue 1.5.17 → 1.5.22

package/src/utils/strings.ts

@@ -2,26 +2,26 @@ export function formatString(
 	str: string,
 	format: 'pascal' | 'camel' | 'snake' | 'titleCase',
 ): string {
-	if (format === 'titleCase') {
+	if ('titleCase' === format) {
 		return str
 			.split('_')
 			.map(word => word[0].toUpperCase() + word.slice(1).toLocaleLowerCase())
 			.join(' ')
 	}
 
-	if (format === 'pascal') {
+	if ('pascal' === format) {
 		return str
 			.split('_')
 			.map(word => word[0].toUpperCase() + word.slice(1).toLocaleLowerCase())
 			.join('')
 	}
-	if (format === 'camel') {
+	if ('camel' === format) {
 		return str
 			.split('_')
-			.map((word, index) => (index === 0 ? word : word[0].toUpperCase() + word.slice(1)))
+			.map((word, index) => (0 === index ? word : word[0].toUpperCase() + word.slice(1)))
 			.join('')
 	}
-	if (format === 'snake') {
+	if ('snake' === format) {
 		return [...str]
 			.map((letter) => {
 				if (letter === letter.toUpperCase()) {

package/src/utils/tapDetector.ts

@@ -34,37 +34,37 @@ export default class TapDetector {
 	}
 
 	onSingleTap(callback: TapCallback): void {
-		if (typeof callback === 'function' && !this.singleTapCallbacks.includes(callback)) {
+		if ('function' === typeof callback && !this.singleTapCallbacks.includes(callback)) {
 			this.singleTapCallbacks.push(callback)
 		}
 	}
 
 	onDoubleTap(callback: TapCallback): void {
-		if (typeof callback === 'function' && !this.doubleTapCallbacks.includes(callback)) {
+		if ('function' === typeof callback && !this.doubleTapCallbacks.includes(callback)) {
 			this.doubleTapCallbacks.push(callback)
 		}
 	}
 
 	private triggerCallbacks(callbackType: CallbackType, event: { clientX: number, clientY: number }): void {
-		const callbacks = callbackType === 'single' ? this.singleTapCallbacks : this.doubleTapCallbacks
+		const callbacks = 'single' === callbackType ? this.singleTapCallbacks : this.doubleTapCallbacks
 		callbacks.forEach((callback) => { callback(event) })
 	}
 
 	private onTouchStart = (event: TouchEvent): void => {
 		this.isTouchMode = true
-		if (event.touches.length === 1) {
+		if (1 === event.touches.length) {
 			this.onPointerDown(event.touches[0].clientX, event.touches[0].clientY)
 		}
 	}
 
 	private onTouchMove = (event: TouchEvent): void => {
-		if (event.touches.length === 1) {
+		if (1 === event.touches.length) {
 			this.onPointerMove(event.touches[0].clientX, event.touches[0].clientY)
 		}
 	}
 
 	private onTouchEnd = (): void => {
-		if (this.isTouchMode) this.onPointerUp()
+		if (this.isTouchMode) {this.onPointerUp()}
 	}
 
 	private onMouseDown = (event: MouseEvent): void => {
@@ -74,13 +74,13 @@ export default class TapDetector {
 	}
 
 	private onMouseMove = (event: MouseEvent): void => {
-		if (!this.isTouchMode && event.button === 0) {
+		if (!this.isTouchMode && 0 === event.button) {
 			this.onPointerMove(event.clientX, event.clientY)
 		}
 	}
 
 	private onMouseUp = (): void => {
-		if (!this.isTouchMode) this.onPointerUp()
+		if (!this.isTouchMode) {this.onPointerUp()}
 	}
 
 	private onPointerDown(x: number, y: number): void {
@@ -91,8 +91,8 @@ export default class TapDetector {
 
 	private onPointerUp(): void {
 		const currTimeStamp = Date.now()
-		if (this.touchMovedLength < 10) {
-			if (currTimeStamp - this.lastTapTimestamp < 300) {
+		if (10 > this.touchMovedLength) {
+			if (300 > currTimeStamp - this.lastTapTimestamp) {
 				this.tappedCount++
 			} else {
 				this.tappedCount = 1
@@ -101,7 +101,7 @@ export default class TapDetector {
 			this.lastTapTimestamp = currTimeStamp
 			this.triggerCallbacks('single', { clientX: this.lastPointerX, clientY: this.lastPointerY })
 
-			if (this.tappedCount === 2) {
+			if (2 === this.tappedCount) {
 				this.triggerCallbacks('double', { clientX: this.lastPointerX, clientY: this.lastPointerY })
 				this.tappedCount = 0
 			}

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 (result === null || result === undefined || typeof result !== 'object') {
+		if (null === result || result === undefined || 'object' !== typeof result) {
 			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 (stringValue.length === 0) return 0
+	if (0 === stringValue.length) {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 typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+	return 'string' === typeof value || 'number' === typeof value || 'boolean' === typeof value
 }
 
 /**
@@ -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 (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()
+	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()}
 	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 => term.length > 1)
+		.filter(term => 1 < term.length)
 
-	if (searchTerms.length === 0) return itemsArray
+	if (0 === searchTerms.length) {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 (typeof customWeight === 'number') {
+			if ('number' === typeof customWeight) {
 				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 || typeof obj !== 'object') return []
+		if (!obj || 'object' !== typeof obj) {return []}
 
 		return Object.keys(obj).flatMap((key) => {
 			const value = obj[key]
 			const newPrefix = prefix ? `${prefix}.${key}` : key
 
-			if (value && typeof value === 'object' && !Array.isArray(value)) {
+			if (value && 'object' === typeof value && !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 (value === null || value === undefined) continue
+			if (null === value || 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 (typeof value === 'object' && !isPrimitive(value)) {
+			if ('object' === typeof value && !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]) => score > 0)
+	const nonZeroItems = scoredItems.filter(([, score]) => 0 < score)
 
 	// Apply dynamic threshold based on score distribution
 	let filteredItems = nonZeroItems
-	if (nonZeroItems.length > 0) {
+	if (0 < nonZeroItems.length) {
 		const maxScore = Math.max(...nonZeroItems.map(([, score]) => score))
 
 		// If we have very high relevance items, filter out low relevance noise
-		if (maxScore > 5) {
+		if (5 < maxScore) {
 			// Items below 25% of max score are considered low relevance
 			const threshold = maxScore * 0.25
 			filteredItems = nonZeroItems.filter(([, score]) => score >= threshold)
-		} else if (maxScore > 2) {
+		} else if (2 < maxScore) {
 			// 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 = typeof paramsOrItems === 'function'
-	const isObject = typeof paramsOrItems === 'object' && paramsOrItems !== null
+	const isFunction = 'function' === typeof paramsOrItems
+	const isObject = 'object' === typeof paramsOrItems && null !== paramsOrItems 
 	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 (debounceTimeout !== null) {
+				if (null !== debounceTimeout) {
 					clearTimeout(debounceTimeout)
 				}
 
-				const term = typeof newTerm === 'string' ? newTerm : ''
+				const term = 'string' === typeof newTerm ? newTerm : ''
 
 				// Allow initial/default fetch when minChars === 0 (including empty term)
-				if (term.length < minChars && minChars > 0) {
+				if (term.length < minChars && 0 < minChars) {
 					serverResults.value = []
 					return
 				}
@@ -454,11 +454,11 @@ export function useSearch<T>(
 
 		// If using server-side search
 		if (serverSearch) {
-			if (term && typeof term === 'string' && term.length >= minChars) {
+			if (term && 'string' === typeof term && term.length >= minChars) {
 				return serverResults.value as T[]
 			}
 			// If minChars is 0, allow default server results when empty
-			if (minChars === 0) return serverResults.value as T[]
+			if (0 === minChars) {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(() => resultCount.value > 0)
+	const hasResults = computed(() => 0 < resultCount.value)
 	const isSearching = computed(() => {
 		const term = getSearchTermValue()
-		return !!term && typeof term === 'string' && term.length >= minChars
+		return !!term && 'string' === typeof term && term.length >= minChars
 	})
 
 	const result: SearchResult<T> = {

package/vite.config.ts

@@ -28,7 +28,7 @@ export default defineConfig(() => ({
 		lib: {
 			entry: resolve(indexDir, 'index.ts'),
 			formats: ['es', 'cjs'],
-			fileName: (module, entry) => `${entry}.${module === 'es' ? 'mjs' : module}`,
+			fileName: (module, entry) => `${entry}.${ 'es' === module ? 'mjs' : module}`,
 			cssFileName: 'style',
 		},
 		rollupOptions: {