@jbrowse/core 4.3.0 → 5.0.0-beta.2

package/esm/ReExports/DataGrid.d.ts

@@ -1 +0,0 @@
-export { DataGrid as default } from '@mui/x-data-grid';

package/esm/ReExports/DataGrid.js

@@ -1 +0,0 @@
-export { DataGrid as default } from '@mui/x-data-grid';

package/esm/configuration/util.d.ts

@@ -1,10 +0,0 @@
-import type { AnyConfigurationModel, AnyConfigurationSchemaType, ConfigurationSchemaForModel, ConfigurationSlotName } from './types.ts';
-export declare function readConfObject<CONFMODEL extends AnyConfigurationModel>(confObject: CONFMODEL, slotPath?: ConfigurationSlotName<ConfigurationSchemaForModel<CONFMODEL>> | string[], args?: Record<string, unknown>): any;
-export declare function getConf<CONFMODEL extends AnyConfigurationModel>(model: {
-    configuration: CONFMODEL;
-}, slotPath?: Parameters<typeof readConfObject<CONFMODEL>>[1], args?: Parameters<typeof readConfObject<CONFMODEL>>[2]): any;
-export declare function getTypeNamesFromExplicitlyTypedUnion(maybeUnionType: unknown): string[];
-export declare function isBareConfigurationSchemaType(thing: unknown): thing is AnyConfigurationSchemaType;
-export declare function isConfigurationSchemaType(thing: unknown): thing is AnyConfigurationSchemaType;
-export declare function isConfigurationModel(thing: unknown): thing is AnyConfigurationModel;
-export declare function isConfigurationSlotType(thing: unknown): thing is object & Record<"isJBrowseConfigurationSlot", unknown>;

package/esm/configuration/util.js

@@ -1,123 +0,0 @@
-import { getSnapshot, getType, isArrayType, isLateType, isMapType, isModelType, isOptionalType, isStateTreeNode, isType, isUnionType, } from '@jbrowse/mobx-state-tree';
-function isConfigSlot(slot) {
-    return typeof slot?.getValue === 'function';
-}
-import { getDefaultValue, getSubType, getUnionSubTypes, resolveLateType, } from "../util/mst-reflection.js";
-export function readConfObject(confObject, slotPath, args = {}) {
-    if (!slotPath) {
-        return isStateTreeNode(confObject)
-            ? structuredClone(getSnapshot(confObject))
-            : structuredClone(confObject);
-    }
-    else if (typeof slotPath === 'string') {
-        let slot = confObject[slotPath];
-        if (!slot) {
-            if (isStateTreeNode(confObject) && isMapType(getType(confObject))) {
-                slot = confObject.get(slotPath);
-            }
-            if (!slot) {
-                return undefined;
-            }
-        }
-        const val = isConfigSlot(slot) ? slot.getValue(args) : slot;
-        if (val === null || typeof val !== 'object') {
-            return val;
-        }
-        return isStateTreeNode(val) ? structuredClone(getSnapshot(val)) : val;
-    }
-    else if (Array.isArray(slotPath)) {
-        const slotName = slotPath[0];
-        if (slotPath.length > 1) {
-            const newPath = slotPath.slice(1);
-            let subConf = confObject[slotName];
-            if (!subConf &&
-                isStateTreeNode(confObject) &&
-                isMapType(getType(confObject))) {
-                subConf = confObject.get(slotName);
-            }
-            return subConf ? readConfObject(subConf, newPath, args) : undefined;
-        }
-        return readConfObject(confObject, slotName, args);
-    }
-    throw new TypeError('slotPath must be a string or array');
-}
-export function getConf(model, slotPath, args) {
-    return readConfObject(model.configuration, slotPath, args);
-}
-export function getTypeNamesFromExplicitlyTypedUnion(maybeUnionType) {
-    if (isType(maybeUnionType)) {
-        maybeUnionType = resolveLateType(maybeUnionType);
-        if (isUnionType(maybeUnionType)) {
-            const typeNames = [];
-            for (let type of getUnionSubTypes(maybeUnionType)) {
-                type = resolveLateType(type);
-                let typeName = getTypeNamesFromExplicitlyTypedUnion(type);
-                if (!typeName.length) {
-                    const def = getDefaultValue(type);
-                    typeName = [def.type];
-                }
-                if (!typeName[0]) {
-                    throw new Error(`invalid config schema type ${type}`);
-                }
-                typeNames.push(...typeName);
-            }
-            return typeNames;
-        }
-    }
-    return [];
-}
-export function isBareConfigurationSchemaType(thing) {
-    if (isType(thing)) {
-        if (isModelType(thing) &&
-            ('isJBrowseConfigurationSchema' in thing ||
-                thing.name.includes('ConfigurationSchema'))) {
-            return true;
-        }
-        if (isLateType(thing)) {
-            return true;
-        }
-    }
-    return false;
-}
-export function isConfigurationSchemaType(thing) {
-    if (!isType(thing)) {
-        return false;
-    }
-    else if (isBareConfigurationSchemaType(thing)) {
-        return true;
-    }
-    else if (isUnionType(thing)) {
-        return getUnionSubTypes(thing).every(t => isConfigurationSchemaType(t) || t.name === 'undefined');
-    }
-    else if (isOptionalType(thing) &&
-        isConfigurationSchemaType(getSubType(thing))) {
-        return true;
-    }
-    else if (isArrayType(thing) &&
-        isConfigurationSchemaType(getSubType(thing))) {
-        return true;
-    }
-    else if (isMapType(thing) && isConfigurationSchemaType(getSubType(thing))) {
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-const configurationModelCache = new WeakMap();
-export function isConfigurationModel(thing) {
-    if (!thing || typeof thing !== 'object') {
-        return false;
-    }
-    let cached = configurationModelCache.get(thing);
-    if (cached === undefined) {
-        cached = isStateTreeNode(thing) && isConfigurationSchemaType(getType(thing));
-        configurationModelCache.set(thing, cached);
-    }
-    return cached;
-}
-export function isConfigurationSlotType(thing) {
-    return (typeof thing === 'object' &&
-        thing !== null &&
-        'isJBrowseConfigurationSlot' in thing);
-}

package/esm/data_adapters/BaseAdapter/BaseOptions.d.ts

@@ -1,18 +0,0 @@
-import type { StopToken } from '../../util/stopToken.ts';
-export interface BaseOptions {
-    stopToken?: StopToken;
-    bpPerPx?: number;
-    sessionId?: string;
-    trackInstanceId?: string;
-    statusCallback?: (message: string) => void;
-    headers?: Record<string, string>;
-    statsEstimationMode?: boolean;
-}
-export type SearchType = 'full' | 'prefix' | 'exact';
-export interface BaseTextSearchArgs {
-    queryString: string;
-    searchType?: SearchType;
-    stopToken?: StopToken;
-    limit?: number;
-    pageNumber?: number;
-}

package/esm/data_adapters/util.d.ts

@@ -1 +0,0 @@
-export declare function adapterConfigCacheKey(conf?: Record<string, unknown>): string;

package/esm/data_adapters/util.js

@@ -1,6 +0,0 @@
-import idMaker from "../util/idMaker.js";
-export function adapterConfigCacheKey(conf = {}) {
-    return conf.type && conf.adapterId
-        ? `${conf.type}-${conf.adapterId}`
-        : `${idMaker(conf)}`;
-}

package/esm/pluggableElementTypes/GlyphType.d.ts

@@ -1,43 +0,0 @@
-import PluggableElementBase from './PluggableElementBase.ts';
-import type { AnyConfigurationModel } from '../configuration/index.ts';
-import type { Feature, Region } from '../util/index.ts';
-import type { Theme } from '@mui/material';
-export interface GlyphRenderContext {
-    ctx: CanvasRenderingContext2D;
-    feature: Feature;
-    featureLayout: GlyphFeatureLayout;
-    region: Region;
-    bpPerPx: number;
-    config: AnyConfigurationModel;
-    theme: Theme;
-    reversed: boolean;
-    topLevel: boolean;
-    canvasWidth: number;
-}
-export interface GlyphFeatureLayout {
-    feature: Feature;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    children: GlyphFeatureLayout[];
-}
-export interface GlyphArgs {
-    name: string;
-    displayName?: string;
-    draw: (context: GlyphRenderContext) => void;
-    getChildFeatures?: (feature: Feature, config: AnyConfigurationModel) => Feature[];
-    getHeightMultiplier?: (feature: Feature, config: AnyConfigurationModel) => number;
-    getSubfeatureMouseover?: (childFeature: Feature) => string | undefined;
-    match?: (feature: Feature) => boolean;
-    priority?: number;
-}
-export default class GlyphType extends PluggableElementBase {
-    draw: (context: GlyphRenderContext) => void;
-    getChildFeatures?: (feature: Feature, config: AnyConfigurationModel) => Feature[];
-    getHeightMultiplier?: (feature: Feature, config: AnyConfigurationModel) => number;
-    getSubfeatureMouseover?: (childFeature: Feature) => string | undefined;
-    match?: (feature: Feature) => boolean;
-    priority: number;
-    constructor(args: GlyphArgs);
-}

package/esm/pluggableElementTypes/GlyphType.js

@@ -1,18 +0,0 @@
-import PluggableElementBase from "./PluggableElementBase.js";
-export default class GlyphType extends PluggableElementBase {
-    draw;
-    getChildFeatures;
-    getHeightMultiplier;
-    getSubfeatureMouseover;
-    match;
-    priority;
-    constructor(args) {
-        super(args);
-        this.draw = args.draw;
-        this.getChildFeatures = args.getChildFeatures;
-        this.getHeightMultiplier = args.getHeightMultiplier;
-        this.getSubfeatureMouseover = args.getSubfeatureMouseover;
-        this.match = args.match;
-        this.priority = args.priority ?? 0;
-    }
-}

package/esm/pluggableElementTypes/models/saveTrackFileTypes/fetchSequence.d.ts

@@ -1,5 +0,0 @@
-import type { AbstractSessionModel, Region } from '../../../util/index.ts';
-export declare function fetchSequence({ session, region, }: {
-    session: AbstractSessionModel;
-    region: Region;
-}): Promise<string | undefined>;

package/esm/pluggableElementTypes/models/saveTrackFileTypes/fetchSequence.js

@@ -1,17 +0,0 @@
-import { getConf } from "../../../configuration/index.js";
-export async function fetchSequence({ session, region, }) {
-    const { rpcManager, assemblyManager } = session;
-    const assembly = assemblyManager.get(region.assemblyName);
-    if (!assembly) {
-        throw new Error(`assembly ${region.assemblyName} not found`);
-    }
-    const sessionId = 'getSequence';
-    return rpcManager.call(sessionId, 'CoreGetSequence', {
-        adapterConfig: getConf(assembly, ['sequence', 'adapter']),
-        region: {
-            ...region,
-            refName: assembly.getCanonicalRefName(region.refName),
-        },
-        sessionId,
-    });
-}

package/esm/pluggableElementTypes/renderers/BoxRendererType.d.ts

@@ -1,52 +0,0 @@
-import FeatureRendererType from './FeatureRendererType.ts';
-import PrecomputedLayout from '../../util/layouts/PrecomputedLayout.ts';
-import type { RenderArgs as FeatureRenderArgs, RenderArgsDeserialized as FeatureRenderArgsDeserialized, RenderArgsSerialized as FeatureRenderArgsSerialized, RenderResults as FeatureRenderResults, ResultsDeserialized as FeatureResultsDeserialized, ResultsSerialized as FeatureResultsSerialized } from './FeatureRendererType.ts';
-import type { LayoutSessionLike, LayoutSessionProps } from './LayoutSession.ts';
-import type { RenderReturn } from './RendererType.tsx';
-import type RpcManager from '../../rpc/RpcManager.ts';
-import type { Feature, Region } from '../../util/index.ts';
-import type { BaseLayout, SerializedLayout } from '../../util/layouts/BaseLayout.ts';
-export interface RenderArgs extends FeatureRenderArgs {
-    bpPerPx: number;
-    trackInstanceId: string;
-}
-export interface RenderArgsSerialized extends FeatureRenderArgsSerialized {
-    bpPerPx: number;
-}
-export interface RenderArgsDeserialized extends FeatureRenderArgsDeserialized {
-    statusCallback?: (arg: string) => void;
-    bpPerPx: number;
-    trackInstanceId: string;
-}
-export interface RenderResults extends FeatureRenderResults {
-    layout?: BaseLayout<Feature> | SerializedLayout;
-}
-export interface ResultsSerialized extends FeatureResultsSerialized {
-    maxHeightReached: boolean;
-    layout: SerializedLayout;
-}
-export interface ResultsDeserialized extends FeatureResultsDeserialized {
-    maxHeightReached: boolean;
-    layout: PrecomputedLayout<string>;
-}
-export default class BoxRendererType extends FeatureRendererType {
-    layoutSessions: Record<string, LayoutSessionLike>;
-    createLayoutSession(props: LayoutSessionProps): LayoutSessionLike;
-    getLayoutSession(props: {
-        sessionId: string;
-        trackInstanceId: string;
-    }): LayoutSessionLike | undefined;
-    getWorkerSession(props: LayoutSessionProps & {
-        sessionId: string;
-        trackInstanceId: string;
-    }): LayoutSessionLike;
-    getExpandedRegion(region: Region, renderArgs: RenderArgsDeserialized): Region;
-    freeResources(args: RenderArgs): void;
-    freeResourcesInClient(rpcManager: RpcManager, args: RenderArgs): Promise<void>;
-    deserializeLayoutInClient(json: SerializedLayout): PrecomputedLayout<unknown>;
-    deserializeResultsInClient(result: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
-    createLayoutInWorker(args: RenderArgsDeserialized): BaseLayout<unknown>;
-    serializeLayout(layout: BaseLayout<unknown>, args: RenderArgsDeserialized): SerializedLayout;
-    render(renderArgs: RenderArgsDeserialized): Promise<RenderReturn>;
-    serializeResultsInWorker(results: RenderResults, args: RenderArgsDeserialized): ResultsSerialized;
-}

package/esm/pluggableElementTypes/renderers/BoxRendererType.js

@@ -1,78 +0,0 @@
-import FeatureRendererType from "./FeatureRendererType.js";
-import { LayoutSession } from "./LayoutSession.js";
-import { expandRegion } from "./util.js";
-import { readConfObject } from "../../configuration/index.js";
-import { getLayoutId } from "../../util/index.js";
-import PrecomputedLayout from "../../util/layouts/PrecomputedLayout.js";
-export default class BoxRendererType extends FeatureRendererType {
-    layoutSessions = {};
-    createLayoutSession(props) {
-        return new LayoutSession(props);
-    }
-    getLayoutSession(props) {
-        return this.layoutSessions[getLayoutId(props)];
-    }
-    getWorkerSession(props) {
-        const key = getLayoutId(props);
-        if (!this.layoutSessions[key]) {
-            this.layoutSessions[key] = this.createLayoutSession(props);
-        }
-        return this.layoutSessions[key].update(props);
-    }
-    getExpandedRegion(region, renderArgs) {
-        const { bpPerPx, config } = renderArgs;
-        const maxFeatureGlyphExpansion = readConfObject(config, 'maxFeatureGlyphExpansion') || 0;
-        const bpExpansion = Math.round(maxFeatureGlyphExpansion * bpPerPx);
-        return expandRegion(region, bpExpansion);
-    }
-    freeResources(args) {
-        const key = getLayoutId(args);
-        const session = this.layoutSessions[key];
-        if (session) {
-            const region = args.regions[0];
-            session.layout.discardRange(region.refName, region.start, region.end);
-        }
-    }
-    async freeResourcesInClient(rpcManager, args) {
-        this.freeResources(args);
-        return super.freeResourcesInClient(rpcManager, args);
-    }
-    deserializeLayoutInClient(json) {
-        return new PrecomputedLayout(json);
-    }
-    deserializeResultsInClient(result, args) {
-        const layout = this.deserializeLayoutInClient(result.layout);
-        return super.deserializeResultsInClient({
-            ...result,
-            layout,
-        }, args);
-    }
-    createLayoutInWorker(args) {
-        const { regions } = args;
-        const { layout } = this.getWorkerSession(args);
-        return layout.getSublayout(regions[0].refName);
-    }
-    serializeLayout(layout, args) {
-        const region = args.regions[0];
-        return layout.serializeRegion(this.getExpandedRegion(region, args));
-    }
-    async render(renderArgs) {
-        const features = await this.getFeatures(renderArgs);
-        const layout = this.createLayoutInWorker(renderArgs);
-        return { features, layout };
-    }
-    serializeResultsInWorker(results, args) {
-        const { features, ...rest } = super.serializeResultsInWorker(results, args);
-        const region = args.regions[0];
-        const resultLayout = results.layout;
-        const layout = resultLayout && 'serializeRegion' in resultLayout
-            ? resultLayout.serializeRegion(this.getExpandedRegion(region, args))
-            : resultLayout;
-        return {
-            ...rest,
-            layout,
-            maxHeightReached: layout.maxHeightReached,
-            features: features?.filter(f => !!layout.rectangles[f.uniqueId]),
-        };
-    }
-}

package/esm/pluggableElementTypes/renderers/CircularChordRendererType.d.ts

@@ -1,4 +0,0 @@
-import FeatureRenderer from './FeatureRendererType.ts';
-export default class CircularChordRendererType extends FeatureRenderer {
-    supportsSVG: boolean;
-}

package/esm/pluggableElementTypes/renderers/CircularChordRendererType.js

@@ -1,4 +0,0 @@
-import FeatureRenderer from "./FeatureRendererType.js";
-export default class CircularChordRendererType extends FeatureRenderer {
-    supportsSVG = true;
-}

package/esm/pluggableElementTypes/renderers/FeatureRendererType.d.ts

@@ -1,58 +0,0 @@
-import ServerSideRendererType from './ServerSideRendererType.ts';
-import type { RenderArgs as ServerSideRenderArgs, RenderArgsDeserialized as ServerSideRenderArgsDeserialized, RenderArgsSerialized as ServerSideRenderArgsSerialized, RenderResults as ServerSideRenderResults, RenderReturn, ResultsDeserialized as ServerSideResultsDeserialized, ResultsSerialized as ServerSideResultsSerialized } from './ServerSideRendererType.ts';
-import type { AnyConfigurationModel } from '../../configuration/index.ts';
-import type { Feature, SimpleFeatureSerialized } from '../../util/simpleFeature.ts';
-import type { AugmentedRegion as Region } from '../../util/types/index.ts';
-export interface RenderArgs extends ServerSideRenderArgs {
-    displayModel?: {
-        id: string;
-        selectedFeatureId?: string;
-    };
-    regions: Region[];
-    blockKey: string;
-}
-export interface RenderArgsSerialized extends ServerSideRenderArgsSerialized {
-    displayModel?: {
-        id: string;
-        selectedFeatureId?: string;
-    };
-    regions: Region[];
-    blockKey: string;
-}
-export interface RenderArgsDeserialized extends ServerSideRenderArgsDeserialized {
-    displayModel: {
-        id: string;
-        selectedFeatureId?: string;
-    };
-    regions: Region[];
-    blockKey: string;
-    adapterConfig: AnyConfigurationModel;
-}
-export interface RenderResults extends ServerSideRenderResults {
-    features?: Map<string, Feature>;
-}
-export interface ResultsSerialized extends ServerSideResultsSerialized {
-    features?: SimpleFeatureSerialized[];
-}
-export interface ResultsDeserialized extends ServerSideResultsDeserialized {
-    features: Map<string, Feature>;
-    blockKey: string;
-}
-export default class FeatureRendererType extends ServerSideRendererType {
-    renderDirect(args: RenderArgs): Promise<{
-        blockKey: string;
-        reactElement?: React.ReactElement;
-        html?: string;
-    } | {
-        blockKey: string;
-        reactElement: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | undefined;
-        html?: string;
-    }>;
-    serializeArgsInClient(args: RenderArgs): ServerSideRenderArgsSerialized;
-    deserializeResultsInClient(result: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
-    serializeResultsInWorker(result: RenderResults, args: RenderArgsDeserialized): ResultsSerialized;
-    getExpandedRegion(region: Region, _renderArgs: RenderArgsDeserialized): Region;
-    getFeatures(renderArgs: RenderArgsDeserialized): Promise<Map<string, Feature>>;
-    featurePassesFilters(renderArgs: RenderArgsDeserialized, feature: Feature): boolean;
-    render(renderArgs: RenderArgsDeserialized): Promise<RenderReturn>;
-}

package/esm/pluggableElementTypes/renderers/FeatureRendererType.js

@@ -1,77 +0,0 @@
-import { firstValueFrom } from 'rxjs';
-import { toArray } from 'rxjs/operators';
-import ServerSideRendererType from "./ServerSideRendererType.js";
-import { normalizeRegion } from "./util.js";
-import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import { iterMap } from "../../util/index.js";
-import SimpleFeature from "../../util/simpleFeature.js";
-export default class FeatureRendererType extends ServerSideRendererType {
-    async renderDirect(args) {
-        const result = await super.renderDirect(args);
-        return {
-            ...result,
-            blockKey: args.blockKey,
-        };
-    }
-    serializeArgsInClient(args) {
-        return super.serializeArgsInClient({
-            ...args,
-            displayModel: undefined,
-            regions: structuredClone(args.regions),
-        });
-    }
-    deserializeResultsInClient(result, args) {
-        const deserializedFeatures = new Map(result.features
-            ?.map(f => SimpleFeature.fromJSON(f))
-            .map(f => [f.id(), f]));
-        const deserialized = super.deserializeResultsInClient({
-            ...result,
-            features: deserializedFeatures,
-        }, args);
-        return {
-            ...deserialized,
-            blockKey: args.blockKey,
-            features: deserializedFeatures,
-        };
-    }
-    serializeResultsInWorker(result, args) {
-        const serialized = super.serializeResultsInWorker(result, args);
-        const { features } = result;
-        return {
-            ...serialized,
-            features: features instanceof Map
-                ? iterMap(features.values(), f => f.toJSON(), features.size)
-                : undefined,
-        };
-    }
-    getExpandedRegion(region, _renderArgs) {
-        return region;
-    }
-    async getFeatures(renderArgs) {
-        const pm = this.pluginManager;
-        const { regions, sessionId, adapterConfig } = renderArgs;
-        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
-        if (!isFeatureAdapter(dataAdapter)) {
-            throw new Error('Adapter does not support retrieving features');
-        }
-        const requestRegions = regions.map(r => normalizeRegion(r));
-        const featureObservable = requestRegions.length === 1
-            ? dataAdapter.getFeatures(this.getExpandedRegion(requestRegions[0], renderArgs), renderArgs)
-            : dataAdapter.getFeaturesInMultipleRegions(requestRegions, renderArgs);
-        const feats = await firstValueFrom(featureObservable.pipe(toArray()));
-        return new Map(feats
-            .filter(feat => this.featurePassesFilters(renderArgs, feat))
-            .map(feat => [feat.id(), feat]));
-    }
-    featurePassesFilters(renderArgs, feature) {
-        return renderArgs.filters
-            ? renderArgs.filters.passes(feature, renderArgs)
-            : true;
-    }
-    async render(renderArgs) {
-        const features = await this.getFeatures(renderArgs);
-        const result = await super.render({ ...renderArgs, features });
-        return { ...result, features };
-    }
-}

package/esm/pluggableElementTypes/renderers/LayoutSession.d.ts

@@ -1,31 +0,0 @@
-import GranularRectLayout from '../../util/layouts/GranularRectLayout.ts';
-import MultiLayout from '../../util/layouts/MultiLayout.ts';
-import type SerializableFilterChain from './util/serializableFilterChain.ts';
-import type { AnyConfigurationModel } from '../../configuration/index.ts';
-import type { Region } from '../../util/index.ts';
-import type { BaseLayout } from '../../util/layouts/index.ts';
-export interface LayoutSessionProps {
-    regions: Region[];
-    config: AnyConfigurationModel;
-    bpPerPx: number;
-    filters?: SerializableFilterChain;
-}
-export type BaseMultiLayout = MultiLayout<BaseLayout<unknown>, unknown>;
-export type MyMultiLayout = MultiLayout<GranularRectLayout<unknown>, unknown>;
-export interface CachedLayout {
-    layout: BaseMultiLayout;
-    props: LayoutSessionProps;
-}
-export interface LayoutSessionLike {
-    layout: BaseMultiLayout;
-    update(props: LayoutSessionProps): LayoutSessionLike;
-}
-export declare class LayoutSession implements LayoutSessionLike {
-    props: LayoutSessionProps;
-    cachedLayout: CachedLayout | undefined;
-    constructor(props: LayoutSessionProps);
-    update(props: LayoutSessionProps): this;
-    makeLayout(): MultiLayout<GranularRectLayout<unknown>, unknown>;
-    cachedLayoutIsValid(cachedLayout: CachedLayout): boolean;
-    get layout(): BaseMultiLayout;
-}

package/esm/pluggableElementTypes/renderers/LayoutSession.js

@@ -1,40 +0,0 @@
-import deepEqual from 'fast-deep-equal';
-import { readConfObject } from "../../configuration/index.js";
-import GranularRectLayout from "../../util/layouts/GranularRectLayout.js";
-import MultiLayout from "../../util/layouts/MultiLayout.js";
-export class LayoutSession {
-    props;
-    cachedLayout;
-    constructor(props) {
-        this.props = props;
-    }
-    update(props) {
-        this.props = props;
-        return this;
-    }
-    makeLayout() {
-        return new MultiLayout(GranularRectLayout, {
-            maxHeight: readConfObject(this.props.config, 'maxHeight'),
-            displayMode: readConfObject(this.props.config, 'displayMode'),
-            pitchX: this.props.bpPerPx,
-            pitchY: readConfObject(this.props.config, 'noSpacing') ? 1 : 3,
-        });
-    }
-    cachedLayoutIsValid(cachedLayout) {
-        const bpPerPxMatch = cachedLayout.props.bpPerPx === this.props.bpPerPx;
-        const currentConfig = readConfObject(this.props.config);
-        const cachedConfig = readConfObject(cachedLayout.props.config);
-        const configMatch = deepEqual(currentConfig, cachedConfig);
-        const filtersMatch = deepEqual(this.props.filters, cachedLayout.props.filters);
-        return bpPerPxMatch && configMatch && filtersMatch;
-    }
-    get layout() {
-        if (!this.cachedLayout || !this.cachedLayoutIsValid(this.cachedLayout)) {
-            this.cachedLayout = {
-                layout: this.makeLayout(),
-                props: this.props,
-            };
-        }
-        return this.cachedLayout.layout;
-    }
-}

package/esm/pluggableElementTypes/renderers/RendererType.d.ts

@@ -1,28 +0,0 @@
-import type React from 'react';
-import PluggableElementBase from '../PluggableElementBase.ts';
-import type PluginManager from '../../PluginManager.ts';
-import type { AnyConfigurationSchemaType } from '../../configuration/index.ts';
-import type { AnyReactComponentType } from '../../util/index.ts';
-import type { RpcResult } from '../../util/librpc.ts';
-export type RenderProps = Record<string, unknown>;
-export interface RenderResults {
-    reactElement?: React.ReactElement;
-    html?: string;
-    [key: string]: unknown;
-}
-export type RenderReturn = RenderResults | RpcResult;
-export default class RendererType extends PluggableElementBase {
-    ReactComponent: AnyReactComponentType;
-    supportsSVG: boolean;
-    configSchema: AnyConfigurationSchemaType;
-    pluginManager: PluginManager;
-    constructor(stuff: {
-        name: string;
-        ReactComponent: AnyReactComponentType;
-        displayName?: string;
-        configSchema: AnyConfigurationSchemaType;
-        pluginManager: PluginManager;
-    });
-    render(props: RenderProps): Promise<RenderReturn>;
-    freeResources(_args: any): void;
-}

package/esm/pluggableElementTypes/renderers/RendererType.js

@@ -1,20 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import PluggableElementBase from "../PluggableElementBase.js";
-export default class RendererType extends PluggableElementBase {
-    ReactComponent;
-    supportsSVG = true;
-    configSchema;
-    pluginManager;
-    constructor(stuff) {
-        super(stuff);
-        this.ReactComponent = stuff.ReactComponent;
-        this.configSchema = stuff.configSchema;
-        this.pluginManager = stuff.pluginManager;
-    }
-    async render(props) {
-        return {
-            reactElement: _jsx(this.ReactComponent, { ...props }),
-        };
-    }
-    freeResources(_args) { }
-}