@jbrowse/plugin-variants 2.17.0 → 3.0.0

package/esm/shared/SharedVariantMixin.d.ts

@@ -0,0 +1,309 @@
+import type { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
+import type { Feature } from '@jbrowse/core/util';
+export default function SharedVariantMixin(configSchema: AnyConfigurationSchemaType): import("mobx-state-tree").IModelType<{
+    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("mobx-state-tree").ISimpleType<string>;
+    rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+} & {
+    heightPreConfig: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+} & {
+    userBpPerPxLimit: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+    userByteSizeLimit: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+} & {
+    blockState: import("mobx-state-tree").IMapType<import("mobx-state-tree").IModelType<{
+        key: import("mobx-state-tree").ISimpleType<string>;
+        region: import("mobx-state-tree").IType<import("@jbrowse/core/util").Region, import("@jbrowse/core/util").Region, import("@jbrowse/core/util").Region>;
+        reloadFlag: import("mobx-state-tree").IType<number | undefined, number, number>;
+        isLeftEndOfDisplayedRegion: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+        isRightEndOfDisplayedRegion: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    }, {
+        stopToken: string | undefined;
+        filled: boolean;
+        reactElement: React.ReactElement | undefined;
+        features: Map<string, Feature> | undefined;
+        layout: any;
+        status: string;
+        error: unknown;
+        message: string | undefined;
+        maxHeightReached: boolean;
+        ReactComponent: ({ model, }: {
+            model: {
+                error?: unknown;
+                reload: () => void;
+                message: React.ReactNode;
+                filled?: boolean;
+                status?: string;
+                reactElement?: React.ReactElement;
+            };
+        }) => import("react/jsx-runtime").JSX.Element | undefined;
+        renderProps: any;
+    } & {
+        doReload(): void;
+        afterAttach(): void;
+        setStatus(message: string): void;
+        setLoading(newStopToken: string): void;
+        setMessage(messageText: string): void;
+        setRendered(props: import("@jbrowse/plugin-linear-genome-view/src/BaseLinearDisplay/models/serverSideRenderedBlock").RenderedProps | undefined): void;
+        setError(error: unknown): void;
+        reload(): void;
+        beforeDestroy(): void;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+    configuration: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        maxFeatureScreenDensity: {
+            type: string;
+            description: string;
+            defaultValue: number;
+        };
+        fetchSizeLimit: {
+            type: string;
+            defaultValue: number;
+            description: string;
+        };
+        height: {
+            type: string;
+            defaultValue: number;
+            description: string;
+        };
+        mouseover: {
+            type: string;
+            description: string;
+            defaultValue: string;
+            contextVariable: string[];
+        };
+        jexlFilters: {
+            type: string;
+            description: string;
+            defaultValue: never[];
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "displayId">>;
+} & {
+    selectedRendering: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    summaryScoreMode: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    rendererTypeNameState: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    configuration: AnyConfigurationSchemaType;
+}, {
+    rendererTypeName: string;
+    error: unknown;
+    message: string | undefined;
+} & {
+    readonly RenderingComponent: React.FC<{
+        model: {
+            id: string;
+            type: string;
+            rpcDriverName: string | undefined;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            rendererTypeName: string;
+            error: unknown;
+            message: string | undefined;
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+        }, {
+            rendererTypeName: string;
+            error: unknown;
+            message: string | undefined;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+        onHorizontalScroll?: () => void;
+        blockState?: Record<string, any>;
+    }>;
+    readonly DisplayBlurb: React.FC<{
+        model: {
+            id: string;
+            type: string;
+            rpcDriverName: string | undefined;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            rendererTypeName: string;
+            error: unknown;
+            message: string | undefined;
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+        }, {
+            rendererTypeName: string;
+            error: unknown;
+            message: string | undefined;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+    }> | null;
+    readonly adapterConfig: any;
+    readonly parentTrack: any;
+    renderProps(): any;
+    readonly rendererType: import("@jbrowse/core/pluggableElementTypes").RendererType;
+    readonly DisplayMessageComponent: undefined | React.FC<any>;
+    trackMenuItems(): import("@jbrowse/core/ui").MenuItem[];
+    readonly viewMenuActions: import("@jbrowse/core/ui").MenuItem[];
+    regionCannotBeRendered(): null;
+} & {
+    setMessage(arg?: string): void;
+    setError(error?: unknown): void;
+    setRpcDriverName(rpcDriverName: string): void;
+    reload(): void;
+} & {
+    scrollTop: number;
+} & {
+    readonly height: number;
+} & {
+    setScrollTop(scrollTop: number): void;
+    setHeight(displayHeight: number): number;
+    resizeHeight(distance: number): number;
+} & {
+    featureDensityStatsP: undefined | Promise<import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats>;
+    featureDensityStats: undefined | import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats;
+    currStatsBpPerPx: number;
+} & {
+    readonly currentBytesRequested: number;
+    readonly currentFeatureScreenDensity: number;
+    readonly maxFeatureScreenDensity: any;
+    readonly featureDensityStatsReady: boolean;
+    readonly maxAllowableBytes: number;
+} & {
+    afterAttach(): void;
+} & {
+    setCurrStatsBpPerPx(n: number): void;
+    setFeatureDensityStatsLimit(stats?: import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats): void;
+    getFeatureDensityStats(): Promise<import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats>;
+    setFeatureDensityStatsP(arg: any): void;
+    setFeatureDensityStats(featureDensityStats?: import("@jbrowse/core/data_adapters/BaseAdapter").FeatureDensityStats): void;
+    clearFeatureDensityStats(): void;
+} & {
+    readonly regionTooLarge: boolean;
+    readonly regionTooLargeReason: string;
+} & {
+    readonly statsReadyAndRegionNotTooLarge: boolean;
+    regionCannotBeRenderedText(_region: import("@jbrowse/core/util").Region): "" | "Force load to see features";
+    regionCannotBeRendered(_region: import("@jbrowse/core/util").Region): import("react/jsx-runtime").JSX.Element | null;
+} & {
+    featureIdUnderMouse: undefined | string;
+    contextMenuFeature: undefined | Feature;
+} & {
+    readonly DisplayMessageComponent: undefined | React.FC<any>;
+    readonly blockType: "staticBlocks" | "dynamicBlocks";
+    readonly blockDefinitions: import("@jbrowse/core/util/blockTypes").BlockSet;
+} & {
+    readonly renderDelay: number;
+    readonly TooltipComponent: import("@jbrowse/core/util").AnyReactComponentType;
+    readonly selectedFeatureId: string | undefined;
+} & {
+    readonly features: import("@jbrowse/core/util/compositeMap").default<string, Feature>;
+    readonly featureUnderMouse: Feature | undefined;
+    getFeatureOverlapping(blockKey: string, x: number, y: number): string | undefined;
+    getFeatureByID(blockKey: string, id: string): [number, number, number, number] | undefined;
+    searchFeatureByID(id: string): [number, number, number, number] | undefined;
+} & {
+    addBlock(key: string, block: import("@jbrowse/core/util/blockTypes").BaseBlock): void;
+    deleteBlock(key: string): void;
+    selectFeature(feature: Feature): void;
+    navToFeature(feature: Feature): void;
+    clearFeatureSelection(): void;
+    setFeatureIdUnderMouse(feature?: string): void;
+    setContextMenuFeature(feature?: Feature): void;
+} & {
+    reload(): Promise<void>;
+} & {
+    trackMenuItems(): import("@jbrowse/core/ui").MenuItem[];
+    contextMenuItems(): import("@jbrowse/core/ui").MenuItem[];
+    renderProps(): any;
+} & {
+    renderSvg(opts: import("@jbrowse/plugin-linear-genome-view").ExportSvgDisplayOptions): Promise<import("react/jsx-runtime").JSX.Element>;
+    afterAttach(): void;
+} & {
+    message: undefined | string;
+} & {
+    selectFeature(feature: Feature): void;
+    setRendererType(val: string): void;
+} & {
+    readonly adapterTypeName: any;
+    readonly rendererTypeNameSimple: any;
+    readonly filters: undefined;
+} & {
+    readonly adapterCapabilities: string[];
+} & {
+    reload(): Promise<void>;
+}, {
+    type: string;
+} & Partial<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
+    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("mobx-state-tree").ISimpleType<string>;
+    rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+} & {
+    heightPreConfig: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+} & {
+    userBpPerPxLimit: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+    userByteSizeLimit: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+} & {
+    blockState: import("mobx-state-tree").IMapType<import("mobx-state-tree").IModelType<{
+        key: import("mobx-state-tree").ISimpleType<string>;
+        region: import("mobx-state-tree").IType<import("@jbrowse/core/util").Region, import("@jbrowse/core/util").Region, import("@jbrowse/core/util").Region>;
+        reloadFlag: import("mobx-state-tree").IType<number | undefined, number, number>;
+        isLeftEndOfDisplayedRegion: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+        isRightEndOfDisplayedRegion: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    }, {
+        stopToken: string | undefined;
+        filled: boolean;
+        reactElement: React.ReactElement | undefined;
+        features: Map<string, Feature> | undefined;
+        layout: any;
+        status: string;
+        error: unknown;
+        message: string | undefined;
+        maxHeightReached: boolean;
+        ReactComponent: ({ model, }: {
+            model: {
+                error?: unknown;
+                reload: () => void;
+                message: React.ReactNode;
+                filled?: boolean;
+                status?: string;
+                reactElement?: React.ReactElement;
+            };
+        }) => import("react/jsx-runtime").JSX.Element | undefined;
+        renderProps: any;
+    } & {
+        doReload(): void;
+        afterAttach(): void;
+        setStatus(message: string): void;
+        setLoading(newStopToken: string): void;
+        setMessage(messageText: string): void;
+        setRendered(props: import("@jbrowse/plugin-linear-genome-view/src/BaseLinearDisplay/models/serverSideRenderedBlock").RenderedProps | undefined): void;
+        setError(error: unknown): void;
+        reload(): void;
+        beforeDestroy(): void;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+    configuration: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        maxFeatureScreenDensity: {
+            type: string;
+            description: string;
+            defaultValue: number;
+        };
+        fetchSizeLimit: {
+            type: string;
+            defaultValue: number;
+            description: string;
+        };
+        height: {
+            type: string;
+            defaultValue: number;
+            description: string;
+        };
+        mouseover: {
+            type: string;
+            description: string;
+            defaultValue: string;
+            contextVariable: string[];
+        };
+        jexlFilters: {
+            type: string;
+            description: string;
+            defaultValue: never[];
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "displayId">>;
+}>> & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree")._NotCustomized, {
+    id: string;
+    type: string;
+    configuration: import("mobx-state-tree").ModelSnapshotType<Record<string, any>>;
+    rpcDriverName: string | undefined;
+    heightPreConfig: number | undefined;
+    userBpPerPxLimit: number | undefined;
+    userByteSizeLimit: number | undefined;
+} & import("mobx-state-tree")._NotCustomized>;

package/esm/shared/SharedVariantMixin.js

@@ -0,0 +1,55 @@
+import { ConfigurationReference, getConf } from '@jbrowse/core/configuration';
+import { getEnv, getSession, isSelectionContainer } from '@jbrowse/core/util';
+import { BaseLinearDisplay } from '@jbrowse/plugin-linear-genome-view';
+import { types } from 'mobx-state-tree';
+export default function SharedVariantMixin(configSchema) {
+    return types
+        .compose(BaseLinearDisplay, types.model({
+        selectedRendering: types.optional(types.string, ''),
+        summaryScoreMode: types.maybe(types.string),
+        rendererTypeNameState: types.maybe(types.string),
+        configuration: ConfigurationReference(configSchema),
+    }))
+        .volatile(() => ({
+        message: undefined,
+    }))
+        .actions(self => ({
+        selectFeature(feature) {
+            const session = getSession(self);
+            if (isSelectionContainer(session)) {
+                session.setSelection(feature);
+            }
+        },
+        setRendererType(val) {
+            self.rendererTypeNameState = val;
+        },
+    }))
+        .views(self => ({
+        get adapterTypeName() {
+            return self.adapterConfig.type;
+        },
+        get rendererTypeNameSimple() {
+            var _a;
+            return (_a = self.rendererTypeNameState) !== null && _a !== void 0 ? _a : getConf(self, 'defaultRendering');
+        },
+        get filters() {
+            return undefined;
+        },
+    }))
+        .views(self => ({
+        get adapterCapabilities() {
+            const type = self.adapterTypeName;
+            const { pluginManager } = getEnv(self);
+            return pluginManager.getAdapterType(type).adapterCapabilities;
+        },
+    }))
+        .actions(self => {
+        const { reload: superReload } = self;
+        return {
+            async reload() {
+                self.setError();
+                superReload();
+            },
+        };
+    });
+}

package/esm/shared/SourcesDataGrid.d.ts

@@ -0,0 +1,6 @@
+import type { Source } from '../types';
+export default function SourcesDataGrid({ rows, onChange, setSelected, }: {
+    rows: Source[];
+    onChange: (arg: Source[]) => void;
+    setSelected: (arg: string[]) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/esm/shared/SourcesDataGrid.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { SanitizedHTML } from '@jbrowse/core/ui';
+import ColorPicker from '@jbrowse/core/ui/ColorPicker';
+import { getStr, measureGridWidth } from '@jbrowse/core/util';
+import { DataGrid } from '@mui/x-data-grid';
+import { makeStyles } from 'tss-react/mui';
+const useStyles = makeStyles()({
+    cell: {
+        whiteSpace: 'nowrap',
+        overflow: 'hidden',
+        textOverflow: 'ellipsis',
+    },
+});
+export default function SourcesDataGrid({ rows, onChange, setSelected, }) {
+    const { classes } = useStyles();
+    const { id: _id, name: _name, label: _label, color: _color, baseUri: _baseUri, HP: _HP, ...rest } = rows[0];
+    const [currSort, setCurrSort] = useState({
+        idx: 0,
+        field: null,
+    });
+    return (_jsx("div", { style: { height: 400, width: '100%' }, children: _jsx(DataGrid, { checkboxSelection: true, disableRowSelectionOnClick: true, onRowSelectionModelChange: arg => {
+                setSelected(arg);
+            }, rows: rows, rowHeight: 25, columnHeaderHeight: 33, columns: [
+                {
+                    field: 'color',
+                    headerName: 'Color',
+                    renderCell: params => {
+                        const { value, id } = params;
+                        return (_jsx(ColorPicker, { color: value || 'blue', onChange: c => {
+                                const elt = rows.find(f => f.name === id);
+                                if (elt) {
+                                    elt.color = c;
+                                }
+                                onChange([...rows]);
+                            } }));
+                    },
+                },
+                {
+                    field: 'label',
+                    headerName: 'Name',
+                    width: measureGridWidth(rows.map(r => r.label)),
+                },
+                ...Object.keys(rest).map(val => ({
+                    field: val,
+                    renderCell: ({ value }) => (_jsx("div", { className: classes.cell, children: _jsx(SanitizedHTML, { html: getStr(value) }) })),
+                    width: measureGridWidth(rows.map(r => `${r[val]}`)),
+                })),
+            ], sortModel: [], onSortModelChange: args => {
+                const sort = args[0];
+                const idx = (currSort.idx + 1) % 2;
+                const field = sort.field || currSort.field;
+                setCurrSort({ idx, field });
+                onChange(field
+                    ? [...rows].sort((a, b) => {
+                        const aa = getStr(a[field]);
+                        const bb = getStr(b[field]);
+                        return idx === 1 ? aa.localeCompare(bb) : bb.localeCompare(aa);
+                    })
+                    : rows);
+            } }) }));
+}

package/esm/shared/SourcesGrid.d.ts

@@ -0,0 +1,7 @@
+import type { Source } from '../types';
+declare function SourcesGrid({ rows, onChange, showTips, }: {
+    rows: Source[];
+    onChange: (arg: Source[]) => void;
+    showTips: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export default SourcesGrid;

package/esm/shared/SourcesGrid.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import SourcesDataGrid from './SourcesDataGrid';
+import SourcesGridHeader from './SourcesGridHeader';
+function SourcesGrid({ rows, onChange, showTips, }) {
+    const [selected, setSelected] = useState([]);
+    return (_jsxs("div", { children: [_jsx(SourcesGridHeader, { selected: selected, rows: rows, showTips: showTips, onChange: onChange }), _jsx(SourcesDataGrid, { rows: rows, onChange: onChange, setSelected: setSelected })] }));
+}
+export default SourcesGrid;

package/esm/shared/SourcesGridHeader.d.ts

@@ -0,0 +1,7 @@
+import type { Source } from '../types';
+export default function SourcesGridHeader({ selected, onChange, rows, showTips, }: {
+    onChange: (arg: Source[]) => void;
+    rows: Source[];
+    selected: string[];
+    showTips: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/esm/shared/SourcesGridHeader.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
+import { ColorPopover } from '@jbrowse/core/ui/ColorPicker';
+import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown';
+import KeyboardArrowUpIcon from '@mui/icons-material/KeyboardArrowUp';
+import KeyboardDoubleArrowDownIcon from '@mui/icons-material/KeyboardDoubleArrowDown';
+import KeyboardDoubleArrowUpIcon from '@mui/icons-material/KeyboardDoubleArrowUp';
+import { Button } from '@mui/material';
+import { moveDown, moveUp } from './util';
+export default function SourcesGridHeader({ selected, onChange, rows, showTips, }) {
+    const [anchorEl, setAnchorEl] = useState(null);
+    const [widgetColor, setWidgetColor] = useState('blue');
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { disabled: !selected.length, onClick: event => {
+                    setAnchorEl(event.currentTarget);
+                }, children: "Change color of selected items" }), _jsxs(Button, { onClick: () => {
+                    onChange(moveUp([...rows], selected));
+                }, disabled: !selected.length, children: [_jsx(KeyboardArrowUpIcon, {}), showTips ? 'Move selected items up' : null] }), _jsxs(Button, { onClick: () => {
+                    onChange(moveDown([...rows], selected));
+                }, disabled: !selected.length, children: [_jsx(KeyboardArrowDownIcon, {}), showTips ? 'Move selected items down' : null] }), _jsxs(Button, { onClick: () => {
+                    onChange(moveUp([...rows], selected, rows.length));
+                }, disabled: !selected.length, children: [_jsx(KeyboardDoubleArrowUpIcon, {}), showTips ? 'Move selected items to top' : null] }), _jsxs(Button, { onClick: () => {
+                    onChange(moveDown([...rows], selected, rows.length));
+                }, disabled: !selected.length, children: [_jsx(KeyboardDoubleArrowDownIcon, {}), showTips ? 'Move selected items to bottom' : null] }), _jsx(ColorPopover, { anchorEl: anchorEl, color: widgetColor, onChange: c => {
+                    setWidgetColor(c);
+                    selected.forEach(id => {
+                        const elt = rows.find(f => f.name === id);
+                        if (elt) {
+                            elt.color = c;
+                        }
+                    });
+                    onChange([...rows]);
+                }, onClose: () => {
+                    setAnchorEl(null);
+                } })] }));
+}

package/esm/shared/multiVariantColor.d.ts

@@ -0,0 +1,3 @@
+export declare function getColorAlleleCount(alleles: string[]): string;
+export declare function getColorPhased(alleles: string[], HP: number): string;
+export declare function getColorPhasedWithPhaseSet(alleles: string[], HP: number, PS: string): string;

package/esm/shared/multiVariantColor.js

@@ -0,0 +1,45 @@
+import { set1 } from '@jbrowse/core/ui/colors';
+import { colord } from '@jbrowse/core/util/colord';
+import { colorify } from '../util';
+export function getColorAlleleCount(alleles) {
+    const total = alleles.length;
+    let alt = 0;
+    let uncalled = 0;
+    let alt2 = 0;
+    let ref = 0;
+    for (const allele of alleles) {
+        if (allele === '1') {
+            alt++;
+        }
+        else if (allele === '0') {
+            ref++;
+        }
+        else if (allele === '.') {
+            uncalled++;
+        }
+        else {
+            alt2++;
+        }
+    }
+    if (ref === total) {
+        return `#ccc`;
+    }
+    else {
+        let a1 = colord(`hsl(200,50%,${80 - (alt / total) * 50}%)`);
+        if (alt2) {
+            a1 = a1.mix(`hsla(0,100%,20%,${alt2 / total})`);
+        }
+        if (uncalled) {
+            a1 = a1.mix(`hsla(50,50%,50%,${uncalled / total / 2})`);
+        }
+        return a1.toHex();
+    }
+}
+export function getColorPhased(alleles, HP) {
+    const c = +alleles[HP];
+    return c ? set1[c - 1] || 'black' : '#ccc';
+}
+export function getColorPhasedWithPhaseSet(alleles, HP, PS) {
+    const c = +alleles[HP];
+    return c ? colorify(+PS) || 'black' : '#ccc';
+}

package/esm/shared/util.d.ts

@@ -0,0 +1,10 @@
+export declare function moveUp(arr: {
+    name: string;
+}[], sel: string[], by?: number): {
+    name: string;
+}[];
+export declare function moveDown(arr: {
+    name: string;
+}[], sel: string[], by?: number): {
+    name: string;
+}[];

package/esm/shared/util.js

@@ -0,0 +1,28 @@
+export function moveUp(arr, sel, by = 1) {
+    const idxs = sel
+        .map(l => arr.findIndex(v => v.name === l))
+        .sort((a, b) => a - b);
+    let lastIdx = 0;
+    for (const old of idxs) {
+        const idx = Math.max(lastIdx, old - by);
+        if (idx >= lastIdx) {
+            arr.splice(idx, 0, arr.splice(old, 1)[0]);
+        }
+        lastIdx = lastIdx + 1;
+    }
+    return arr;
+}
+export function moveDown(arr, sel, by = 1) {
+    const idxs = sel
+        .map(l => arr.findIndex(v => v.name === l))
+        .sort((a, b) => b - a);
+    let lastIdx = arr.length - 1;
+    for (const old of idxs) {
+        const idx = Math.min(lastIdx, old + by);
+        if (idx <= lastIdx) {
+            arr.splice(idx, 0, arr.splice(old, 1)[0]);
+        }
+        lastIdx = lastIdx - 1;
+    }
+    return arr;
+}

package/esm/types.d.ts

@@ -0,0 +1,14 @@
+export interface Source {
+    baseUri?: string;
+    name: string;
+    label?: string;
+    color?: string;
+    group?: string;
+    HP?: number;
+    id?: string;
+    [key: string]: unknown;
+}
+export interface SampleInfo {
+    isPhased: boolean;
+    maxPloidy: number;
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/esm/util.d.ts

@@ -0,0 +1,8 @@
+import type { Feature } from '@jbrowse/core/util';
+export declare function fillRectCtx(x: number, y: number, width: number, height: number, ctx: CanvasRenderingContext2D, color?: string): void;
+export declare function getCol(gt: string): "blue" | "teal" | "#ccc" | "#CBC3E3";
+export declare function randomColor(str: string): string;
+export declare function colorify(n: number): string;
+export declare function findSecondLargest(arr: Iterable<number>): number;
+export declare function calculateMinorAlleleFrequency(feat: Feature): number;
+export declare function getFeaturesThatPassMinorAlleleFrequencyFilter(feats: Iterable<Feature>, minorAlleleFrequencyFilter: number): Feature[];