jbrowse-plugin-msaview 2.10.0 → 2.10.2

package/src/utils/useFetch.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'vitest'
+
+import { serializeKey } from './useFetch'
+
+describe('serializeKey', () => {
+  test('a key identifies the fetch', () => {
+    expect(serializeKey('msa-list')).toBe(serializeKey('msa-list'))
+    expect(serializeKey(['NM_1', 'hg38'])).not.toBe(
+      serializeKey(['NM_1', 'mm39']),
+    )
+  })
+
+  test('no key means do not fetch', () => {
+    expect(serializeKey(null)).toBeNull()
+    expect(serializeKey(undefined)).toBeNull()
+    expect(serializeKey(false)).toBeNull()
+    expect(serializeKey('')).not.toBeNull()
+  })
+
+  test('an array key with a piece still missing means do not fetch', () => {
+    expect(serializeKey(['NM_1', undefined, 'feature-sequence'])).toBeNull()
+  })
+
+  // the trap this rule sets: a boolean IN a key reads as a missing piece, so a
+  // `!!selected` where a string belonged disables the fetch and raises nothing
+  test('a boolean in a key disables the fetch', () => {
+    expect(serializeKey(['gene', false])).toBeNull()
+    expect(serializeKey(['gene', true])).not.toBeNull()
+  })
+})

package/src/utils/useFetch.ts

@@ -0,0 +1,116 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+// A trimmed copy of jbrowse-components' `packages/core/src/util/useFetch.ts`,
+// vendored for the same reason `useLocalStorage` and `defaultCodonTable` are:
+// it does not exist in the @jbrowse/core this plugin builds against, and a
+// host-resolved import is exactly how published bundles have broken here
+// before. Our own copy takes this out of the whack-a-mole.
+//
+// Trimmed because this plugin has no RPC: the core version also carries stop
+// tokens, a throttled progress stream and a cross-component mutate registry,
+// and nothing here has ever wanted any of the three. What is left is the
+// {data, error, isLoading} the four call sites this replaced actually used --
+// they were on SWR, whose only feature we relied on was fetch-once-per-key with
+// background revalidation off, so dropping it also drops a dependency from the
+// UMD bundle.
+
+export type FetchKey = string | readonly unknown[] | null | undefined | false
+
+const isNil = (k: unknown) => k === null || k === undefined || k === false
+
+// A null result means "don't fetch": no key, or an array key with a missing
+// piece. Note what that makes of a boolean IN a key -- `false` reads as a
+// missing piece and silently disables the fetch, so put a string there.
+export function serializeKey(key: FetchKey): string | null {
+  return isNil(key) || (Array.isArray(key) && key.some(isNil))
+    ? null
+    : JSON.stringify(key)
+}
+
+interface Settled<Data> {
+  /** the key AND the attempt, so a mutate() refetch is a different entry */
+  attempt: string
+  /** the key alone, which is the question the data answers */
+  question: string
+  data?: Data
+  error?: unknown
+}
+
+/**
+ * Fetch once per key, keeping loading and error state with the data instead of
+ * spread across three `useState`s and a cancellation flag.
+ *
+ * Everything the caller reads is derived from the one settled result, which is
+ * what keeps the states consistent: while a key change is in flight there is no
+ * frame showing the previous key's data as though it were the new key's. A
+ * `mutate()` refetch under the same key does leave its data up, because it is
+ * the same question asked again and blanking it flashes an empty list.
+ */
+export function useFetch<Data>(
+  key: FetchKey,
+  fetcher: () => Promise<Data>,
+  { onSuccess }: { onSuccess?: (data: Data) => void } = {},
+) {
+  const serialized = serializeKey(key)
+  const [nonce, setNonce] = useState(0)
+  const [settled, setSettled] = useState<Settled<Data>>()
+
+  const attempt = serialized === null ? null : `${nonce}\u0000${serialized}`
+  const current = settled?.attempt === attempt
+  const answersThisKey = settled?.question === serialized
+
+  // The fetcher and the success callback are inline closures at every call site,
+  // so depending on their identity would refetch every render. This effect is
+  // declared before the fetch effect and has no dependency list, so it has
+  // already run with the current render's values by the time that one does.
+  const latest = useRef({ fetcher, onSuccess })
+  useEffect(() => {
+    latest.current = { fetcher, onSuccess }
+  })
+
+  useEffect(() => {
+    if (attempt === null || serialized === null) {
+      return undefined
+    }
+    let alive = true
+    latest.current
+      .fetcher()
+      .then(data => {
+        if (alive) {
+          setSettled({ attempt, question: serialized, data })
+          latest.current.onSuccess?.(data)
+        }
+      })
+      .catch((error: unknown) => {
+        if (alive) {
+          setSettled({ attempt, question: serialized, error })
+        }
+      })
+    return () => {
+      alive = false
+    }
+  }, [attempt, serialized])
+
+  return {
+    data: answersThisKey ? settled.data : undefined,
+    error: current ? settled.error : undefined,
+    isLoading: attempt !== null && !current,
+    mutate: useCallback(() => {
+      setNonce(n => n + 1)
+    }, []),
+  }
+}
+
+/** `value`, but only after it has stopped changing for `ms`. */
+export function useDebounced<T>(value: T, ms: number) {
+  const [debounced, setDebounced] = useState(value)
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebounced(value)
+    }, ms)
+    return () => {
+      clearTimeout(timer)
+    }
+  }, [value, ms])
+  return debounced
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = '2.10.0'
+export const version = '2.10.2'

package/dist/LaunchMsaView/components/useSWRFeatureSequence.d.ts

@@ -1,12 +0,0 @@
-import type { Feature } from '@jbrowse/core/util';
-export declare function useSWRFeatureSequence({ view, feature, }: {
-    view: {
-        assemblyNames?: string[];
-    } | undefined;
-    feature?: Feature;
-}): {
-    sequence: {
-        seq: string;
-    } | undefined;
-    error: any;
-};

package/dist/LaunchMsaView/components/useSWRFeatureSequence.js

@@ -1,25 +0,0 @@
-import { getSession } from '@jbrowse/core/util';
-import useSWR from 'swr';
-import { fetchSeq } from './fetchSeq';
-import { staticSwrConfig } from '../../utils/swrConfig';
-async function featureSequenceFetcher({ feature, assemblyName, view, }) {
-    const session = getSession(view);
-    const { start, end, refName } = feature.toJSON();
-    const seq = await fetchSeq({
-        start,
-        end,
-        refName,
-        assemblyName,
-        session,
-    });
-    return { seq };
-}
-export function useSWRFeatureSequence({ view, feature, }) {
-    const assemblyName = view?.assemblyNames?.[0];
-    const args = feature && assemblyName ? { feature, assemblyName, view } : undefined;
-    const { data, error } = useSWR(args ? [args.feature.id(), args.assemblyName, 'feature-sequence'] : null, () => featureSequenceFetcher(args), staticSwrConfig);
-    return {
-        sequence: data,
-        error,
-    };
-}

package/dist/utils/swrConfig.d.ts

@@ -1,8 +0,0 @@
-export declare const staticSwrConfig: {
-    revalidateOnFocus: boolean;
-    revalidateOnReconnect: boolean;
-    revalidateIfStale: boolean;
-    refreshWhenHidden: boolean;
-    refreshWhenOffline: boolean;
-    shouldRetryOnError: boolean;
-};

package/dist/utils/swrConfig.js

@@ -1,8 +0,0 @@
-export const staticSwrConfig = {
-    revalidateOnFocus: false,
-    revalidateOnReconnect: false,
-    revalidateIfStale: false,
-    refreshWhenHidden: false,
-    refreshWhenOffline: false,
-    shouldRetryOnError: false,
-};

package/src/LaunchMsaView/components/useSWRFeatureSequence.ts

@@ -1,54 +0,0 @@
-import { getSession } from '@jbrowse/core/util'
-import useSWR from 'swr'
-
-import { fetchSeq } from './fetchSeq'
-import { staticSwrConfig } from '../../utils/swrConfig'
-
-import type { Feature } from '@jbrowse/core/util'
-
-async function featureSequenceFetcher({
-  feature,
-  assemblyName,
-  view,
-}: {
-  feature: Feature
-  assemblyName: string
-  view: { assemblyNames?: string[] }
-}) {
-  const session = getSession(view)
-  const { start, end, refName } = feature.toJSON() as {
-    start: number
-    end: number
-    refName: string
-  }
-  const seq = await fetchSeq({
-    start,
-    end,
-    refName,
-    assemblyName,
-    session,
-  })
-  return { seq }
-}
-
-export function useSWRFeatureSequence({
-  view,
-  feature,
-}: {
-  view: { assemblyNames?: string[] } | undefined
-  feature?: Feature
-}) {
-  const assemblyName = view?.assemblyNames?.[0]
-  const args =
-    feature && assemblyName ? { feature, assemblyName, view } : undefined
-  const { data, error } = useSWR(
-    args ? [args.feature.id(), args.assemblyName, 'feature-sequence'] : null,
-    () => featureSequenceFetcher(args!),
-    staticSwrConfig,
-  )
-
-  return {
-    sequence: data,
-    error,
-  }
-}

package/src/utils/swrConfig.ts

@@ -1,8 +0,0 @@
-export const staticSwrConfig = {
-  revalidateOnFocus: false,
-  revalidateOnReconnect: false,
-  revalidateIfStale: false,
-  refreshWhenHidden: false,
-  refreshWhenOffline: false,
-  shouldRetryOnError: false,
-}