@jbrowse/core 3.7.0 → 4.0.0

package/esm/util/tss-react/makeStyles.js

@@ -0,0 +1,38 @@
+'use client';
+import { useMemo } from 'react';
+import { __unsafe_useEmotionCache } from '@emotion/react';
+import { createUseCssAndCx } from "./cssAndCx.js";
+import { mergeClasses } from "./mergeClasses.js";
+import { getDependencyArrayRef } from "./tools/getDependencyArrayRef.js";
+const useContextualCache = __unsafe_useEmotionCache;
+export function createMakeStyles(params) {
+    const { useTheme } = params;
+    const { useCssAndCx } = createUseCssAndCx({
+        useCache: useContextualCache,
+    });
+    function makeStyles() {
+        return function (cssObjectByRuleNameOrGetCssObjectByRuleName) {
+            const getCssObjectByRuleName = typeof cssObjectByRuleNameOrGetCssObjectByRuleName === 'function'
+                ? cssObjectByRuleNameOrGetCssObjectByRuleName
+                : () => cssObjectByRuleNameOrGetCssObjectByRuleName;
+            return function useStyles(_params, muiStyleOverridesParams) {
+                const theme = useTheme();
+                const { css, cx } = useCssAndCx();
+                const classes = useMemo(() => {
+                    const cssObjectByRuleName = getCssObjectByRuleName(theme);
+                    const result = {};
+                    for (const ruleName of Object.keys(cssObjectByRuleName)) {
+                        const cssObject = cssObjectByRuleName[ruleName];
+                        result[ruleName] = css(cssObject);
+                    }
+                    return result;
+                }, [css, theme]);
+                const propsClasses = muiStyleOverridesParams?.props.classes;
+                const propsClassesRef = getDependencyArrayRef(propsClasses);
+                const mergedClasses = useMemo(() => propsClasses ? mergeClasses(classes, propsClasses, cx) : classes, [classes, propsClassesRef, cx]);
+                return { classes: mergedClasses, theme, css, cx };
+            };
+        };
+    }
+    return { makeStyles };
+}

package/esm/util/tss-react/mergeClasses.d.ts

@@ -0,0 +1,2 @@
+import type { Cx } from './types.ts';
+export declare function mergeClasses<T extends string, U extends string>(classesFromUseStyles: Record<T, string>, classesOverrides: Partial<Record<U, string>> | undefined, cx: Cx): Record<T, string> & Partial<Record<Exclude<U, T>, string>>;

package/esm/util/tss-react/mergeClasses.js

@@ -0,0 +1,24 @@
+export function mergeClasses(classesFromUseStyles, classesOverrides, cx) {
+    if (!(classesOverrides instanceof Object)) {
+        return classesFromUseStyles;
+    }
+    const overrideKeys = Object.keys(classesOverrides);
+    if (overrideKeys.length === 0) {
+        return classesFromUseStyles;
+    }
+    const out = {};
+    for (const ruleName of Object.keys(classesFromUseStyles)) {
+        out[ruleName] = cx(classesFromUseStyles[ruleName], classesOverrides[ruleName]);
+    }
+    for (const ruleName of overrideKeys) {
+        if (ruleName in classesFromUseStyles) {
+            continue;
+        }
+        const className = classesOverrides[ruleName];
+        if (typeof className !== 'string') {
+            continue;
+        }
+        out[ruleName] = className;
+    }
+    return out;
+}

package/esm/util/tss-react/mui/index.d.ts

@@ -0,0 +1 @@
+export { makeStyles } from './mui.ts';

package/esm/util/tss-react/mui/index.js

@@ -0,0 +1 @@
+export { makeStyles } from "./mui.js";

package/esm/util/tss-react/mui/mui.d.ts

@@ -0,0 +1,10 @@
+export declare const makeStyles: () => <RuleName extends string>(cssObjectByRuleNameOrGetCssObjectByRuleName: Record<RuleName, import("../types.ts").CSSObject> | ((theme: import("@mui/material").Theme) => Record<RuleName, import("../types.ts").CSSObject>)) => (_params?: unknown, muiStyleOverridesParams?: {
+    props: {
+        classes?: Record<string, string>;
+    };
+}) => {
+    classes: Record<RuleName, string>;
+    theme: import("@mui/material").Theme;
+    css: import("../types.ts").Css;
+    cx: import("../types.ts").Cx;
+};

package/esm/util/tss-react/mui/mui.js

@@ -0,0 +1,5 @@
+import { useTheme } from '@mui/material/styles';
+import { createMakeStyles } from "../makeStyles.js";
+export const { makeStyles } = createMakeStyles({
+    useTheme,
+});

package/esm/util/tss-react/tools/classnames.d.ts

@@ -0,0 +1,2 @@
+export type CxArg = undefined | null | string | boolean | Record<string, boolean | null | undefined> | readonly CxArg[];
+export declare const classnames: (args: CxArg[]) => string;

package/esm/util/tss-react/tools/classnames.js

@@ -0,0 +1,44 @@
+export const classnames = (args) => {
+    const len = args.length;
+    let i = 0;
+    let cls = '';
+    for (; i < len; i++) {
+        const arg = args[i];
+        if (arg == null) {
+            continue;
+        }
+        let toAdd;
+        switch (typeof arg) {
+            case 'boolean':
+                break;
+            case 'object': {
+                if (Array.isArray(arg)) {
+                    toAdd = classnames(arg);
+                }
+                else {
+                    const obj = arg;
+                    toAdd = '';
+                    for (const k in obj) {
+                        if (obj[k] && k) {
+                            if (toAdd) {
+                                toAdd += ' ';
+                            }
+                            toAdd += k;
+                        }
+                    }
+                }
+                break;
+            }
+            default: {
+                toAdd = arg;
+            }
+        }
+        if (toAdd) {
+            if (cls) {
+                cls += ' ';
+            }
+            cls += toAdd;
+        }
+    }
+    return cls;
+};

package/esm/util/tss-react/tools/getDependencyArrayRef.d.ts

@@ -0,0 +1 @@
+export declare function getDependencyArrayRef(obj: any): any;

package/esm/util/tss-react/tools/getDependencyArrayRef.js

@@ -0,0 +1,19 @@
+export function getDependencyArrayRef(obj) {
+    if (!(obj instanceof Object) || typeof obj === 'function') {
+        return obj;
+    }
+    const arr = [];
+    for (const key in obj) {
+        const value = obj[key];
+        const typeofValue = typeof value;
+        if (!(typeofValue === 'string' ||
+            (typeofValue === 'number' && !isNaN(value)) ||
+            typeofValue === 'boolean' ||
+            value === undefined ||
+            value === null)) {
+            return obj;
+        }
+        arr.push(`${key}:${typeofValue}_${value}`);
+    }
+    return `xSqLiJdLMd9s${arr.join('|')}`;
+}

package/esm/util/tss-react/types.d.ts

@@ -0,0 +1,13 @@
+import type { CxArg } from './tools/classnames.ts';
+import type { CSSObject as CSSObject_base, Interpolation } from '@emotion/react';
+export type CSSInterpolation = Interpolation<undefined>;
+export interface CSSObject extends CSSObject_base {
+    label?: string;
+}
+export interface Css {
+    (template: TemplateStringsArray, ...args: CSSInterpolation[]): string;
+    (...args: CSSInterpolation[]): string;
+}
+export type Cx = (...classNames: CxArg[]) => string;
+export declare function matchCSSObject(arg: TemplateStringsArray | CSSInterpolation): arg is CSSObject;
+export type { CxArg } from './tools/classnames.ts';

package/esm/util/tss-react/types.js

@@ -0,0 +1,6 @@
+export function matchCSSObject(arg) {
+    return (arg instanceof Object &&
+        !('styles' in arg) &&
+        !('length' in arg) &&
+        !('__emotion_styles' in arg));
+}

package/esm/util/types/ElementId.d.ts

@@ -0,0 +1 @@
+export declare const ElementId: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;

package/esm/util/types/ElementId.js

@@ -0,0 +1,3 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import { nanoid } from "../nanoid.js";
+export const ElementId = types.optional(types.identifier, () => nanoid(10));

package/esm/util/types/index.d.ts

@@ -0,0 +1,273 @@
+import type React from 'react';
+import type { BlobLocation as MUBlobLocation, LocalPathLocation as MULocalPathLocation, NoAssemblyRegion as MUNoAssemblyRegion, Region as MUIRegion, UriLocation as MUUriLocation } from './mst.ts';
+import type TextSearchManager from '../../TextSearch/TextSearchManager.ts';
+import type assemblyManager from '../../assemblyManager/index.ts';
+import type { AnyConfigurationModel } from '../../configuration/index.ts';
+import type { BaseInternetAccountModel } from '../../pluggableElementTypes/models/index.ts';
+import type RpcManager from '../../rpc/RpcManager.ts';
+import type { MenuItem } from '../../ui/index.ts';
+import type { Feature } from '../simpleFeature.ts';
+import type { IAnyStateTreeNode, IStateTreeNode, IType, Instance, SnapshotIn } from '@jbrowse/mobx-state-tree';
+import type { ThemeOptions } from '@mui/material';
+export * from './util.ts';
+export interface AbstractViewContainer extends IStateTreeNode<IType<any, any, any>> {
+    views: AbstractViewModel[];
+    removeView(view: AbstractViewModel): void;
+    addView(typeName: string, initialState?: Record<string, unknown>): AbstractViewModel;
+}
+export declare function isViewContainer(thing: unknown): thing is AbstractViewContainer;
+export type NotificationLevel = 'error' | 'info' | 'warning' | 'success';
+export interface SnackAction {
+    name: React.ReactElement | string;
+    onClick: () => void;
+}
+export type AssemblyManager = Instance<ReturnType<typeof assemblyManager>>;
+export interface BasePlugin {
+    version?: string;
+    name: string;
+    url?: string;
+}
+export interface JBrowsePlugin {
+    name: string;
+    authors: string[];
+    description: string;
+    location: string;
+    url?: string;
+    umdUrl?: string;
+    esmUrl?: string;
+    cjsUrl?: string;
+    license: string;
+    image?: string;
+}
+export type DialogComponentType = React.LazyExoticComponent<React.FC<any>> | React.FC<any>;
+export interface AbstractSessionModel extends AbstractViewContainer {
+    tracksById: Record<string, AnyConfigurationModel>;
+    jbrowse: IAnyStateTreeNode;
+    drawerPosition?: string;
+    configuration: AnyConfigurationModel;
+    rpcManager: RpcManager;
+    assemblyNames: string[];
+    assemblies: AnyConfigurationModel[];
+    selection?: unknown;
+    focusedViewId?: string;
+    themeName?: string;
+    theme?: ThemeOptions;
+    hovered: unknown;
+    setHovered: (arg: unknown) => void;
+    setFocusedViewId?: (id: string) => void;
+    allThemes?: () => Record<string, ThemeOptions>;
+    setSelection: (feature: Feature) => void;
+    setSession?: (arg: {
+        name: string;
+        [key: string]: unknown;
+    }) => void;
+    clearSelection: () => void;
+    duplicateCurrentSession?: () => void;
+    notify: (message: string, level?: NotificationLevel, action?: SnackAction) => void;
+    notifyError: (message: string, error?: unknown, extra?: unknown) => void;
+    assemblyManager: AssemblyManager;
+    version: string;
+    getTrackActionMenuItems?: (config: AnyConfigurationModel, extraTrackActions?: MenuItem[]) => MenuItem[];
+    getTrackActions?: (arg: AnyConfigurationModel) => MenuItem[];
+    getTrackListMenuItems?: (arg: AnyConfigurationModel) => MenuItem[];
+    addAssembly?: Function;
+    removeAssembly?: Function;
+    textSearchManager?: TextSearchManager;
+    connections: AnyConfigurationModel[];
+    deleteConnection?: Function;
+    temporaryAssemblies?: unknown[];
+    addTemporaryAssembly?: (arg: Record<string, unknown>) => void;
+    removeTemporaryAssembly?: (arg: string) => void;
+    sessionConnections?: AnyConfigurationModel[];
+    sessionTracks?: AnyConfigurationModel[];
+    connectionInstances?: {
+        name: string;
+        tracks: AnyConfigurationModel[];
+        configuration: AnyConfigurationModel;
+    }[];
+    makeConnection?: Function;
+    breakConnection?: Function;
+    prepareToBreakConnection?: (arg: AnyConfigurationModel) => any;
+    adminMode?: boolean;
+    showWidget?: Function;
+    addWidget?: Function;
+    DialogComponent?: DialogComponentType;
+    DialogProps: any;
+    queueDialog<T extends DialogComponentType>(callback: (doneCallback: () => void) => [T, React.ComponentProps<T>]): void;
+    name: string;
+    id?: string;
+    tracks: AnyConfigurationModel[];
+}
+export declare function isSessionModel(thing: unknown): thing is AbstractSessionModel;
+export interface SessionWithConfigEditing extends AbstractSessionModel {
+    editConfiguration(configuration: AnyConfigurationModel): void;
+}
+export declare function isSessionModelWithConfigEditing(t: unknown): t is SessionWithConfigEditing;
+export interface SessionWithAddTracks extends AbstractSessionModel {
+    addTrackConf(configuration: AnyConfigurationModel | SnapshotIn<AnyConfigurationModel>): void;
+}
+export declare function isSessionWithAddTracks(t: unknown): t is SessionWithAddTracks;
+export interface SessionWithShareURL extends AbstractSessionModel {
+    shareURL: string;
+}
+export declare function isSessionWithShareURL(thing: unknown): thing is SessionWithShareURL;
+export interface Widget {
+    type: string;
+    id: string;
+}
+export interface WidgetMap<K, V> {
+    size: number;
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    forEach(callbackfn: (value: V, key: K) => void): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}
+export interface SessionWithWidgets extends AbstractSessionModel {
+    minimized: boolean;
+    visibleWidget?: Widget;
+    widgets: WidgetMap<string, Widget>;
+    activeWidgets: WidgetMap<string, Widget>;
+    hideAllWidgets: () => void;
+    addWidget(typeName: string, id: string, initialState?: Record<string, unknown>, configuration?: {
+        type: string;
+    }): Widget;
+    showWidget(widget: unknown): void;
+    hideWidget(widget: unknown): void;
+}
+export interface SessionWithDrawerWidgets extends SessionWithWidgets {
+    drawerWidth: number;
+    resizeDrawer(arg: number): number;
+    minimizeWidgetDrawer(): void;
+    showWidgetDrawer: () => void;
+    drawerPosition: string;
+    setDrawerPosition(arg: string): void;
+}
+export declare function isSessionModelWithWidgets(thing: unknown): thing is SessionWithWidgets;
+export interface SessionWithConnections {
+    makeConnection: (arg: AnyConfigurationModel) => void;
+}
+export declare function isSessionModelWithConnections(thing: unknown): thing is SessionWithConnections;
+export interface SessionWithConnectionEditing {
+    addConnectionConf: (arg: AnyConfigurationModel) => void;
+}
+export declare function isSessionModelWithConnectionEditing(thing: unknown): thing is SessionWithConnectionEditing;
+export interface SessionWithSessionPlugins extends AbstractSessionModel {
+    sessionPlugins: JBrowsePlugin[];
+    addSessionPlugin: Function;
+    removeSessionPlugin: Function;
+}
+export declare function isSessionWithSessionPlugins(thing: unknown): thing is SessionWithSessionPlugins;
+export interface SelectionContainer extends AbstractSessionModel {
+    selection?: unknown;
+    setSelection(thing: unknown): void;
+}
+export declare function isSelectionContainer(thing: unknown): thing is SelectionContainer;
+export interface SessionWithFocusedViewAndDrawerWidgets extends SessionWithDrawerWidgets {
+    focusedViewId: string | undefined;
+    setFocusedViewId(id: string): void;
+}
+export interface AbstractViewModel {
+    id: string;
+    type: string;
+    width: number;
+    minimized: boolean;
+    setWidth(width: number): void;
+    setMinimized(flag: boolean): void;
+    displayName: string | undefined;
+    setDisplayName: (arg: string) => void;
+    menuItems: () => MenuItem[];
+}
+export declare function isViewModel(thing: unknown): thing is AbstractViewModel;
+type Display = {
+    displayId: string;
+} & AnyConfigurationModel;
+export interface AbstractTrackModel {
+    id: string;
+    displays: AbstractDisplayModel[];
+    configuration: AnyConfigurationModel & {
+        displays: Display[];
+    };
+}
+export declare function isTrackModel(thing: unknown): thing is AbstractTrackModel;
+export interface AbstractDisplayModel {
+    id: string;
+    parentTrack: AbstractTrackModel;
+    renderDelay: number;
+    rendererType: any;
+    cannotBeRenderedReason?: string;
+}
+export declare function isDisplayModel(thing: unknown): thing is AbstractDisplayModel;
+export interface TrackViewModel extends AbstractViewModel {
+    showTrack(trackId: string): void;
+    hideTrack(trackId: string): void;
+}
+export declare function isTrackViewModel(thing: unknown): thing is TrackViewModel;
+export interface AbstractRootModel {
+    jbrowse: IAnyStateTreeNode;
+    session?: AbstractSessionModel;
+    setDefaultSession?(): void;
+    adminMode?: boolean;
+    error?: unknown;
+}
+export interface AppRootModel extends AbstractRootModel {
+    internetAccounts: BaseInternetAccountModel[];
+    findAppropriateInternetAccount(location: UriLocation): BaseInternetAccountModel | undefined;
+}
+export declare function isAppRootModel(thing: unknown): thing is AppRootModel;
+export interface RootModelWithInternetAccounts extends AbstractRootModel {
+    internetAccounts: BaseInternetAccountModel[];
+    findAppropriateInternetAccount(location: UriLocation): BaseInternetAccountModel | undefined;
+}
+export declare function isRootModelWithInternetAccounts(thing: unknown): thing is RootModelWithInternetAccounts;
+export interface AbstractMenuManager {
+    appendMenu(menuName: string): void;
+    insertMenu(menuName: string, position: number): number;
+    insertInMenu(menuName: string, menuItem: MenuItem, position: number): number;
+    appendToMenu(menuName: string, menuItem: MenuItem): number;
+    appendToSubMenu(menuPath: string[], menuItem: MenuItem): number;
+    insertInSubMenu(menuPath: string[], menuItem: MenuItem, position: number): number;
+}
+export declare function isAbstractMenuManager(thing: unknown): thing is AbstractMenuManager;
+export interface NoAssemblyRegion extends SnapshotIn<typeof MUNoAssemblyRegion> {
+}
+export interface Region extends SnapshotIn<typeof MUIRegion> {
+}
+export interface AugmentedRegion extends Region {
+    originalRefName?: string;
+}
+export interface LocalPathLocation extends SnapshotIn<typeof MULocalPathLocation> {
+}
+export interface UriLocation extends SnapshotIn<typeof MUUriLocation> {
+}
+export declare function isUriLocation(location: unknown): location is UriLocation;
+export declare function isLocalPathLocation(location: unknown): location is LocalPathLocation;
+export declare function isBlobLocation(location: unknown): location is BlobLocation;
+export declare class AuthNeededError extends Error {
+    message: string;
+    url: string;
+    constructor(message: string, url: string);
+}
+export declare class RetryError extends Error {
+    message: string;
+    internetAccountId: string;
+    constructor(message: string, internetAccountId: string);
+}
+export declare function isAuthNeededException(exception: unknown): exception is AuthNeededError;
+export declare function isRetryException(exception: Error): boolean;
+export interface BlobLocation extends SnapshotIn<typeof MUBlobLocation> {
+}
+export type FileLocation = LocalPathLocation | UriLocation | BlobLocation;
+export interface PreUriLocation {
+    uri: string;
+}
+export interface PreLocalPathLocation {
+    localPath: string;
+}
+export interface PreBlobLocation {
+    blob: File;
+}
+export type PreFileLocation = PreUriLocation | PreLocalPathLocation | PreBlobLocation;
+export { default as TextSearchManager } from '../../TextSearch/TextSearchManager.ts';

package/esm/util/types/index.js

@@ -0,0 +1,131 @@
+import { isStateTreeNode } from '@jbrowse/mobx-state-tree';
+export * from "./util.js";
+export function isViewContainer(thing) {
+    return (isStateTreeNode(thing) &&
+        'removeView' in thing &&
+        'addView' in thing &&
+        'views' in thing);
+}
+export function isSessionModel(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'rpcManager' in thing &&
+        'configuration' in thing);
+}
+export function isSessionModelWithConfigEditing(t) {
+    return isSessionModel(t) && 'editConfiguration' in t;
+}
+export function isSessionWithAddTracks(t) {
+    return (isSessionModel(t) && 'addTrackConf' in t && !t.disableAddTracks);
+}
+export function isSessionWithShareURL(thing) {
+    return isSessionModel(thing) && 'shareURL' in thing && !!thing.shareURL;
+}
+export function isSessionModelWithWidgets(thing) {
+    return isSessionModel(thing) && 'widgets' in thing;
+}
+export function isSessionModelWithConnections(thing) {
+    return isSessionModel(thing) && 'makeConnection' in thing;
+}
+export function isSessionModelWithConnectionEditing(thing) {
+    return isSessionModel(thing) && 'addConnectionConf' in thing;
+}
+export function isSessionWithSessionPlugins(thing) {
+    return isSessionModel(thing) && 'sessionPlugins' in thing;
+}
+export function isSelectionContainer(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'selection' in thing &&
+        'setSelection' in thing);
+}
+export function isViewModel(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'width' in thing &&
+        'setWidth' in thing);
+}
+export function isTrackModel(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'configuration' in thing &&
+        thing.configuration.trackId);
+}
+export function isDisplayModel(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'configuration' in thing &&
+        thing.configuration.displayId);
+}
+export function isTrackViewModel(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'showTrack' in thing &&
+        'hideTrack' in thing);
+}
+export function isAppRootModel(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'findAppropriateInternetAccount' in thing);
+}
+export function isRootModelWithInternetAccounts(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'internetAccounts' in thing &&
+        'findAppropriateInternetAccount' in thing);
+}
+export function isAbstractMenuManager(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'appendMenu' in thing &&
+        'appendToSubMenu' in thing);
+}
+export function isUriLocation(location) {
+    return (typeof location === 'object' &&
+        location !== null &&
+        'uri' in location &&
+        !!location.uri);
+}
+export function isLocalPathLocation(location) {
+    return (typeof location === 'object' &&
+        location !== null &&
+        'localPath' in location &&
+        !!location.localPath);
+}
+export function isBlobLocation(location) {
+    return (typeof location === 'object' &&
+        location !== null &&
+        'blobId' in location &&
+        !!location.blobId);
+}
+export class AuthNeededError extends Error {
+    message;
+    url;
+    constructor(message, url) {
+        super(message);
+        this.message = message;
+        this.url = url;
+        this.name = 'AuthNeededError';
+        Object.setPrototypeOf(this, AuthNeededError.prototype);
+    }
+}
+export class RetryError extends Error {
+    message;
+    internetAccountId;
+    constructor(message, internetAccountId) {
+        super(message);
+        this.message = message;
+        this.internetAccountId = internetAccountId;
+        this.name = 'RetryError';
+    }
+}
+export function isAuthNeededException(exception) {
+    return (exception instanceof Error &&
+        (exception.name === 'AuthNeededError' ||
+            exception.url !== undefined));
+}
+export function isRetryException(exception) {
+    return (exception.name === 'RetryError' ||
+        exception.internetAccountId !== undefined);
+}
+export { default as TextSearchManager } from "../../TextSearch/TextSearchManager.js";