hevy-shared 1.0.698 → 1.0.700

package/built/filterExercises.d.ts

@@ -1,3 +1,4 @@
+import Fuse from 'fuse.js';
 import { EquipmentFilter, Language, LibraryExercise, MuscleGroupFilter, CustomExercise } from './index';
 export interface SearchableLibraryExercise extends LibraryExercise {
     localized_muscle_group_name: string;
@@ -20,6 +21,11 @@ interface FilterExercisesProps {
     searchText: string;
     language: Language;
 }
+export declare const createFuseInstance: () => Fuse<string>;
+export declare const newFilterExercises: ({ fuseInstance, exercises, muscleGroupFilter, equipmentType, searchText, language, muscleGroupMatchPenalty, }: FilterExercisesProps & {
+    muscleGroupMatchPenalty: number;
+    fuseInstance: Fuse<string>;
+}) => SearchableExerciseTemplateWithStringScore[];
 export declare const filterExercises: ({ exercises, muscleGroupFilter, equipmentType, searchText, language, }: FilterExercisesProps) => (CustomExercise | LibraryExercise)[];
 /**
  * Exercise templates that are shown at the top of the Exercise Library to

package/built/filterExercises.js

@@ -1,8 +1,31 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.popularExerciseTemplateIds = exports.filterExercises = void 0;
+exports.popularExerciseTemplateIds = exports.filterExercises = exports.newFilterExercises = exports.createFuseInstance = void 0;
+const fuse_js_1 = __importDefault(require("fuse.js"));
 const utils_1 = require("./utils");
 const lodash_1 = require("lodash");
+const createFuseInstance = () => {
+    const stringSimilarityFuseInstance = new fuse_js_1.default([''], {
+        includeScore: true,
+        threshold: 0.4,
+        location: 0, // Prefer matches at the beginning of the string
+    });
+    return stringSimilarityFuseInstance;
+};
+exports.createFuseInstance = createFuseInstance;
+const newFilterExercises = ({ fuseInstance, exercises, muscleGroupFilter, equipmentType, searchText, language, muscleGroupMatchPenalty, }) => {
+    let result = exercises;
+    result = filterExercisesWithMuscleGroup(muscleGroupFilter, result);
+    result = filterExercisesWithEquipment(equipmentType, result);
+    const normalizedSearchText = normalizeSearchText(searchText, language);
+    result = newFilterExercisesWithSearchText(fuseInstance, normalizedSearchText, result, language, muscleGroupMatchPenalty);
+    result = orderExercisesWithSearchText(normalizedSearchText, result);
+    return result;
+};
+exports.newFilterExercises = newFilterExercises;
 const filterExercises = ({ exercises, muscleGroupFilter, equipmentType, searchText, language, }) => {
     let result = exercises;
     result = filterExercisesWithMuscleGroup(muscleGroupFilter, result);
@@ -25,6 +48,25 @@ const filterExercisesWithEquipment = (equipmentType, exercises) => {
     }
     return exercises.filter((rd) => rd.equipment_category === equipmentType);
 };
+const fuseScoreToSimilarity = (score) => {
+    if (score === 0)
+        return 'exact';
+    if (score < 0.05)
+        return 'extremely-similar';
+    if (score < 0.3)
+        return 'very-similar';
+    if (score < 0.6)
+        return 'somewhat-similar';
+    return 'not-similar';
+};
+const getStringSimilarityScore = (searchString, targetString, fuseInstance) => {
+    var _a, _b;
+    fuseInstance.setCollection([targetString]);
+    const result = fuseInstance.search(searchString);
+    const score = (_b = (_a = result[0]) === null || _a === void 0 ? void 0 : _a.score) !== null && _b !== void 0 ? _b : 1.0;
+    return score;
+};
+// Old filter exercise functionality, will be removed when new feature goes live
 const filterExercisesWithSearchText = (searchText, exercises, language) => {
     if (searchText.length === 0) {
         return exercises;
@@ -84,6 +126,89 @@ const filterExercisesWithSearchText = (searchText, exercises, language) => {
         return false;
     });
 };
+const newFilterExercisesWithSearchText = (fuseInstance, searchText, exercises, language, 
+// 0 means no penalty, 1 means don't match muscle groups (because a score > 1 means no match)
+muscleGroupMatchPenalty) => {
+    if (searchText.length === 0) {
+        return exercises;
+    }
+    return exercises.reduce((accu, e) => {
+        const searchableSearchText = searchable(searchText);
+        const searchableEnglishTitle = searchable(e.title);
+        const searchableLocalizedTitleMap = !e.is_custom
+            ? {
+                en: searchable(e.title),
+                es: e.es_title ? searchable(e.es_title) : undefined,
+                de: e.de_title ? searchable(e.de_title) : undefined,
+                fr: e.fr_title ? searchable(e.fr_title) : undefined,
+                it: e.it_title ? searchable(e.it_title) : undefined,
+                pt: e.pt_title ? searchable(e.pt_title) : undefined,
+                tr: e.tr_title ? searchable(e.tr_title) : undefined,
+                zh_CN: e.zh_cn_title ? searchable(e.zh_cn_title) : undefined,
+                zh_TW: e.zh_tw_title ? searchable(e.zh_tw_title) : undefined,
+                ru: e.ru_title ? searchable(e.ru_title) : undefined,
+                ja: e.ja_title ? searchable(e.ja_title) : undefined,
+                ko: e.ko_title ? searchable(e.ko_title) : undefined,
+            }
+            : {
+                en: searchable(e.title),
+            };
+        const searchableLocalizedTitle = searchableLocalizedTitleMap[language] || searchableLocalizedTitleMap.en;
+        const searchableLocalizedMuscleGroupName = searchable(e.localized_muscle_group_name);
+        const searchableMuscleGroup = searchable(e.muscle_group);
+        const searchableMisspelledDumbbellEquipment = e.equipment_category === 'dumbbell' ? 'dumbell' : '';
+        const searchableTags = !e.is_custom && e.manual_tag ? searchable(e.manual_tag) : '';
+        const searchableAka = !e.is_custom && e.aka ? searchable(e.aka) : '';
+        const englishSimilarityScore = getStringSimilarityScore(searchableSearchText, searchableEnglishTitle, fuseInstance);
+        const localizedSimilarityScore = getStringSimilarityScore(searchableSearchText, searchableLocalizedTitle, fuseInstance);
+        let englishMuscleGroupSimilarityScore = 1;
+        let muscleGroupSimilarityScore = 1;
+        if (muscleGroupMatchPenalty < 1) {
+            englishMuscleGroupSimilarityScore = getStringSimilarityScore(searchableSearchText, searchableMuscleGroup, fuseInstance);
+            muscleGroupSimilarityScore = getStringSimilarityScore(searchableSearchText, searchableLocalizedMuscleGroupName, fuseInstance);
+        }
+        // We always return the best score, regardless of where the match happens
+        const bestScore = Math.min(englishSimilarityScore, localizedSimilarityScore, englishMuscleGroupSimilarityScore + muscleGroupMatchPenalty, muscleGroupSimilarityScore + muscleGroupMatchPenalty);
+        if (fuseScoreToSimilarity(englishSimilarityScore) !== 'not-similar') {
+            accu.push(Object.assign(Object.assign({}, e), { searchStringScore: bestScore }));
+            return accu;
+        }
+        if (fuseScoreToSimilarity(localizedSimilarityScore) !== 'not-similar') {
+            accu.push(Object.assign(Object.assign({}, e), { searchStringScore: bestScore }));
+            return accu;
+        }
+        if (['exact', 'extremely-similar'].includes(fuseScoreToSimilarity(englishMuscleGroupSimilarityScore))) {
+            accu.push(Object.assign(Object.assign({}, e), { searchStringScore: bestScore }));
+            return accu;
+        }
+        if (['exact', 'extremely-similar'].includes(fuseScoreToSimilarity(muscleGroupSimilarityScore))) {
+            accu.push(Object.assign(Object.assign({}, e), { searchStringScore: bestScore }));
+            return accu;
+        }
+        if (e.is_custom && 'custom'.includes(searchableSearchText)) {
+            accu.push(e);
+            return accu;
+        }
+        const splitSearch = searchableSearchText.split(' ');
+        const splitTitle = [
+            searchableLocalizedTitle,
+            searchableEnglishTitle,
+            searchableTags,
+            searchableAka,
+            searchableMisspelledDumbbellEquipment,
+        ]
+            .join(' ')
+            .split(' ');
+        // Find:
+        // title ['arnold', 'press', '(barbell)']
+        // search ['press', 'bar']
+        if ((0, lodash_1.intersectionWith)(splitSearch, splitTitle, (search, title) => title.includes(search)).length === splitSearch.length) {
+            accu.push(e);
+            return accu;
+        }
+        return accu;
+    }, []);
+};
 const orderExercisesWithSearchText = (searchText, exercises) => {
     if (searchText.length === 0) {
         return exercises;

package/built/typeUtils.d.ts

@@ -30,3 +30,8 @@ export type Some<T> = {
  * ```
  */
 export declare const dangerousUncheckedTypeCast: <T = void, U extends T = T>(value: unknown) => U;
+/**
+ * Same as `array[index]`, but adds `undefined` to the return type. Maybe some
+ * fine day we will enable `noUncheckedIndexedAccess` in all our projects. 🤞
+ */
+export declare const typeSafeIndex: <T>(array: T[], index: number) => T | undefined;

package/built/typeUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dangerousUncheckedTypeCast = exports.exhaustiveTypeException = exports.exhaustiveTypeCheck = exports.isInArray = void 0;
+exports.typeSafeIndex = exports.dangerousUncheckedTypeCast = exports.exhaustiveTypeException = exports.exhaustiveTypeCheck = exports.isInArray = void 0;
 const isInArray = (value, array) => array.includes(value);
 exports.isInArray = isInArray;
 const exhaustiveTypeCheck = (_) => void _;
@@ -30,3 +30,9 @@ exports.exhaustiveTypeException = exhaustiveTypeException;
  */
 const dangerousUncheckedTypeCast = (value) => value;
 exports.dangerousUncheckedTypeCast = dangerousUncheckedTypeCast;
+/**
+ * Same as `array[index]`, but adds `undefined` to the return type. Maybe some
+ * fine day we will enable `noUncheckedIndexedAccess` in all our projects. 🤞
+ */
+const typeSafeIndex = (array, index) => array[index];
+exports.typeSafeIndex = typeSafeIndex;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hevy-shared",
-  "version": "1.0.698",
+  "version": "1.0.700",
   "description": "",
   "main": "built/index.js",
   "types": "built/index.d.ts",
@@ -35,6 +35,7 @@
     "typescript": "5.8.2"
   },
   "dependencies": {
+    "fuse.js": "^7.0.0",
     "lodash": "^4.17.21"
   }
 }