higlass/dist/app/scripts/types.d.ts

HiGlass Hi-C / genomic / large data viewer

import type * as configs from './configs';
import type { ChromsizeRow } from './utils/parse-chromsizes-rows';
export type Theme = typeof configs.THEME_DARK | typeof configs.THEME_LIGHT;
export type SizeMode = typeof configs.SIZE_MODE_DEFAULT | typeof configs.SIZE_MODE_BOUNDED | typeof configs.SIZE_MODE_OVERFLOW | typeof configs.SIZE_MODE_BOUNDED_OVERFLOW | typeof configs.SIZE_MODE_SCROLL;
export type HiGlassViewConfig = Record<string, unknown>;
/** Additional options for how the {@link HiGlassComponent} is drawn and behaves */
export interface HiGlassOptions {
    /** An auth token to be included with every tile request. */
    authToken?: string;
    /**
     * Whether the component should be sized to fit within the enclosing div.
     *
     * If `false`, the component will grow as needed to fit the tracks within it.
     */
    bounded?: boolean;
    /**
     * Whether the layout be changed.
     *
     * If `false`, the view headers will be hidden. Overrides the `editable` value in the viewconf if specified.
     */
    editable?: boolean;
    /** A set of default options that will be used for newly added tracks. */
    defaultTrackOptions?: {
        /** Options for all tracks types. */
        all?: Record<string, unknown>;
        /** Options for specific tracks types. */
        trackSpecific?: Record<string, Record<string, unknown>>;
    };
    viewMarginTop?: number;
    viewMarginBottom?: number;
    viewMarginLeft?: number;
    viewMarginRight?: number;
    viewPaddingTop?: number;
    viewPaddingBottom?: number;
    viewPaddingLeft?: number;
    viewPaddingRight?: number;
    theme?: 'dark' | 'light';
    isDarkTheme?: boolean;
    moustTool?: 'select' | 'track-select';
    pluginTracks?: Record<string, unknown>;
    pluginDataFetchers?: Record<string, unknown>;
    pixelPreciseMarginPadding?: boolean;
    sizeMode?: SizeMode;
    renderer?: 'canvas';
    onViewConfLoaded?: () => void;
    cheatCodesEnabled?: boolean;
    rangeSelectionOnAlt?: boolean;
    tracksEditable?: boolean;
    zoomFixed?: boolean;
    containerPaddingX?: number;
    containerPaddingY?: number;
    broadcastMousePositionGlobally?: boolean;
    showGlobalMousePosition?: boolean;
    globalMousePosition?: boolean;
}
export type Scale = import('d3-scale').ScaleContinuousNumeric<number, number>;
export type TrackPosition = typeof import('./configs/primitives').TRACK_LOCATIONS[number];
export type ChromInfo<Name extends string = string> = {
    cumPositions: {
        id?: number;
        pos: number;
        chr: Name;
    }[];
    chrPositions: Record<Name, {
        pos: number;
    }>;
    chromLengths: Record<Name, number>;
    totalLength: number;
};
export type UnknownTrackConfig = {
    type: string;
    uid: string;
    server: string;
    tilesetUid: string;
    options?: Record<string, unknown>;
    position?: TrackPosition;
    data?: Record<string, unknown>;
    coordSystem?: unknown;
    height?: number;
    width?: number;
    x?: number;
    y?: number;
    chromInfoPath?: string;
    projectionXDomain?: [number, number];
    projectionYDomain?: [number, number];
    registerViewportChanged?: unknown;
    removeViewportChanged?: unknown;
    setDomainsCallback?: unknown;
};
export type CombinedTrackConfig = {
    type: 'combined';
    contents: Array<UnknownTrackConfig>;
    uid: string;
    server?: string;
    height?: number;
    width?: number;
    tilesetUid?: string;
    options?: Record<string, unknown>;
    position?: TrackPosition;
    data?: Record<string, unknown>;
    coordSystem?: unknown;
    x?: number;
    y?: number;
    chromInfoPath?: string;
    projectionXDomain?: [number, number];
    projectionYDomain?: [number, number];
    registerViewportChanged?: unknown;
    removeViewportChanged?: unknown;
    setDomainsCallback?: unknown;
};
export type TrackConfig = UnknownTrackConfig | CombinedTrackConfig;
export type TrackVisitor = (track: TrackConfig, position: null | TrackPosition) => void;
type ZoomedFunction = (xScale: Scale, yScale: Scale, k?: number, x?: number, y?: number, xPosition?: number, yPosition?: number) => void;
export interface TrackObject {
    draw(): void;
    rerender(options: unknown): void;
    delayDrawing: boolean;
    flipText?: boolean;
    originalTrack?: TrackObject;
    childTracks?: TrackObject[];
    createdTracks: Record<string, TrackObject>;
    refScalesChanged(x: Scale, y: Scale): void;
    position: [number, number];
    dimensions: [number, number];
    updateContents(contents: TrackConfig[], x: unknown): TrackObject;
    zoomed: ZoomedFunction;
    setPosition(position: [number, number]): void;
    setDimensions(dimensions: [number, number]): void;
    remove(): void;
    movedY(extent: number): void;
    zoomedY(yPosition: number, wheelDelta: number): void;
    fetching?: Set<unknown>;
    tilesetInfo?: TilesetInfo;
    chromInfo?: unknown;
}
/** Minimum information describing a tileset. */
export type TilesetInfoShared = {
    name: string;
    min_pos: number[];
    max_pos: number[];
    max_zoom: number;
    coordSystem?: string;
    tile_size?: number;
    max_tile_width?: number;
    transforms?: {
        name: string;
        value: string;
    }[];
    chromsizes?: ArrayLike<ChromsizeRow>;
    error?: string;
};
export type LegacyTilesetInfo = TilesetInfoShared & {
    max_width: number;
    bins_per_dimension?: number;
};
export type ResolutionsTilesetInfo = TilesetInfoShared & {
    resolutions: number[];
};
export type TilesetInfo = LegacyTilesetInfo | ResolutionsTilesetInfo;
export type DataConfig = {
    server?: string;
    url?: string;
    filetype?: string;
    coordSystem?: string;
    children?: DataConfig[];
    options?: Record<string, any>;
    type?: string;
    slicePos?: number;
};
export type HandleTilesetInfoFinished = (info: TilesetInfo | null | {
    error: string;
}, tilesetUid?: string) => void;
export interface AbstractDataFetcher<TileType, DataConfig> {
    tilesetInfo(callback?: HandleTilesetInfoFinished): Promise<TilesetInfo | undefined>;
    fetchTilesDebounced(receivedTiles: (tiles: Record<string, TileType>) => void, tileIds: string[]): Promise<Record<string, TileType>>;
    dataConfig: DataConfig;
}
export type TilesRequest = {
    id: string;
    tileIds: Array<string>;
    server: string;
    options?: Record<string, any>;
};
export type TilesetInfoRequest = {
    server: string;
    tilesetUid: string;
};
export type RegisterTilesetRequest = {
    server: string;
    url: string;
    filetype: string;
    coordSystem?: string;
};
export type TileSource<T> = {
    fetchTiles: (request: TilesRequest) => Promise<Record<string, T>>;
    fetchTilesetInfo: (request: TilesetInfoRequest) => Promise<Record<string, TilesetInfo>>;
    registerTileset: (request: RegisterTilesetRequest) => Promise<Response>;
};
export {};