@jbrowse/core 2.17.0 → 2.18.0

package/util/color/index.js

@@ -6,44 +6,14 @@ exports.emphasize = emphasize;
 exports.makeContrasting = makeContrasting;
 const styles_1 = require("@mui/material/styles");
 const cssColorsLevel4_1 = require("./cssColorsLevel4");
-/**
- * Algorithmically pick a contrasting text color that will
- * be visible on top of the given background color. Either
- * black or white.
- *
- * @param color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(),
- *  hsl(), hsla(), or named color
- * @returns 'black' or 'white'
- */
 function contrastingTextColor(color) {
     const luminance = getLuminance(color);
     return luminance > 0.5 ? 'black' : 'white';
 }
-/**
- * The relative brightness of any point in a color space,
- * normalized to 0 for darkest black and 1 for lightest white.
- * Uses MUI's `getLuminance`, but adds support for named colors
- *
- * Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
- *
- * @param color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(),
- *  hsl(), hsla(), or named color
- * @returns The relative brightness of the color in the range 0 - 1
- */
 function getLuminance(color) {
     const convertedColor = (0, cssColorsLevel4_1.namedColorToHex)(color);
     return (0, styles_1.getLuminance)(convertedColor || color);
 }
-/**
- * Darken or lighten a color, depending on its luminance.
- * Light colors are darkened, dark colors are lightened.
- * Uses MUI's `emphasize`, but adds support for named colors
- *
- * @param color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(),
- * hsl(), hsla(), or named color
- * @param coefficient - multiplier in the range 0 - 1, defaults to 0.15
- * @returns A CSS color string. Hex input values are returned as rgb
- */
 function emphasize(color, coefficient = 0.15) {
     const convertedColor = (0, cssColorsLevel4_1.namedColorToHex)(color);
     return (0, styles_1.emphasize)(convertedColor || color, coefficient);

package/util/compositeMap.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// takes an array or Map or Set (anything iterable with values()) of Maps and
-// lets you query them as one Map
 class CompositeMap {
     constructor(submaps) {
         this.submaps = submaps;

package/util/dedupe.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dedupe = dedupe;
-// from https://github.com/seriousManual/dedupe/blob/master/LICENSE
 function dedupe(list, hasher = JSON.stringify) {
     const clone = [];
     const lookup = new Set();

package/util/formatFastaStrings.d.ts

@@ -2,18 +2,5 @@ export interface SeqChunk {
     header: string;
     seq: string;
 }
-/**
- * Returns sequence with new line every 80 characters
- * ref https://stackoverflow.com/a/51506718/2129219
- *
- * @param seqString -  string
- * @returns formatted sequence string
- */
 export declare function formatFastaLines(seqString: string): string;
-/**
- * Formats the sequences chunks into Fasta format
- *
- * @param chunks - array of seq chunks of the form `{ header: string, seq: string }`
- * @returns formatted sequence in fasta format
- */
 export declare function formatSeqFasta(chunks: SeqChunk[]): string;

package/util/formatFastaStrings.js

@@ -2,22 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatFastaLines = formatFastaLines;
 exports.formatSeqFasta = formatSeqFasta;
-/**
- * Returns sequence with new line every 80 characters
- * ref https://stackoverflow.com/a/51506718/2129219
- *
- * @param seqString -  string
- * @returns formatted sequence string
- */
 function formatFastaLines(seqString) {
     return seqString.replaceAll(/(.{1,80})/g, '$1\n').trimEnd();
 }
-/**
- * Formats the sequences chunks into Fasta format
- *
- * @param chunks - array of seq chunks of the form `{ header: string, seq: string }`
- * @returns formatted sequence in fasta format
- */
 function formatSeqFasta(chunks) {
     return chunks
         .map(chunk => `>${chunk.header}\n${formatFastaLines(chunk.seq)}`)

package/util/idMaker.d.ts

@@ -1 +1 @@
-export default function idMaker(args: any, id?: string): number;
+export default function idMaker(args: Record<string, unknown>, id?: string, len?: number): number;

package/util/idMaker.js

@@ -2,19 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = idMaker;
 const _1 = require("./");
-// generates a short "id fingerprint" from the config passed to the base
-// feature adapter by recursively enumerating props, but if config is too big
-// does not process entire config (FromConfigAdapter for example can be large)
-function idMaker(args, id = '') {
-    const keys = Object.keys(args);
-    for (const key of keys) {
-        if (id.length > 5000) {
-            break;
+function idMaker(args, id = '', len = 5000) {
+    const stack = [args];
+    while (stack.length) {
+        const obj = stack.pop();
+        for (const [key, val] of Object.entries(obj)) {
+            if (id.length > len) {
+                return (0, _1.hashCode)(id);
+            }
+            else {
+                if (typeof val === 'object' && val !== null) {
+                    stack.push(val);
+                }
+                else {
+                    id += `${key}-${val}`;
+                }
+            }
         }
-        id +=
-            typeof args[key] === 'object' && args[key]
-                ? idMaker(args[key], id)
-                : `${key}-${args[key]};`;
     }
     return (0, _1.hashCode)(id);
 }

package/util/index.d.ts

@@ -1,16 +1,14 @@
-import React from 'react';
-import PluginManager from '../PluginManager';
-import type { Buffer } from 'buffer';
-import { IAnyStateTreeNode, IStateTreeNode, Instance } from 'mobx-state-tree';
-import { IReactionPublic, IReactionOptions } from 'mobx';
-import { Feature } from './simpleFeature';
-import { AssemblyManager, Region, TypeTestedByPredicate } from './types';
+import type React from 'react';
+import type PluginManager from '../PluginManager';
+import type { BaseBlock } from './blockTypes';
+import type { Feature } from './simpleFeature';
+import type { AssemblyManager, Region, TypeTestedByPredicate } from './types';
 import type { Region as MUIRegion } from './types/mst';
-import { BaseBlock } from './blockTypes';
-import { GenericFilehandle } from 'generic-filehandle';
-import { BaseOptions } from '../data_adapters/BaseAdapter';
+import type { BaseOptions } from '../data_adapters/BaseAdapter';
+import type { Buffer } from 'buffer';
+import type { GenericFilehandle } from 'generic-filehandle';
+import type { IAnyStateTreeNode, IStateTreeNode, Instance } from 'mobx-state-tree';
 export * from './types';
-export * from './aborting';
 export * from './when';
 export * from './range';
 export * from './dedupe';
@@ -21,70 +19,13 @@ export declare function useWidthSetter(view: {
     setWidth: (arg: number) => void;
 }, padding: string): React.RefObject<HTMLDivElement>;
 export declare function useDebouncedCallback<T>(callback: (...args: T[]) => void, wait?: number): (...args: T[]) => void;
-/**
- * find the first node in the hierarchy that matches the given predicate
- */
 export declare function findParentThat(node: IAnyStateTreeNode, predicate: (thing: IAnyStateTreeNode) => boolean): IAnyStateTreeNode;
 export declare function springAnimate(fromValue: number, toValue: number, setValue: (value: number) => void, onFinish?: () => void, precision?: number, tension?: number, friction?: number, clamp?: boolean): (() => void)[];
-/**
- * find the first node in the hierarchy that matches the given 'is' typescript
- * type guard predicate
- */
 export declare function findParentThatIs<T extends (a: IAnyStateTreeNode) => boolean>(node: IAnyStateTreeNode, predicate: T): TypeTestedByPredicate<T>;
-/**
- * get the current JBrowse session model, starting at any node in the state
- * tree
- */
 export declare function getSession(node: IAnyStateTreeNode): import("./types").AbstractSessionModel;
-/**
- * get the state model of the view in the state tree that contains the given
- * node
- */
 export declare function getContainingView(node: IAnyStateTreeNode): import("./types").AbstractViewModel;
-/**
- * get the state model of the view in the state tree that contains the given
- * node
- */
 export declare function getContainingTrack(node: IAnyStateTreeNode): import("./types").AbstractTrackModel;
-/**
- * get the state model of the display in the state tree that contains the given
- * node
- */
 export declare function getContainingDisplay(node: IAnyStateTreeNode): import("./types").AbstractDisplayModel;
-/**
- * Assemble a 1-based "locString" from an interbase genomic location
- * @param region - Region
- * @example
- * ```ts
- * assembleLocString({ refName: 'chr1', start: 0, end: 100 })
- * // ↳ 'chr1:1..100'
- * ```
- * @example
- * ```ts
- * assembleLocString({ assemblyName: 'hg19', refName: 'chr1', start: 0, end: 100 })
- * // ↳ '{hg19}chr1:1..100'
- * ```
- * @example
- * ```ts
- * assembleLocString({ refName: 'chr1' })
- * // ↳ 'chr1'
- * ```
- * @example
- * ```ts
- * assembleLocString({ refName: 'chr1', start: 0 })
- * // ↳ 'chr1:1..'
- * ```
- * @example
- * ```ts
- * assembleLocString({ refName: 'chr1', end: 100 })
- * // ↳ 'chr1:1..100'
- * ```
- * @example
- * ```ts
- * assembleLocString({ refName: 'chr1', start: 0, end: 1 })
- * // ↳ 'chr1:1'
- * ```
- */
 export declare function assembleLocString(region: ParsedLocString): string;
 export declare function assembleLocStringFast(region: ParsedLocString, cb?: (n: number) => string | number): string;
 export interface ParsedLocString {
@@ -95,59 +36,10 @@ export interface ParsedLocString {
     reversed?: boolean;
 }
 export declare function parseLocStringOneBased(locString: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): ParsedLocString;
-/**
- * Parse a 1-based location string into an interbase genomic location
- * @param locString - Location string
- * @param isValidRefName - Function that checks if a refName exists in the set
- * of all known refNames, or in the set of refNames for an assembly if
- * assemblyName is given
- * @example
- * ```ts
- * parseLocString('chr1:1..100', isValidRefName)
- * // ↳ { refName: 'chr1', start: 0, end: 100 }
- * ```
- * @example
- * ```ts
- * parseLocString('chr1:1-100', isValidRefName)
- * // ↳ { refName: 'chr1', start: 0, end: 100 }
- * ```
- * @example
- * ```ts
- * parseLocString(`{hg19}chr1:1..100`, isValidRefName)
- * // ↳ { assemblyName: 'hg19', refName: 'chr1', start: 0, end: 100 }
- * ```
- * @example
- * ```ts
- * parseLocString('chr1', isValidRefName)
- * // ↳ { refName: 'chr1' }
- * ```
- * @example
- * ```ts
- * parseLocString('chr1:1', isValidRefName)
- * // ↳ { refName: 'chr1', start: 0, end: 1 }
- * ```
- * @example
- * ```ts
- * parseLocString('chr1:1..', isValidRefName)
- * // ↳ { refName: 'chr1', start: 0}
- * ```
- */
 export declare function parseLocString(locString: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): ParsedLocString;
 export declare function compareLocs(locA: ParsedLocString, locB: ParsedLocString): number;
 export declare function compareLocStrings(a: string, b: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): number;
-/**
- * Ensure that a number is at least min and at most max.
- *
- * @param num -
- * @param min -
- * @param  max -
- */
 export declare function clamp(num: number, min: number, max: number): number;
-/**
- * @param bp -
- * @param region -
- * @param bpPerPx -
- */
 export declare function bpToPx(bp: number, { reversed, end, start, }: {
     start?: number;
     end?: number;
@@ -155,15 +47,7 @@ export declare function bpToPx(bp: number, { reversed, end, start, }: {
 }, bpPerPx: number): number;
 export declare function radToDeg(radians: number): number;
 export declare function degToRad(degrees: number): number;
-/**
- * @returns [x, y]
- */
 export declare function polarToCartesian(rho: number, theta: number): [number, number];
-/**
- * @param x - the x
- * @param y - the y
- * @returns [rho, theta]
- */
 export declare function cartesianToPolar(x: number, y: number): [number, number];
 interface MinimalRegion {
     start: number;
@@ -173,45 +57,15 @@ interface MinimalRegion {
 export declare function featureSpanPx(feature: Feature, region: MinimalRegion, bpPerPx: number): readonly [number, number];
 export declare function bpSpanPx(leftBp: number, rightBp: number, region: MinimalRegion, bpPerPx: number): readonly [number, number];
 export declare function iterMap<T, U>(iter: Iterable<T>, func: (arg: T) => U, sizeHint?: number): U[];
-/**
- * Returns the index of the last element in the array where predicate is true,
- * and -1 otherwise. Based on https://stackoverflow.com/a/53187807
- *
- * @param array - The source array to search in
- *
- * @param predicate - find calls predicate once for each element of the array, in
- * descending order, until it finds one where predicate returns true.
- *
- * @returns findLastIndex returns element index where predicate is true.
- * Otherwise, findLastIndex returns -1.
- */
 export declare function findLastIndex<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): number;
 export declare function findLast<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): T | undefined;
-/**
- * makes a mobx reaction with the given functions, that calls actions on the
- * model for each stage of execution, and to abort the reaction function when
- * the model is destroyed.
- *
- * Will call startedFunction(signal), successFunction(result), and
- * errorFunction(error) when the async reaction function starts, completes, and
- * errors respectively.
- *
- * @param self -
- * @param dataFunction -
- * @param asyncReactionFunction -
- * @param reactionOptions -
- * @param startedFunction -
- * @param successFunction -
- * @param errorFunction -
- */
-export declare function makeAbortableReaction<T, U, V>(self: T, dataFunction: (arg: T) => U, asyncReactionFunction: (arg: U | undefined, signal: AbortSignal, model: T, handle: IReactionPublic) => Promise<V>, reactionOptions: IReactionOptions, startedFunction: (aborter: AbortController) => void, successFunction: (arg: V) => void, errorFunction: (err: unknown) => void): void;
 export declare function renameRegionIfNeeded(refNameMap: Record<string, string> | undefined, region: Region | Instance<typeof MUIRegion>): Region & {
     originalRefName?: string;
 };
 export declare function renameRegionsIfNeeded<ARGTYPE extends {
     assemblyName?: string;
     regions?: Region[];
-    signal?: AbortSignal;
+    stopToken?: string;
     adapterConfig: Record<string, unknown>;
     sessionId: string;
     statusCallback?: (arg: string) => void;
@@ -305,12 +159,9 @@ export declare const defaultCodonTable: {
     GGG: string;
     GGT: string;
 };
-/**
- * take CodonTable above and generate larger codon table that includes all
- * permutations of upper and lower case nucleotides
- */
 export declare function generateCodonTable(table: any): Record<string, string>;
 export declare function updateStatus<U>(msg: string, cb: (arg: string) => void, fn: () => U | Promise<U>): Promise<U>;
+export declare function updateStatus2<U>(msg: string, cb: (arg: string) => void, stopToken: string | undefined, fn: () => U | Promise<U>): Promise<U>;
 export declare function hashCode(str: string): number;
 export declare function objectHash(obj: Record<string, any>): string;
 interface VirtualOffset {
@@ -385,13 +236,12 @@ export declare function mergeIntervals<T extends {
     start: number;
     end: number;
 }>(intervals: T[], w?: number): T[];
-interface BasicFeature {
+export interface BasicFeature {
     end: number;
     start: number;
     refName: string;
-    assemblyName?: string;
 }
-export declare function gatherOverlaps(regions: BasicFeature[], w?: number): BasicFeature[];
+export declare function gatherOverlaps<T extends BasicFeature>(regions: T[], w?: number): T[];
 export declare function stripAlpha(str: string): string;
 export declare function getStrokeProps(str: string): {
     strokeOpacity: number;
@@ -406,5 +256,7 @@ export declare function renderToStaticMarkup(node: React.ReactElement, createRoo
 }): string;
 export declare function isGzip(buf: Buffer): boolean;
 export declare function fetchAndMaybeUnzip(loc: GenericFilehandle, opts?: BaseOptions): Promise<Buffer>;
-export { isFeature, default as SimpleFeature, type Feature, type SimpleFeatureSerialized, type SimpleFeatureSerializedNoId, } from './simpleFeature';
+export { type Feature, type SimpleFeatureSerialized, type SimpleFeatureSerializedNoId, default as SimpleFeature, isFeature, } from './simpleFeature';
 export { blobToDataURL } from './blobToDataURL';
+export { makeAbortableReaction } from './makeAbortableReaction';
+export * from './aborting';