@jbrowse/core 3.7.0 → 4.0.0

package/esm/util/map-obj/index.js

@@ -0,0 +1,92 @@
+export const mapObjectSkip = Symbol('mapObjectSkip');
+const isObject = (value) => typeof value === 'object' && value !== null;
+const isObjectCustom = (value) => {
+    if (!isObject(value)) {
+        return false;
+    }
+    if (value instanceof RegExp ||
+        value instanceof Error ||
+        value instanceof Date ||
+        value instanceof Map ||
+        value instanceof Set ||
+        value instanceof WeakMap ||
+        value instanceof WeakSet ||
+        value instanceof Promise ||
+        value instanceof ArrayBuffer ||
+        value instanceof DataView ||
+        ArrayBuffer.isView(value) ||
+        (globalThis.Blob && value instanceof globalThis.Blob)) {
+        return false;
+    }
+    const v = value;
+    if (typeof v.$$typeof === 'symbol' ||
+        typeof v.asymmetricMatch === 'function') {
+        return false;
+    }
+    return true;
+};
+const getEnumerableKeys = (object, includeSymbols) => {
+    if (includeSymbols) {
+        const stringKeys = Object.keys(object);
+        const symbolKeys = Object.getOwnPropertySymbols(object).filter(symbol => Object.getOwnPropertyDescriptor(object, symbol)?.enumerable);
+        return [...stringKeys, ...symbolKeys];
+    }
+    return Object.keys(object);
+};
+const _mapObject = (object, mapper, options, isSeen = new WeakMap()) => {
+    const { target = {}, deep = false, includeSymbols = false } = options ?? {};
+    const processOptions = { deep, includeSymbols };
+    if (isSeen.has(object)) {
+        return isSeen.get(object);
+    }
+    isSeen.set(object, target);
+    const mapArray = (array) => array.map(element => isObjectCustom(element)
+        ? _mapObject(element, mapper, processOptions, isSeen)
+        : element);
+    if (Array.isArray(object)) {
+        return mapArray(object);
+    }
+    for (const key of getEnumerableKeys(object, processOptions.includeSymbols)) {
+        const value = object[key];
+        const mapResult = mapper(key, value, object);
+        if (mapResult === mapObjectSkip) {
+            continue;
+        }
+        if (!Array.isArray(mapResult)) {
+            throw new TypeError(`Mapper must return an array or mapObjectSkip, got ${mapResult === null ? 'null' : typeof mapResult}`);
+        }
+        if (mapResult.length < 2) {
+            throw new TypeError(`Mapper must return an array with at least 2 elements [key, value], got ${mapResult.length} elements`);
+        }
+        let [newKey, newValue, { shouldRecurse = true } = {}] = mapResult;
+        if (newKey === '__proto__') {
+            continue;
+        }
+        if (processOptions.deep && shouldRecurse && isObjectCustom(newValue)) {
+            newValue = (Array.isArray(newValue)
+                ? mapArray(newValue)
+                : _mapObject(newValue, mapper, processOptions, isSeen));
+        }
+        try {
+            ;
+            target[newKey] = newValue;
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message.includes('read only')) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    return target;
+};
+export default function mapObject(object, mapper, options) {
+    if (!isObject(object)) {
+        throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
+    }
+    if (Array.isArray(object)) {
+        throw new TypeError('Expected an object, got an array');
+    }
+    const mapperWithRoot = (key, value) => mapper(key, value, object);
+    return _mapObject(object, mapperWithRoot, options);
+}

package/esm/util/mst-reflection.d.ts

@@ -0,0 +1,11 @@
+import type { IAnyComplexType, IAnyType, IModelReflectionPropertiesData, ISimpleType, UnionStringArray } from '@jbrowse/mobx-state-tree';
+export interface ILiteralType<T> extends ISimpleType<T> {
+    value: T;
+}
+export declare function getSubType(type: IAnyType): IAnyType;
+export declare function getUnionSubTypes(unionType: IAnyType): IAnyType[];
+export declare function getPropertyType(type: IModelReflectionPropertiesData, propertyName: string): IAnyType;
+export declare function getDefaultValue(type: IAnyType): any;
+export type IEnumerationType<T extends string> = ISimpleType<UnionStringArray<T[]>>;
+export declare function getEnumerationValues(type: IAnyComplexType): string[];
+export declare function resolveLateType(maybeLate: IAnyType): any;

package/esm/util/mst-reflection.js

@@ -0,0 +1,54 @@
+import { isArrayType, isLateType, isMapType, isOptionalType, isUnionType, } from '@jbrowse/mobx-state-tree';
+export function getSubType(type) {
+    let t;
+    if (isOptionalType(type)) {
+        t = type._subtype || type.type;
+    }
+    else if (isArrayType(type) || isMapType(type)) {
+        t = type._subtype || type._subType || type.subType;
+    }
+    else if (typeof type.getSubType === 'function') {
+        return type.getSubType();
+    }
+    else {
+        throw new TypeError('unsupported mst type');
+    }
+    if (!t) {
+        throw new Error('failed to get subtype');
+    }
+    return t;
+}
+export function getUnionSubTypes(unionType) {
+    if (!isUnionType(unionType)) {
+        throw new TypeError('not an MST union type');
+    }
+    const t = unionType._types ||
+        unionType.types ||
+        getSubType(unionType)._types ||
+        getSubType(unionType).types;
+    if (!t) {
+        throw new Error('failed to extract subtypes from mst union');
+    }
+    return t;
+}
+export function getPropertyType(type, propertyName) {
+    return type.properties[propertyName];
+}
+export function getDefaultValue(type) {
+    if (!isOptionalType(type)) {
+        throw new TypeError('type must be an optional type');
+    }
+    return type._defaultValue || type.defaultValue;
+}
+export function getEnumerationValues(type) {
+    const subtypes = getUnionSubTypes(type);
+    return subtypes.map(t => t.value);
+}
+export function resolveLateType(maybeLate) {
+    if (!isUnionType(maybeLate) &&
+        !isArrayType(maybeLate) &&
+        isLateType(maybeLate)) {
+        return maybeLate.getSubType();
+    }
+    return maybeLate;
+}

package/esm/util/nanoid.d.ts

@@ -0,0 +1,5 @@
+export declare const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+export declare const random: (bytes: number) => Uint8Array<ArrayBuffer>;
+export declare const customRandom: (alphabet: string, defaultSize: number, getRandom: (bytes: number) => Uint8Array) => (size?: number) => string;
+export declare const customAlphabet: (alphabet: string, size?: number) => (size?: number) => string;
+export declare const nanoid: (size?: number) => string;

package/esm/util/nanoid.js

@@ -0,0 +1,36 @@
+export const urlAlphabet = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+export const random = (bytes) => crypto.getRandomValues(new Uint8Array(bytes));
+export const customRandom = (alphabet, defaultSize, getRandom) => {
+    const mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1;
+    const step = -~((1.6 * mask * defaultSize) / alphabet.length);
+    return (size = defaultSize) => {
+        let id = '';
+        while (true) {
+            const bytes = getRandom(step);
+            let j = step;
+            while (j--) {
+                id += alphabet[bytes[j] & mask] || '';
+                if (id.length === size) {
+                    return id;
+                }
+            }
+        }
+    };
+};
+export const customAlphabet = (alphabet, size = 21) => customRandom(alphabet, size, random);
+export const nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+    byte &= 63;
+    if (byte < 36) {
+        id += byte.toString(36);
+    }
+    else if (byte < 62) {
+        id += (byte - 26).toString(36).toUpperCase();
+    }
+    else if (byte > 62) {
+        id += '-';
+    }
+    else {
+        id += '_';
+    }
+    return id;
+}, '');

package/esm/util/nextTick.js

@@ -0,0 +1,3 @@
+export default function nextTickMod() {
+    return new Promise(resolve => requestAnimationFrame(resolve) || setTimeout(resolve, 1));
+}

package/esm/util/offscreenCanvasGetSerializingSvg.d.ts

@@ -0,0 +1,5 @@
+export declare function getSerializedSvg(results: {
+    width: number;
+    height: number;
+    canvasRecordedData: unknown;
+}): Promise<string>;

package/esm/util/offscreenCanvasGetSerializingSvg.js

@@ -0,0 +1,9 @@
+import { CanvasSequence } from 'canvas-sequencer-ts';
+export async function getSerializedSvg(results) {
+    const { width, height, canvasRecordedData } = results;
+    const C2S = await import('canvas2svg');
+    const ctx = new C2S.default(width, height);
+    const seq = new CanvasSequence(canvasRecordedData);
+    seq.execute(ctx);
+    return ctx.getSvg().innerHTML;
+}

package/esm/util/offscreenCanvasPonyfill.d.ts

@@ -0,0 +1,5 @@
+export { collectTransferables, isDetachedBuffer } from './transferables.ts';
+export declare function isImageBitmap(value: unknown): value is ImageBitmap;
+export declare function drawImageOntoCanvasContext(imageData: any, context: CanvasRenderingContext2D): void;
+export declare function createCanvas(width: number, height: number): any;
+export declare function createImageBitmap(canvas: any): Promise<unknown>;

package/esm/util/offscreenCanvasPonyfill.js

@@ -0,0 +1,57 @@
+import { CanvasSequence } from 'canvas-sequencer-ts';
+import isNode from 'detect-node';
+export { collectTransferables, isDetachedBuffer } from "./transferables.js";
+export function isImageBitmap(value) {
+    return typeof ImageBitmap !== 'undefined' && value instanceof ImageBitmap;
+}
+export function drawImageOntoCanvasContext(imageData, context) {
+    if (imageData.serializedCommands) {
+        const seq = new CanvasSequence(imageData.serializedCommands);
+        seq.execute(context);
+    }
+    else {
+        context.drawImage(imageData, 0, 0);
+    }
+}
+export function createCanvas(width, height) {
+    if (typeof OffscreenCanvas === 'function') {
+        return new OffscreenCanvas(width, height);
+    }
+    else if (isNode) {
+        return nodeCreateCanvas(width, height);
+    }
+    else {
+        const context = new CanvasSequence();
+        return {
+            width,
+            height,
+            getContext() {
+                return context;
+            },
+        };
+    }
+}
+export async function createImageBitmap(canvas) {
+    if (typeof OffscreenCanvas === 'function') {
+        return canvas.transferToImageBitmap();
+    }
+    else if (isNode) {
+        const dataUri = canvas.toDataURL();
+        const img = new nodeImage();
+        return new Promise((resolve, reject) => {
+            img.onload = () => {
+                resolve(img);
+            };
+            img.onerror = reject;
+            img.src = dataUri;
+        });
+    }
+    else {
+        const ctx = canvas.getContext('2d');
+        return {
+            height: canvas.height,
+            width: canvas.width,
+            serializedCommands: ctx.toJSON(),
+        };
+    }
+}

package/esm/util/offscreenCanvasUtils.d.ts

@@ -0,0 +1,12 @@
+export { renderToAbstractCanvas } from './renderToAbstractCanvas.ts';
+export declare function ReactRendering({ rendering, }: {
+    rendering: {
+        reactElement?: React.ReactNode;
+        html?: string;
+    };
+}): import("react/jsx-runtime").JSX.Element;
+export { getSerializedSvg } from './offscreenCanvasGetSerializingSvg.ts';
+export declare function renderingToSvg<T extends {
+    canvasRecordedData?: unknown;
+    html?: string;
+}>(rendering: T, width: number, height: number): Promise<T>;

package/esm/util/offscreenCanvasUtils.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { isValidElement } from 'react';
+export { renderToAbstractCanvas } from "./renderToAbstractCanvas.js";
+export function ReactRendering({ rendering, }) {
+    return isValidElement(rendering.reactElement) ? (rendering.reactElement) : (_jsx("g", { dangerouslySetInnerHTML: { __html: rendering.html || '' } }));
+}
+export { getSerializedSvg } from "./offscreenCanvasGetSerializingSvg.js";
+export async function renderingToSvg(rendering, width, height) {
+    if (rendering.canvasRecordedData && !rendering.html) {
+        const { getSerializedSvg } = await import("./offscreenCanvasGetSerializingSvg.js");
+        const html = await getSerializedSvg({
+            width,
+            height,
+            canvasRecordedData: rendering.canvasRecordedData,
+        });
+        return { ...rendering, html };
+    }
+    return rendering;
+}

package/esm/util/parseLineByLine.js

@@ -0,0 +1,22 @@
+import { getProgressDisplayStr } from "./index.js";
+export function parseLineByLine(buffer, lineCallback, statusCallback = () => { }) {
+    const decoder = new TextDecoder('utf8');
+    let blockStart = 0;
+    let i = 0;
+    while (blockStart < buffer.length) {
+        const n = buffer.indexOf(10, blockStart);
+        const lineEnd = n === -1 ? buffer.length : n;
+        const b = buffer.subarray(blockStart, lineEnd);
+        const line = decoder.decode(b).trim();
+        if (line) {
+            const shouldContinue = lineCallback(line, i);
+            if (shouldContinue === false) {
+                break;
+            }
+        }
+        if (i++ % 10_000 === 0) {
+            statusCallback(`Loading ${getProgressDisplayStr(blockStart, buffer.length)}`);
+        }
+        blockStart = lineEnd + 1;
+    }
+}

package/esm/util/range.js

@@ -0,0 +1,21 @@
+export function intersection2(left1, right1, left2, right2) {
+    if (right1 > left2 && left1 < right2 && right2 - left2 && right1 - left1) {
+        if (left1 > left2) {
+            if (right1 < right2) {
+                return [left1, right1];
+            }
+            return [left1, right2];
+        }
+        if (right1 < right2) {
+            return [left2, right1];
+        }
+        return [left2, right2];
+    }
+    return [];
+}
+export function doesIntersect2(left1, right1, left2, right2) {
+    return right1 > left2 && left1 < right2;
+}
+export function isContainedWithin(left1, right1, left2, right2) {
+    return left2 <= left1 && right2 >= right1;
+}

package/esm/util/renderToAbstractCanvas.d.ts

@@ -0,0 +1,17 @@
+interface ExportSVGOptions {
+    rasterizeLayers?: boolean;
+    scale?: number;
+}
+interface RenderToAbstractCanvasOptions {
+    exportSVG?: ExportSVGOptions;
+    highResolutionScaling?: number;
+}
+type RenderResult = {
+    canvasRecordedData: Record<string, unknown>;
+} | {
+    imageData: ImageBitmap;
+} | {
+    html: string;
+};
+export declare function renderToAbstractCanvas<T extends object | undefined>(width: number, height: number, opts: RenderToAbstractCanvasOptions, cb: (ctx: CanvasRenderingContext2D) => Promise<T> | T): Promise<(T extends undefined ? object : T) & RenderResult>;
+export {};

package/esm/util/renderToAbstractCanvas.js

@@ -0,0 +1,53 @@
+import { CanvasSequence } from 'canvas-sequencer-ts';
+import { blobToDataURL } from "./blobToDataURL.js";
+import { createCanvas, createImageBitmap } from "./offscreenCanvasPonyfill.js";
+export async function renderToAbstractCanvas(width, height, opts, cb) {
+    const { exportSVG, highResolutionScaling = 1 } = opts;
+    const safeWidth = Math.max(1, width);
+    const safeHeight = Math.max(1, height);
+    if (exportSVG) {
+        if (!exportSVG.rasterizeLayers) {
+            const fakeCtx = new CanvasSequence();
+            const callbackResult = await cb(fakeCtx);
+            return {
+                ...callbackResult,
+                canvasRecordedData: fakeCtx.toJSON(),
+            };
+        }
+        else {
+            const s = exportSVG.scale || highResolutionScaling;
+            const canvas = createCanvas(Math.ceil(safeWidth * s), Math.ceil(safeHeight * s));
+            const ctx = canvas.getContext('2d');
+            if (!ctx) {
+                throw new Error('2d canvas rendering not supported on this platform');
+            }
+            if (s !== 1) {
+                ctx.scale(s, s);
+            }
+            const callbackResult = await cb(ctx);
+            return {
+                ...callbackResult,
+                html: `<image width="${width}" height="${height}" href="${'convertToBlob' in canvas
+                    ? await blobToDataURL(await canvas.convertToBlob({
+                        type: 'image/png',
+                    }))
+                    : canvas.toDataURL('image/png')}" />`,
+            };
+        }
+    }
+    else {
+        const canvas = createCanvas(Math.ceil(safeWidth * highResolutionScaling), Math.ceil(safeHeight * highResolutionScaling));
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('2d canvas rendering not supported on this platform');
+        }
+        if (highResolutionScaling !== 1) {
+            ctx.scale(highResolutionScaling, highResolutionScaling);
+        }
+        const callbackResult = await cb(ctx);
+        return {
+            ...callbackResult,
+            imageData: await createImageBitmap(canvas),
+        };
+    }
+}

package/esm/util/rpc.d.ts

@@ -0,0 +1,2 @@
+import type { RpcResult } from './librpc.ts';
+export declare function isRpcResult(value: unknown): value is RpcResult;

package/esm/util/rpc.js

@@ -0,0 +1,6 @@
+export function isRpcResult(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '__rpcResult' in value &&
+        value.__rpcResult);
+}

package/esm/util/rxjs.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs';
+import type { StopToken } from './stopToken.ts';
+import type { Observer } from 'rxjs';
+export declare function ObservableCreate<T>(func: (arg: Observer<T>) => void | Promise<void>, _stopToken?: StopToken): Observable<T>;

package/esm/util/rxjs.js

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+export function ObservableCreate(func, _stopToken) {
+    return new Observable((observer) => {
+        try {
+            const ret = func(observer);
+            if (ret?.catch) {
+                ret.catch((error) => {
+                    observer.error(error);
+                });
+            }
+        }
+        catch (error) {
+            observer.error(error);
+        }
+    });
+}

package/esm/util/simpleFeature.d.ts

@@ -0,0 +1,44 @@
+export interface Feature {
+    get(name: 'refName'): string;
+    get(name: 'start' | 'end'): number;
+    get(name: 'subfeatures'): Feature[] | undefined;
+    get(name: string): any;
+    id(): string;
+    parent?: () => Feature | undefined;
+    children?: () => Feature[] | undefined;
+    toJSON(): SimpleFeatureSerialized;
+}
+export declare function isFeature(thing: unknown): thing is Feature;
+export interface SimpleFeatureArgs {
+    data: Record<string, unknown>;
+    parent?: Feature;
+    id: string | number;
+}
+export interface SimpleFeatureSerializedNoId {
+    [key: string]: unknown;
+    parentId?: string;
+    start: number;
+    end: number;
+    refName: string;
+    type?: string;
+    subfeatures?: SimpleFeatureSerializedNoId[];
+}
+export interface SimpleFeatureSerialized extends SimpleFeatureSerializedNoId {
+    subfeatures?: SimpleFeatureSerializedNoId[];
+    uniqueId: string;
+}
+export default class SimpleFeature implements Feature {
+    private data;
+    private subfeatures?;
+    private parentHandle?;
+    private uniqueId;
+    constructor(args: SimpleFeatureArgs | SimpleFeatureSerialized);
+    get(name: string): any;
+    set(name: string, val: any): void;
+    tags(): string[];
+    id(): string;
+    parent(): Feature | undefined;
+    children(): Feature[] | undefined;
+    toJSON(): SimpleFeatureSerialized;
+    static fromJSON(json: SimpleFeatureSerialized): SimpleFeature;
+}

package/esm/util/simpleFeature.js

@@ -0,0 +1,81 @@
+export function isFeature(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        typeof thing.get === 'function' &&
+        typeof thing.id === 'function');
+}
+function isSimpleFeatureSerialized(args) {
+    return 'uniqueId' in args && typeof args.data !== 'object';
+}
+export default class SimpleFeature {
+    data;
+    subfeatures;
+    parentHandle;
+    uniqueId;
+    constructor(args) {
+        if (isSimpleFeatureSerialized(args)) {
+            this.data = args;
+        }
+        else {
+            this.data = args.data;
+            this.parentHandle = args.parent;
+        }
+        const id = isSimpleFeatureSerialized(args) ? args.uniqueId : args.id;
+        if (id === undefined || id === null) {
+            throw new Error('SimpleFeature requires a unique `id` or `data.uniqueId` attribute');
+        }
+        this.uniqueId = String(id);
+        if (!(this.data.aliases || this.data.end - this.data.start >= 0)) {
+            throw new Error(`invalid feature data, end less than start. end: ${this.data.end} start: ${this.data.start}`);
+        }
+        if (this.data.subfeatures) {
+            this.subfeatures = this.data.subfeatures?.map((f, i) => typeof f.get !== 'function'
+                ? new SimpleFeature({
+                    id: f.uniqueId || `${id}-${i}`,
+                    data: {
+                        strand: this.data.strand,
+                        ...f,
+                    },
+                    parent: this,
+                })
+                : f);
+        }
+    }
+    get(name) {
+        return name === 'subfeatures'
+            ? this.subfeatures
+            : name === 'parent'
+                ? this.parent()
+                : this.data[name];
+    }
+    set(name, val) {
+        this.data[name] = val;
+    }
+    tags() {
+        return Object.keys(this.data);
+    }
+    id() {
+        return this.uniqueId;
+    }
+    parent() {
+        return this.parentHandle;
+    }
+    children() {
+        return this.get('subfeatures');
+    }
+    toJSON() {
+        const d = { ...this.data, uniqueId: this.id() };
+        const p = this.parent();
+        if (p) {
+            d.parentId = p.id();
+        }
+        const c = this.children();
+        if (c) {
+            d.subfeatures = c.map(child => child.toJSON());
+        }
+        return d;
+    }
+    static fromJSON(json) {
+        return new SimpleFeature({ ...json });
+    }
+}

package/esm/util/stats.d.ts

@@ -0,0 +1,23 @@
+import type { Feature } from './simpleFeature.ts';
+import type { NoAssemblyRegion } from './types/index.ts';
+import type { Observable } from 'rxjs';
+export interface UnrectifiedQuantitativeStats {
+    scoreMin: number;
+    scoreMax: number;
+    scoreSum: number;
+    scoreSumSquares: number;
+    featureCount: number;
+    basesCovered: number;
+}
+export interface RectifiedQuantitativeStats extends UnrectifiedQuantitativeStats {
+    featureDensity: number;
+    scoreMean: number;
+    scoreStdDev: number;
+}
+export interface QuantitativeStats extends RectifiedQuantitativeStats {
+    currStatsBpPerPx: number;
+}
+export declare function calcStdFromSums(sum: number, sumSquares: number, n: number, population?: boolean): number;
+export declare function rectifyStats(s: UnrectifiedQuantitativeStats): RectifiedQuantitativeStats;
+export declare function scoresToStats(region: NoAssemblyRegion, feats: Observable<Feature>): Promise<RectifiedQuantitativeStats>;
+export declare function blankStats(): RectifiedQuantitativeStats;