@jbrowse/core 5.0.0-beta.1 → 5.0.0-beta.11

package/esm/util/featureTransforms.d.ts

@@ -0,0 +1,81 @@
+import type { FeatureTable } from './featureTable.ts';
+import type { JexlInstance } from './jexlStrings.ts';
+import type { FacetSection, FacetSpec, FieldRef, TransformStep } from './markEncodingTypes.ts';
+import type { Feature } from './simpleFeature.ts';
+export { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS } from './stepTables.ts';
+export declare const DEFAULT_BIN_FIELD = "start";
+export declare const DEFAULT_FLATTEN_FIELD = "subfeatures";
+export { DEFAULT_CELLS_FIELD } from './cellsStep.ts';
+export declare const DEFAULT_COVERAGE_AS = "coverage";
+export declare const DEFAULT_PILEUP_AS = "row";
+export declare const DEFAULT_PILEUP_FIELDS: [string, string];
+/**
+ * #api
+ * How a record states its other end, or undefined where it states none: the
+ * `mate` a paired adapter fills (BEDPE, STAR-Fusion), an `ALT` the breakend
+ * and symbolic-SV readers resolve, or a read's `next_ref` and `next_pos`. The
+ * `mate` step admits exactly the features this names one for, so a caller
+ * deciding whether links are the picture a track wants asks here rather than
+ * re-reading the fields.
+ */
+export declare function matedBy(f: Feature): "alt" | "mate" | "pair" | undefined;
+/**
+ * #api
+ * One layer of a faceted request: its rows in section order, and the stacked
+ * row of each, index for index.
+ */
+export interface FacetedLayer {
+    table: FeatureTable;
+    rows: Uint32Array;
+}
+/**
+ * #api
+ * A faceted request's layers: the rows split on the facet's field, the
+ * facet's own steps and then each layer's run over each section alone, and
+ * the sections stacked — a section's rows start where the one above it ends,
+ * and it is as tall as the tallest layer packed it. Every layer's rows come
+ * back in section order beside their stacked rows, so a faceted display is
+ * the unfaceted one drawn once per section, and a row is handed on as its
+ * steps left it. A layer naming no `row` field stands on each section's first
+ * row, the answer the unfaceted encoder gives it.
+ *
+ * The split is a counting sort into section order rather than a list per
+ * section: every step runs once over the ordered rows, keeping section order,
+ * and one that groups rows groups within a section.
+ */
+export declare function facetLayers(input: readonly Feature[] | FeatureTable, facet: FacetSpec, layers: readonly {
+    transform?: readonly TransformStep[];
+    row?: FieldRef;
+}[], jexl?: JexlInstance): {
+    layers: FacetedLayer[];
+    sections: FacetSection[];
+};
+/**
+ * #api
+ * Run the transform steps over a feature list or a table, in order, in the
+ * worker. The table a step answers is what the next one reads, and the last
+ * one is what the encoder walks.
+ */
+export declare function runTransforms(input: readonly Feature[] | FeatureTable, steps: readonly TransformStep[], jexl?: JexlInstance): FeatureTable;
+/**
+ * #api
+ * A layered request's rows: the shared steps, the facet's split where it
+ * names one, and each layer's own steps, with the row each layer's rows stand
+ * in — the field it names, or under a facet each row's stacked row. The split
+ * comes as early as it can: after the last shared step that must see every
+ * row, so the steps that follow it read the rows already in section order.
+ */
+export declare function layerTables(input: readonly Feature[] | FeatureTable, request: {
+    transform?: readonly TransformStep[];
+    facet?: FacetSpec;
+    layers: readonly {
+        transform?: readonly TransformStep[];
+        row?: FieldRef;
+    }[];
+}, jexl?: JexlInstance): {
+    layers: {
+        table: FeatureTable;
+        row: FieldRef | Uint32Array | undefined;
+    }[];
+    sections: FacetSection[] | undefined;
+};