@env-hopper/frontend-core 2.0.1-alpha

package/src/modules/fuzzyMatchLogic/autoCompleteFilter.ts

@@ -0,0 +1,186 @@
+import { Encoder, Index } from 'flexsearch'
+import { score } from './scoring'
+import type {
+  FuzzySearchContext,
+  FuzzySearchIndex,
+  FuzzySearchPrepareIndexParams,
+  FuzzySearchReturnItem,
+} from './types'
+
+export function makeFuzzySearchIndex(
+  params: FuzzySearchPrepareIndexParams,
+): FuzzySearchIndex {
+  const encoder = new Encoder({
+    // prepare
+    // normalize: true,
+    // dedupe: true,
+    // include: {
+    //   letter: true,
+    //   number: true,
+    //   symbol: true,
+    //   punctuation: true,
+    //   control: false,
+    // },
+    // finalize: (terms) => {
+    //   return terms
+    // },
+  })
+  const index = new Index({
+    tokenize: 'forward',
+    encoder: encoder,
+  })
+  params.entries.forEach((entry, idx) => {
+    index.add(idx, entry.displayName || entry.slug)
+    // index.add(idx, enrichTokensForIndex(tokenize(entry.displayName || entry.slug)).join(' '))
+  })
+  return {
+    flexIndex: index,
+    entries: params.entries,
+  }
+}
+
+export function fuzzySearch(
+  needle: string,
+  context: FuzzySearchContext,
+): Array<FuzzySearchReturnItem> {
+  const postFiltrationResults = context.index.flexIndex
+    .searchCache(needle)
+    .map((id) => {
+      return {
+        entry: context.index.entries[id as number]!,
+      }
+    })
+
+  // const tokenizedNeedle = tokenize(needle)
+
+  // const foundTokensByRows = new Map<number, FuzzySearchPreliminaryResult>()
+
+  // tokenizedNeedle.forEach((token) => {
+  //   const found = context.index.flexIndex.search(token)
+  //   ;(found as number[]).forEach((id) => {
+  //     let row = foundTokensByRows.get(id)
+  //     if (!row) {
+  //       row = {
+  //         entry: context.index.entries[id as number]!,
+  //         foundTokens: [token],
+  //       }
+  //       foundTokensByRows.set(id, row)
+  //     } else {
+  //       row.foundTokens.push(token)
+  //     }
+  //   })
+  // })
+
+  // const rawResults = [...foundTokensByRows.values()]
+  // const postFiltrationResults = postFiltration(rawResults)
+  return score(postFiltrationResults, needle)
+}
+
+// type IndexType = {
+//   title: string;
+//   titleOrig: string;
+//   tokens: string[];
+//   notFavorite: boolean;
+//   notRecent: boolean;
+//   item: SourceItem;
+// };
+
+// export function makeAutoCompleteFilter(
+//   items: SourceItem[],
+// ): EhAutoCompleteFilter {
+//   const itemsIndex: IndexType[] = items.map((item) => {
+//     const lower = item.title.toLowerCase();
+//     return {
+//       title: lower,
+//       titleOrig: item.title,
+//       tokens: tokenize(item.title),
+//       notFavorite: !item.favorite,
+//       notRecent: !item.recent,
+//       item,
+//     };
+//   });
+//   const recentFavWinSort = ['notFavorite', 'notRecent'];
+//   const shortestWinSort = (x: IndexType) => x.title.length;
+//   const sorts: Many<ListIteratee<IndexType>> = [
+//     ...recentFavWinSort,
+//     shortestWinSort,
+//   ];
+
+//   function doSearch(searchPatternOrig: string) {
+//     const searchPattern = searchPatternOrig.toLowerCase();
+//     const results = new Set<SourceItem>();
+
+//     // prefix match exact case sensitive
+//     const exactPrefix = sortBy(
+//       itemsIndex.filter((item) => item.titleOrig.startsWith(searchPatternOrig)),
+//       sorts,
+//     );
+//     exactPrefix.forEach((x) => results.add(x.item));
+
+//     // prefix case insensitive
+//     const caseRelaxedPrefix = sortBy(
+//       itemsIndex.filter((item) => item.title.startsWith(searchPattern)),
+//       sorts,
+//     );
+//     caseRelaxedPrefix.forEach((x) => results.add(x.item));
+
+//     // token prefix
+//     const searchTokens = tokenize(searchPattern);
+
+//     if (searchTokens.length > 0) {
+//       const prefixedInTokens = itemsIndex.filter((item) => {
+//         const isFound = searchTokens.reduce<string[] | false>(
+//           (itemTokens, searchToken) => {
+//             if (itemTokens !== false) {
+//               for (let i = 0; i < itemTokens.length; i++) {
+//                 if (itemTokens[i].startsWith(searchToken)) {
+//                   return itemTokens.slice(i + 1);
+//                 }
+//               }
+//             }
+//             return false;
+//           },
+//           item.tokens,
+//         );
+//         return isFound !== false;
+//       });
+
+//       sortBy(prefixedInTokens, sorts).forEach((x) => results.add(x.item));
+//     }
+
+//     // substring match (case sensitive)
+//     const exactSubstring = sortBy(
+//       itemsIndex.filter((item) => item.titleOrig.includes(searchPatternOrig)),
+//       sorts,
+//       (x) => x.titleOrig.indexOf(searchPatternOrig),
+//     );
+//     exactSubstring.forEach((x) => results.add(x.item));
+
+//     // substring match (case insensitive)
+//     const relaxSubstring = sortBy(
+//       itemsIndex.filter((item) => item.title.includes(searchPattern)),
+//       sorts,
+//       (x) => x.title.indexOf(searchPattern),
+//     );
+//     relaxSubstring.forEach((x) => results.add(x.item));
+
+//     itemsIndex
+//       .filter((item) => item.tokens.join('').includes(searchPattern))
+//       .forEach((x) => results.add(x.item));
+
+//     const searchString = searchTokens.join('');
+//     itemsIndex
+//       .filter((item) => item.tokens.join('').includes(searchString))
+//       .forEach((x) => results.add(x.item));
+
+//     return [...results];
+//   }
+
+//   return (searchPatternOrig: string) => {
+//     let results = doSearch(searchPatternOrig);
+//     if (results.length === 0 && isRuLayout(searchPatternOrig)) {
+//       results = doSearch(fixRuLayout(searchPatternOrig));
+//     }
+//     return results;
+//   };
+// }

package/src/modules/fuzzyMatchLogic/features/prefixFrac.ts

@@ -0,0 +1,13 @@
+import { longestCommonPrefix } from '../utils'
+
+export function prefixFrac(
+  needle: string,
+  candidate: string,
+  qLen: number,
+): number {
+  if (qLen === 0) {
+    return 0
+  }
+  const lcp = longestCommonPrefix(needle, candidate)
+  return lcp / qLen
+}

package/src/modules/fuzzyMatchLogic/features/prefixFracTokenMiddles.ts

@@ -0,0 +1,29 @@
+import { sum } from 'radashi'
+import { tokenize } from '../tokenize'
+import { longestCommonPrefix } from '../utils'
+import type { FuzzySearchInputEntry } from '../types'
+
+export function prefixFracAcrossTokens(
+  entry: FuzzySearchInputEntry,
+  needleTokens: Array<string>,
+): number {
+  const entryTokens = tokenize(entry.displayName)
+
+  const scores = []
+
+  for (let i = 0, j = 0; i < needleTokens.length && j < entryTokens.length; ) {
+    const needleToken = needleTokens[i]!
+    const entryToken = entryTokens[j]!
+
+    if (entryToken.includes(needleToken)) {
+      const lcp = longestCommonPrefix(entryToken, needleToken)
+      scores.push((1.0 * lcp) / entryToken.length)
+      i++
+      j++
+    } else {
+      j++
+    }
+  }
+
+  return needleTokens.length > 0 ? sum(scores) / needleTokens.length : 0
+}

package/src/modules/fuzzyMatchLogic/fixLayout.ts

@@ -0,0 +1,24 @@
+const En = "qwertyuiop[]asdfghjkl;'zxcvbnm,.",
+  Ru = 'йцукенгшщзхъфывапролджэячсмитьбю'
+
+const ruEnMap: Record<string, string> = [...Ru].reduce<Record<string, string>>(
+  (acc, ruChar, index) => {
+    const enChar = En[index]
+
+    if (enChar) {
+      acc[ruChar] = enChar
+      acc[ruChar.toUpperCase()] = enChar.toUpperCase()
+    }
+
+    return acc
+  },
+  {},
+)
+
+export function isRuLayout(text: string) {
+  return [...text].some((c) => Ru.includes(c))
+}
+
+export function fixRuLayout(text: string) {
+  return [...text].map((c) => ruEnMap[c] || c).join('')
+}

package/src/modules/fuzzyMatchLogic/postFiltration.ts

@@ -0,0 +1,35 @@
+import { normalize } from './utils'
+import type { FuzzySearchInputEntry } from './types'
+
+export function isTokensConsequent(
+  foundTokens: Array<string>,
+  entry: FuzzySearchInputEntry,
+): boolean {
+  const entryNormalized = normalize(entry.displayName)
+
+  for (let index = 0; index < entryNormalized.length; index++) {
+    const nextToken = foundTokens.shift()
+    if (nextToken === undefined) {
+      break
+    }
+
+    const nextIndex = entryNormalized.indexOf(nextToken, index)
+    if (nextIndex === -1) {
+      return false
+    }
+    index = nextIndex + nextToken.length - 1
+  }
+
+  return foundTokens.length === 0
+}
+
+// export function postFiltration(
+//   raw: Array<FuzzySearchPreliminaryResult>,
+// ): Array<FuzzySearchPreliminaryResult> {
+//   return raw.filter(({ entry, foundTokens }) => {
+//     if (foundTokens.length > 1 && !isTokensConsequent(foundTokens, entry)) {
+//       return false
+//     }
+//     return true
+//   })
+// }

package/src/modules/fuzzyMatchLogic/scoring.ts

@@ -0,0 +1,42 @@
+import { prefixFrac } from './features/prefixFrac'
+import type {
+  FuzzySearchPreliminaryResult,
+  FuzzySearchReturnItem,
+} from './types'
+
+const W = {
+  prefixFrac: 1.3,
+  prefixFracTokenMiddles: 0.1,
+}
+
+export function score(
+  raw: Array<FuzzySearchPreliminaryResult>,
+  needle: string,
+): Array<FuzzySearchReturnItem> {
+  const qLen = needle.length
+
+  const scored = raw.map(({ entry }) => {
+    const label = entry.displayName
+    const norm = label
+
+    const pf = prefixFrac(needle, norm, qLen)
+    // const pfTokens = prefixFracTokenMiddles(entry, foundTokens)
+
+    // const tc = tokenCoverage(qTokens, norm);
+    // const pb = positionBonus(q, norm, W.positionDecayAlpha);
+
+    let scoreValue = 0
+    scoreValue += W.prefixFrac * pf
+
+    return { entry, score: scoreValue }
+  })
+
+  // stable sort by score desc, then by displayName
+  scored.sort(
+    (a, b) =>
+      b.score - a.score ||
+      a.entry.displayName.localeCompare(b.entry.displayName),
+  )
+
+  return scored
+}

package/src/modules/fuzzyMatchLogic/tokenize.ts

@@ -0,0 +1,32 @@
+export function normalize(str: string): string {
+  const text = str.normalize('NFKD').replace(/[\u0300-\u036f]/g, '')
+  return text
+}
+
+const TOKEN_SPLIT = new RegExp(
+  [
+    String.raw`[\p{Z}\p{P}\p{S}]+`,
+    String.raw`(?<=\p{Nd})(?=\p{L})`,
+    String.raw`(?<=\p{L})(?=\p{Nd})`,
+    String.raw`(?<=[\p{Ll}\p{Nd}])(?=\p{Lu})`,
+    String.raw`(?<=\p{Lu})(?=\p{Lu}\p{Ll})`,
+  ].join('|'),
+  'u',
+)
+
+export function tokenize(str: string): Array<string> {
+  return str
+    .split(TOKEN_SPLIT)
+    .filter(Boolean)
+    .map((s) => s.toLowerCase())
+}
+
+export function enrichTokensForIndex(tokens: Array<string>): Array<string> {
+  const newTokens = tokens.flatMap((token) => {
+    if (token.startsWith('0')) {
+      return [token.replace(/^0+(?=[1-9])/, ''), token]
+    }
+    return [token]
+  })
+  return newTokens
+}

package/src/modules/fuzzyMatchLogic/types.ts

@@ -0,0 +1,33 @@
+import type { Index } from 'flexsearch'
+
+export interface FuzzySearchInputEntry {
+  slug: string
+  displayName: string
+}
+
+export interface FuzzySearchContext {
+  index: FuzzySearchIndex
+}
+
+export interface FuzzySearchIndex {
+  flexIndex: Index
+  entries: Array<FuzzySearchInputEntry>
+}
+
+export interface FuzzySearchIndexEntry {
+  inputEntry: FuzzySearchInputEntry
+  tokens: Array<string>
+}
+
+export interface FuzzySearchPrepareIndexParams {
+  entries: Array<FuzzySearchInputEntry>
+}
+
+export interface FuzzySearchPreliminaryResult {
+  entry: FuzzySearchInputEntry
+  // foundTokens: string[]
+}
+
+export interface FuzzySearchReturnItem {
+  entry: FuzzySearchInputEntry
+}

package/src/modules/fuzzyMatchLogic/utils.ts

@@ -0,0 +1,18 @@
+export function normalize(x: string): string {
+  // lower, NFKD, strip combining marks (accents), collapse spaces
+  return x
+    .toLowerCase()
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+export function longestCommonPrefix(a: string, b: string): number {
+  const n = Math.min(a.length, b.length)
+  let i = 0
+  while (i < n && a.charCodeAt(i) === b.charCodeAt(i)) {
+    i++
+  }
+  return i
+}

package/src/modules/pluginCore/PluginManagerContext.tsx

@@ -0,0 +1,107 @@
+import { objectify } from 'radashi'
+import { createContext, use, useCallback, useMemo, useState } from 'react'
+import { isEhPluginResourceJumpable } from './types'
+import type { ReactNode } from 'react'
+import type { PluginPageUrlAutocompleteItem } from '~/plugins/builtin/pageUrl/pageUrlTypes'
+import type { PartialRecord } from '~/types/utilityTypes'
+import type { ResourceJumpItem } from '../resourceJump/types'
+import type { PluginInterfaceForCore } from './makePluginManagerContext'
+import type {
+  EhPlugin,
+  EhPluginResouceJumpFactoryCtx,
+  PluginName,
+} from './types'
+
+export interface PluginManagerContextIface {
+  plugins: Array<EhPlugin>
+  interfaceForPlugins: PartialRecord<
+    PluginName,
+    PluginManagerInterfaceForPlugins
+  >
+  resouceJumpItems: PartialRecord<PluginName, Array<ResourceJumpItem>>
+  autocompleteFactoryItems: (
+    ctx: EhPluginResouceJumpFactoryCtx,
+  ) => Array<PluginPageUrlAutocompleteItem>
+}
+
+export interface PluginManagerInterfaceForPlugins {
+  setResouceJumps: (items: Array<ResourceJumpItem>) => void
+}
+
+const PluginManagerContext = createContext<
+  PluginManagerContextIface | undefined
+>(undefined)
+
+interface PluginManagerProviderProps {
+  children: ReactNode
+  plugins: Array<EhPlugin>
+  pluginInterfaceForCore: PluginInterfaceForCore
+}
+
+export function PluginManagerContextProvider({
+  children,
+  plugins,
+}: PluginManagerProviderProps) {
+  const [resouceJumpItems, setResouceJumpsItems] = useState<
+    PartialRecord<PluginName, Array<ResourceJumpItem>>
+  >({})
+
+  const autocompleteFactoryItems = useCallback(
+    (
+      ctx: EhPluginResouceJumpFactoryCtx,
+    ): Array<PluginPageUrlAutocompleteItem> => {
+      return plugins
+        .filter((p) => isEhPluginResourceJumpable(p))
+        .flatMap((plugin) => plugin.factoryPageJumpAutocompleteItems(ctx))
+    },
+    [plugins],
+  )
+
+  const value: PluginManagerContextIface = useMemo(() => {
+    return {
+      plugins,
+      interfaceForPlugins: objectify(
+        plugins.map((p) => p.name),
+        (pluginName) => pluginName,
+        (pluginName) => ({
+          setResouceJumps: (items: Array<ResourceJumpItem>) => {
+            setResouceJumpsItems((old) => ({
+              ...old,
+              ...{ [pluginName]: items },
+            }))
+          },
+        }),
+      ),
+      autocompleteFactoryItems,
+      resouceJumpItems,
+    }
+  }, [autocompleteFactoryItems, plugins, resouceJumpItems])
+
+  return <PluginManagerContext value={value}>{children}</PluginManagerContext>
+}
+
+export function usePluginManager(): PluginManagerContextIface {
+  const context = use(PluginManagerContext)
+  if (context === undefined) {
+    throw new Error(
+      'usePluginManager must be used within an PluginManagerContextProvider',
+    )
+  }
+  return context
+}
+
+export function usePluginManagerForPlugin(
+  pluginName: PluginName,
+): PluginManagerInterfaceForPlugins {
+  const context = usePluginManager()
+
+  const interfaceForPlugins = context.interfaceForPlugins[pluginName]
+
+  if (interfaceForPlugins === undefined) {
+    throw new Error(
+      `usePluginManagerForPlugin("${pluginName}") is not initialized.`,
+    )
+  }
+
+  return interfaceForPlugins
+}

package/src/modules/pluginCore/makePluginManagerContext.ts

@@ -0,0 +1,35 @@
+import { objectify } from 'radashi'
+import { isEhPluginResourceJumpable } from './types'
+import type { EhPlugin } from './types'
+import type { BootstrapConfigData } from '@env-hopper/backend-core'
+import type { ResourceJumpItem } from '../resourceJump/types'
+
+export interface PluginInterfaceForCore {
+  getResourceJumpsItems: (
+    config: BootstrapConfigData,
+  ) => Promise<Record<string, ResourceJumpItem>>
+}
+
+export function makePluginInterfaceForCore(
+  plugins: Array<EhPlugin>,
+): PluginInterfaceForCore {
+  return {
+    getResourceJumpsItems: async (bootstrapConfig: BootstrapConfigData) => {
+      const items = await Promise.all(
+        plugins.map((plugin) => {
+          if (isEhPluginResourceJumpable(plugin)) {
+            return plugin.factoryPageJumpAutocompleteItems({
+              bootstrapConfig,
+            })
+          }
+          return []
+        }),
+      )
+      return objectify(
+        items.flat(),
+        (item) => item.slug,
+        (item) => item,
+      )
+    },
+  }
+}

package/src/modules/pluginCore/types.ts

@@ -0,0 +1,54 @@
+import type {
+  BootstrapConfigData,
+  EhEnvIndexed,
+} from '@env-hopper/backend-core'
+import type { PluginPageUrlAutocompleteItem } from '~/plugins/builtin/pageUrl/pageUrlTypes'
+
+export interface PluginAsyncData<T> {
+  pluginName: string
+  data: T
+  isLoaded: boolean
+}
+
+export interface EhPluginResourceJumpable extends EhPlugin {
+  factoryPageJumpAutocompleteItems: (
+    ctx: EhPluginResouceJumpFactoryCtx,
+  ) => Array<PluginPageUrlAutocompleteItem>
+}
+
+export interface EhPlugin {
+  name: PluginName
+  // populatePageJumpItems(): Promise<ResouceJumpItem[]>
+}
+
+export function isEhPluginResourceJumpable(
+  plugin: EhPlugin,
+): plugin is EhPluginResourceJumpable {
+  return 'factoryPageJumpAutocompleteItems' in plugin
+}
+export interface BaseAppAutoCompletableParent {
+  type: string
+  displayName: string
+  hasSingleChild: boolean
+}
+export interface BaseAutoCompletableItem {
+  type: string
+  slug: string
+  parent?: BaseAppAutoCompletableParent
+}
+
+export interface BaseAutoCompleteItemRender {
+  displayName: string
+  parentDisplayName?: string
+  isDefaultGroupItem?: boolean
+}
+
+export interface EhPluginResouceJumpFactoryCtx {
+  bootstrapConfig: BootstrapConfigData
+}
+
+export interface EhPluginResouceJumpCtx {
+  env: EhEnvIndexed | undefined
+}
+
+export type PluginName = string

package/src/modules/resourceJump/ApiQueryMagazineResourceJump.ts

@@ -0,0 +1,31 @@
+import { queryOptions } from '@tanstack/react-query'
+import type {
+  AvailiabilityMatrixData,
+  RenameRule,
+  RenameRuleParams,
+  ResourceJumpsData,
+} from '@env-hopper/backend-core'
+import { getTrpcFromMeta } from '~/util/reactQueryUtils'
+
+export class ApiQueryMagazineResouceJump {
+  static getNameMigration(params: RenameRuleParams) {
+    return queryOptions<RenameRule | false, Error>({
+      queryKey: ['nameMigrations'],
+      queryFn: (ctx) => getTrpcFromMeta(ctx).tryFindRenameRule.query(params),
+    })
+  }
+
+  static getAvailabilityMatrix() {
+    return queryOptions<AvailiabilityMatrixData, Error>({
+      queryKey: ['availabilityMatrix'],
+      queryFn: (ctx) => getTrpcFromMeta(ctx).availabilityMatrix.query(),
+    })
+  }
+
+  static getResourceJumps() {
+    return queryOptions<ResourceJumpsData, Error>({
+      queryKey: ['resourceJumps'],
+      queryFn: (ctx) => getTrpcFromMeta(ctx).resourceJumps.query(),
+    })
+  }
+}