react-cheminfo 0.8.0 → 0.10.0

package/lib/projection/core/projectionStrings.d.ts

@@ -0,0 +1,134 @@
+import type { ProjectionOptionId, ProjectionVariablesView } from './projectionOptions.ts';
+import type { ProjectionTab } from './projectionTabs.ts';
+/** A worked case under a piece of help: the construct, and what it does. */
+export interface ProjectionHelpExample {
+    /** The construct itself, shown in monospace. */
+    code: string;
+    /**
+     * What the construct is applied to, when showing it alone is half a
+     * demonstration.
+     * @default undefined
+     */
+    input?: string;
+    /**
+     * One line saying what the example demonstrates.
+     * @default undefined
+     */
+    note?: string;
+}
+/**
+ * Everything one option's help says.
+ *
+ * It restates the shape the help domain renders rather than importing it,
+ * because that type is declared beside a React component and every word of a
+ * viewer has to stay readable from a server. The shapes match, so a piece of
+ * help written here is handed straight to a tooltip.
+ */
+export interface ProjectionHelp {
+    /** First line, in bold: what the option is, not what its label already says. */
+    title: string;
+    /** The explanation, one or two sentences. */
+    body: string;
+    /**
+     * A concrete case, because a definition without one is what makes a reader
+     * give up.
+     * @default undefined
+     */
+    example?: ProjectionHelpExample;
+}
+/**
+ * The help behind every option's glyph.
+ *
+ * It is keyed by {@link ProjectionOptionId} rather than written as a loose
+ * list, so a control added to the floating bar cannot ship without the
+ * sentence that says what it does.
+ */
+export declare const PROJECTION_HELP: Record<ProjectionOptionId, ProjectionHelp>;
+/**
+ * The short form of each tab's name, for a bar too narrow for the long one.
+ *
+ * Written out rather than truncated, because "How much each explains" cut to
+ * the width that fits reads "How much each e…", which tells the reader less
+ * than the one word the tab is actually about.
+ */
+export declare const PROJECTION_SHORT_TAB: Record<ProjectionTab, string>;
+/** The words the settings bar writes on itself. */
+export interface ProjectionBarWords {
+    /**
+     * The one word written in front of each setting's value where the bar has
+     * room for it. One word rather than the setting's full name: the name is
+     * read once and the value every time, so `Outlines 95%` is what a reader
+     * scanning the bar needs and `Group outlines` is what the pointer is told.
+     */
+    key: {
+        /** In front of what the colour stands for. */
+        colorBy: string;
+        /** In front of how much of a group its outline covers. */
+        ellipse: string;
+        /** In front of how many components the pair grid lays out. */
+        pairCount: string;
+        /** In front of what the "what differs" panels are drawing. */
+        variablesView: string;
+        /** In front of how much of the differences is to be accounted for. */
+        shareTarget: string;
+    };
+    /**
+     * What each of the map's two name switches is called.
+     *
+     * They ride the bar as glyphs rather than words — a switch has no value to
+     * write, so a word beside it would be a caption, and four captions is the
+     * bar the ladder exists to avoid — so this is what the pointer and a screen
+     * reader are told, and it has to name the action rather than the setting.
+     */
+    switches: {
+        /** The switch that writes each group's name over its own crowd. */
+        showGroupLabels: string;
+        /** The switch that writes each sample's name beside its dot. */
+        showIds: string;
+    };
+    /** What "the colour stands for nothing" reads. */
+    uncoloured: string;
+    /** What "no outlines at all" reads where there is no room for a sentence. */
+    noOutlines: string;
+    /** What the settings gathered into one chip are called together. */
+    settings: string;
+    /**
+     * What each view of the "what differs" tab is called.
+     *
+     * They are the reader's own choice rather than the jargon, which is why
+     * `rescaled` is offered as weights in their units: a reader who has not met
+     * a loading cannot pick between four words they have never seen.
+     */
+    view: Record<ProjectionVariablesView, string>;
+}
+/** The words the settings bar writes when a site overrides nothing. */
+export declare const PROJECTION_BAR_WORDS: ProjectionBarWords;
+/**
+ * What each setting is called in the fixed name column of a settings panel.
+ *
+ * The column is eight characters wide and a name in it never wraps, so a name
+ * written in full overlaps the control it names: `One scale for all` runs into
+ * its own switch. Nothing is lost by shortening it, because the sentence the
+ * name gives up is the one the help behind the name still says in full — which
+ * is the whole point of hanging the explanation off the words.
+ */
+export declare const PROJECTION_PANEL_NAME: Record<ProjectionOptionId, string>;
+/**
+ * What each cluster of a settings panel is called, written over it in small
+ * capitals.
+ *
+ * They name the question a cluster answers rather than the settings inside it:
+ * a heading that repeats the names under it has told the reader nothing and
+ * has spent a line of the panel saying it.
+ */
+export declare const PROJECTION_PANEL_SECTION: {
+    /** Which pattern of difference each direction of the map stands for. */
+    readonly axes: "Axes";
+    /** How the marks themselves are drawn. */
+    readonly drawing: "Drawing";
+    /** What a drag over the figure does to the selection. */
+    readonly selecting: "Selecting";
+    /** What the panels of the "what differs" tab are measured against. */
+    readonly scale: "Scale";
+};
+//# sourceMappingURL=projectionStrings.d.ts.map

package/lib/projection/core/projectionStrings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectionStrings.d.ts","sourceRoot":"","sources":["../../../src/projection/core/projectionStrings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,uBAAuB,EACxB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,4EAA4E;AAC5E,MAAM,WAAW,qBAAqB;IACpC,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,gFAAgF;IAChF,KAAK,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,qBAAqB,CAAC;CACjC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,kBAAkB,EAAE,cAAc,CA6EtE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAK9D,CAAC;AAEF,mDAAmD;AACnD,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,GAAG,EAAE;QACH,8CAA8C;QAC9C,OAAO,EAAE,MAAM,CAAC;QAChB,0DAA0D;QAC1D,OAAO,EAAE,MAAM,CAAC;QAChB,8DAA8D;QAC9D,SAAS,EAAE,MAAM,CAAC;QAClB,8DAA8D;QAC9D,aAAa,EAAE,MAAM,CAAC;QACtB,sEAAsE;QACtE,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF;;;;;;;OAOG;IACH,QAAQ,EAAE;QACR,mEAAmE;QACnE,eAAe,EAAE,MAAM,CAAC;QACxB,gEAAgE;QAChE,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC,uBAAuB,EAAE,MAAM,CAAC,CAAC;CAC/C;AAED,uEAAuE;AACvE,eAAO,MAAM,oBAAoB,EAAE,kBAqBlC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAkBpE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;IACnC,wEAAwE;;IAExE,0CAA0C;;IAE1C,yDAAyD;;IAEzD,sEAAsE;;CAE9D,CAAC"}

package/lib/projection/core/projectionStrings.js

@@ -0,0 +1,168 @@
+/**
+ * The help behind every option's glyph.
+ *
+ * It is keyed by {@link ProjectionOptionId} rather than written as a loose
+ * list, so a control added to the floating bar cannot ship without the
+ * sentence that says what it does.
+ */
+export const PROJECTION_HELP = {
+    xAxis: {
+        title: 'Across',
+        body: 'Which pattern of difference runs left to right. The first one is the strongest.',
+    },
+    yAxis: {
+        title: 'Up',
+        body: 'Which pattern of difference runs bottom to top.',
+    },
+    colorBy: {
+        title: 'Colour by',
+        body: 'What a dot’s colour stands for. Colouring by nothing is useful when the groups are what you are trying to find rather than what you already know.',
+    },
+    ellipse: {
+        title: 'Group outlines',
+        body: 'Each outline is drawn to cover about that share of its group’s samples, assuming the group is roughly bell-shaped. It is a summary of where a group sits, not a boundary.',
+        example: {
+            code: '95% of samples',
+            note: 'Two standard deviations is often assumed to mean 95%. On a map it covers 86%, which is why the choices here are written as shares.',
+        },
+    },
+    pointRadius: {
+        title: 'Dot size',
+        body: 'Smaller dots for a crowded map, larger ones for a sparse one or a projector.',
+    },
+    showGroupMeans: {
+        title: 'Group averages',
+        body: 'Marks the average position of each group with a cross. A sample far from its own cross is the one the grouping fits worst.',
+    },
+    showGroupLabels: {
+        title: 'Category names',
+        body: 'Writes each group’s name once, over the middle of that group. Names that would land on each other are moved aside, with a line back to the crowd they name, and one with nowhere left to go is dropped rather than written over another. Past a handful of groups the key runs out of room and this is the only way to tell which crowd is which without counting colours.',
+    },
+    showIds: {
+        title: 'Sample names',
+        body: 'Writes every sample’s own name beside its dot. It is what turns a dot sitting on its own into something you can go and look up. In a crowd there is only room for some of the names, so the ones that do not fit are left out rather than written over each other.',
+        example: {
+            code: '0326_3a',
+            note: 'The name is whatever you handed in as the sample’s id, so it is the one you can find again in your own files.',
+        },
+    },
+    pairCount: {
+        title: 'Components',
+        body: 'How many components the grid lays out, up to six. Past that the cells get too small to read, so the grid drops one on its own when the panel is narrow.',
+    },
+    variablesView: {
+        title: 'Show',
+        body: 'What each panel draws. "Effect on a sample" is the only one you can read without knowing how the maths works: it shows what a sample at each end of this component actually looks like.',
+    },
+    variablesCount: {
+        title: 'Panels',
+        body: 'How many components to draw. The later ones usually carry noise rather than a pattern.',
+    },
+    sharedScale: {
+        title: 'One scale for all',
+        body: 'Draws every panel on the same vertical scale, so a component that accounts for two per cent of the differences looks small. Fitting each panel to itself makes it look as important as the first.',
+    },
+    showAverage: {
+        title: 'Average sample',
+        body: 'Draws the average of all your samples faintly behind each panel. Without it you cannot tell which peak a wiggle belongs to.',
+    },
+    spread: {
+        title: 'How far',
+        body: 'How far along the component the average sample is pushed. Two standard deviations reaches past most of your samples in both directions.',
+    },
+    variableOrder: {
+        title: 'Bar order',
+        body: 'Keep your column order so the panels line up and can be read down a column, or sort each panel by how heavily that component leans on each measurement.',
+    },
+    shareTarget: {
+        title: 'Target',
+        body: 'Marks how many components you need before they account for this much of the differences. Set it to zero to draw no marker.',
+    },
+    selectMode: {
+        title: 'Drag does',
+        body: 'What a plain drag does to what is already selected. Holding shift always adds and holding alt always removes, whatever this says.',
+    },
+};
+/**
+ * The short form of each tab's name, for a bar too narrow for the long one.
+ *
+ * Written out rather than truncated, because "How much each explains" cut to
+ * the width that fits reads "How much each e…", which tells the reader less
+ * than the one word the tab is actually about.
+ */
+export const PROJECTION_SHORT_TAB = {
+    map: 'Map',
+    pairs: 'Pairs',
+    variables: 'Differs',
+    shares: 'Explains',
+};
+/** The words the settings bar writes when a site overrides nothing. */
+export const PROJECTION_BAR_WORDS = {
+    key: {
+        colorBy: 'Colour',
+        ellipse: 'Outlines',
+        pairCount: 'Components',
+        variablesView: 'Show',
+        shareTarget: 'Target',
+    },
+    switches: {
+        showGroupLabels: 'Show category',
+        showIds: 'Show sample ID',
+    },
+    uncoloured: 'Nothing',
+    noOutlines: 'None',
+    settings: 'How this is drawn',
+    view: {
+        effect: 'Effect on a sample',
+        weights: 'Weights',
+        rescaled: 'Weights in your units',
+        sample: 'Selected sample',
+    },
+};
+/**
+ * What each setting is called in the fixed name column of a settings panel.
+ *
+ * The column is eight characters wide and a name in it never wraps, so a name
+ * written in full overlaps the control it names: `One scale for all` runs into
+ * its own switch. Nothing is lost by shortening it, because the sentence the
+ * name gives up is the one the help behind the name still says in full — which
+ * is the whole point of hanging the explanation off the words.
+ */
+export const PROJECTION_PANEL_NAME = {
+    xAxis: 'Across',
+    yAxis: 'Up',
+    colorBy: 'Colour by',
+    ellipse: 'Outlines',
+    pointRadius: 'Dot size',
+    showGroupMeans: 'Averages',
+    showGroupLabels: 'Category',
+    showIds: 'Sample ID',
+    pairCount: 'Components',
+    variablesView: 'Show',
+    variablesCount: 'Panels',
+    sharedScale: 'One scale',
+    showAverage: 'Average',
+    spread: 'How far',
+    variableOrder: 'Bar order',
+    shareTarget: 'Target',
+    selectMode: 'Drag does',
+};
+/**
+ * What each cluster of a settings panel is called, written over it in small
+ * capitals.
+ *
+ * They name the question a cluster answers rather than the settings inside it:
+ * a heading that repeats the names under it has told the reader nothing and
+ * has spent a line of the panel saying it.
+ */
+export const PROJECTION_PANEL_SECTION = {
+    /** Which pattern of difference each direction of the map stands for. */
+    axes: 'Axes',
+    /** How the marks themselves are drawn. */
+    drawing: 'Drawing',
+    /** What a drag over the figure does to the selection. */
+    selecting: 'Selecting',
+    /** What the panels of the "what differs" tab are measured against. */
+    scale: 'Scale',
+};
+//# sourceMappingURL=projectionStrings.js.map

package/lib/projection/core/projectionStrings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectionStrings.js","sourceRoot":"","sources":["../../../src/projection/core/projectionStrings.ts"],"names":[],"mappings":"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"}

package/lib/projection/core/projectionTabDefaults.d.ts

@@ -0,0 +1,18 @@
+import type { ProjectionOptions } from './projectionOptions.ts';
+import type { ProjectionTab } from './projectionTabs.ts';
+/**
+ * The settings each tab owns, back at the values the figure came with.
+ *
+ * A panel offers a way back, and it has to be the way back from *its* figure
+ * rather than from all four: a reader who has spent a minute on the pair grid
+ * and presses Reset there expects the grid to return, not the map's axes to
+ * move behind their back. So each tab lists exactly the options it reads, and
+ * the patch a panel sends touches nothing else.
+ *
+ * A tab lists an option it shares with another — the colour, the outlines —
+ * because it genuinely draws with it; sharing is what makes the two figures
+ * read as one picture, and a reset that skipped the shared settings would
+ * leave the tab half restored.
+ */
+export declare const PROJECTION_TAB_DEFAULTS: Record<ProjectionTab, Partial<ProjectionOptions>>;
+//# sourceMappingURL=projectionTabDefaults.d.ts.map

package/lib/projection/core/projectionTabDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectionTabDefaults.d.ts","sourceRoot":"","sources":["../../../src/projection/core/projectionTabDefaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,aAAa,EACb,OAAO,CAAC,iBAAiB,CAAC,CA8B3B,CAAC"}

package/lib/projection/core/projectionTabDefaults.js

@@ -0,0 +1,46 @@
+import { DEFAULT_PROJECTION_OPTIONS } from "./projectionOptions.js";
+/**
+ * The settings each tab owns, back at the values the figure came with.
+ *
+ * A panel offers a way back, and it has to be the way back from *its* figure
+ * rather than from all four: a reader who has spent a minute on the pair grid
+ * and presses Reset there expects the grid to return, not the map's axes to
+ * move behind their back. So each tab lists exactly the options it reads, and
+ * the patch a panel sends touches nothing else.
+ *
+ * A tab lists an option it shares with another — the colour, the outlines —
+ * because it genuinely draws with it; sharing is what makes the two figures
+ * read as one picture, and a reset that skipped the shared settings would
+ * leave the tab half restored.
+ */
+export const PROJECTION_TAB_DEFAULTS = {
+    map: {
+        xAxis: DEFAULT_PROJECTION_OPTIONS.xAxis,
+        yAxis: DEFAULT_PROJECTION_OPTIONS.yAxis,
+        colorBy: DEFAULT_PROJECTION_OPTIONS.colorBy,
+        ellipse: DEFAULT_PROJECTION_OPTIONS.ellipse,
+        pointRadius: DEFAULT_PROJECTION_OPTIONS.pointRadius,
+        showGroupMeans: DEFAULT_PROJECTION_OPTIONS.showGroupMeans,
+        showGroupLabels: DEFAULT_PROJECTION_OPTIONS.showGroupLabels,
+        showIds: DEFAULT_PROJECTION_OPTIONS.showIds,
+        selectMode: DEFAULT_PROJECTION_OPTIONS.selectMode,
+    },
+    pairs: {
+        pairCount: DEFAULT_PROJECTION_OPTIONS.pairCount,
+        colorBy: DEFAULT_PROJECTION_OPTIONS.colorBy,
+        ellipse: DEFAULT_PROJECTION_OPTIONS.ellipse,
+        pointRadius: DEFAULT_PROJECTION_OPTIONS.pointRadius,
+    },
+    variables: {
+        variablesView: DEFAULT_PROJECTION_OPTIONS.variablesView,
+        variablesCount: DEFAULT_PROJECTION_OPTIONS.variablesCount,
+        sharedScale: DEFAULT_PROJECTION_OPTIONS.sharedScale,
+        showAverage: DEFAULT_PROJECTION_OPTIONS.showAverage,
+        spread: DEFAULT_PROJECTION_OPTIONS.spread,
+        variableOrder: DEFAULT_PROJECTION_OPTIONS.variableOrder,
+    },
+    shares: {
+        shareTarget: DEFAULT_PROJECTION_OPTIONS.shareTarget,
+    },
+};
+//# sourceMappingURL=projectionTabDefaults.js.map

package/lib/projection/core/projectionTabDefaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectionTabDefaults.js","sourceRoot":"","sources":["../../../src/projection/core/projectionTabDefaults.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAGpE;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAGhC;IACF,GAAG,EAAE;QACH,KAAK,EAAE,0BAA0B,CAAC,KAAK;QACvC,KAAK,EAAE,0BAA0B,CAAC,KAAK;QACvC,OAAO,EAAE,0BAA0B,CAAC,OAAO;QAC3C,OAAO,EAAE,0BAA0B,CAAC,OAAO;QAC3C,WAAW,EAAE,0BAA0B,CAAC,WAAW;QACnD,cAAc,EAAE,0BAA0B,CAAC,cAAc;QACzD,eAAe,EAAE,0BAA0B,CAAC,eAAe;QAC3D,OAAO,EAAE,0BAA0B,CAAC,OAAO;QAC3C,UAAU,EAAE,0BAA0B,CAAC,UAAU;KAClD;IACD,KAAK,EAAE;QACL,SAAS,EAAE,0BAA0B,CAAC,SAAS;QAC/C,OAAO,EAAE,0BAA0B,CAAC,OAAO;QAC3C,OAAO,EAAE,0BAA0B,CAAC,OAAO;QAC3C,WAAW,EAAE,0BAA0B,CAAC,WAAW;KACpD;IACD,SAAS,EAAE;QACT,aAAa,EAAE,0BAA0B,CAAC,aAAa;QACvD,cAAc,EAAE,0BAA0B,CAAC,cAAc;QACzD,WAAW,EAAE,0BAA0B,CAAC,WAAW;QACnD,WAAW,EAAE,0BAA0B,CAAC,WAAW;QACnD,MAAM,EAAE,0BAA0B,CAAC,MAAM;QACzC,aAAa,EAAE,0BAA0B,CAAC,aAAa;KACxD;IACD,MAAM,EAAE;QACN,WAAW,EAAE,0BAA0B,CAAC,WAAW;KACpD;CACF,CAAC"}

package/lib/projection/core/projectionTabs.d.ts

@@ -0,0 +1,25 @@
+import type { ProjectionResult } from './projectionResult.ts';
+/** Which tab of a projection viewer is showing. The ids are stable, so a site may put one in its own URL. */
+export type ProjectionTab = 'map' | 'pairs' | 'variables' | 'shares';
+/**
+ * The tabs a result can actually fill.
+ *
+ * A tab is offered because the data for it exists, never because a caller
+ * remembered to ask. That is what stops a UMAP viewer from showing an empty
+ * "how much each explains" tab, and it makes a new method a data shape rather
+ * than a code change — there is no place in the viewer where a method's name
+ * is tested. The map always exists, so the answer is never empty; the shares
+ * tab needs three axes as well as a share on each, because a two-bar chart is
+ * not worth a tab.
+ * A site embedding the viewer in a page of its own may narrow the answer with
+ * `allowed`, which is the one thing that is a caller's business rather than the
+ * data's: a page that only has room for the map, or that has already explained
+ * the components in its own prose, says so. It can only ever take tabs away —
+ * naming one the result cannot fill does not conjure it.
+ * @param result - The reduced space.
+ * @param allowed - The tabs the site permits, in any order.
+ * @returns The tabs, in reading order. Never empty: the map survives every
+ * filter, because a viewer with no panel at all is not a viewer.
+ */
+export declare function projectionTabs(result: ProjectionResult, allowed?: readonly ProjectionTab[]): ProjectionTab[];
+//# sourceMappingURL=projectionTabs.d.ts.map

package/lib/projection/core/projectionTabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectionTabs.d.ts","sourceRoot":"","sources":["../../../src/projection/core/projectionTabs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9E,6GAA6G;AAC7G,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,OAAO,GAAG,WAAW,GAAG,QAAQ,CAAC;AAIrE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,gBAAgB,EACxB,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,GACjC,aAAa,EAAE,CAejB"}

package/lib/projection/core/projectionTabs.js

@@ -0,0 +1,51 @@
+const PAIRS_MINIMUM_AXES = 3;
+/**
+ * The tabs a result can actually fill.
+ *
+ * A tab is offered because the data for it exists, never because a caller
+ * remembered to ask. That is what stops a UMAP viewer from showing an empty
+ * "how much each explains" tab, and it makes a new method a data shape rather
+ * than a code change — there is no place in the viewer where a method's name
+ * is tested. The map always exists, so the answer is never empty; the shares
+ * tab needs three axes as well as a share on each, because a two-bar chart is
+ * not worth a tab.
+ * A site embedding the viewer in a page of its own may narrow the answer with
+ * `allowed`, which is the one thing that is a caller's business rather than the
+ * data's: a page that only has room for the map, or that has already explained
+ * the components in its own prose, says so. It can only ever take tabs away —
+ * naming one the result cannot fill does not conjure it.
+ * @param result - The reduced space.
+ * @param allowed - The tabs the site permits, in any order.
+ * @returns The tabs, in reading order. Never empty: the map survives every
+ * filter, because a viewer with no panel at all is not a viewer.
+ */
+export function projectionTabs(result, allowed) {
+    const tabs = ['map'];
+    const enoughAxes = result.axes.length >= PAIRS_MINIMUM_AXES;
+    if (enoughAxes)
+        tabs.push('pairs');
+    if (result.loadings !== undefined)
+        tabs.push('variables');
+    if (enoughAxes && everyAxisPublishesAShare(result.axes))
+        tabs.push('shares');
+    if (allowed === undefined)
+        return tabs;
+    const permitted = new Set(allowed);
+    const kept = [];
+    for (const tab of tabs) {
+        if (permitted.has(tab))
+            kept.push(tab);
+    }
+    return kept.length === 0 ? ['map'] : kept;
+}
+function everyAxisPublishesAShare(axes) {
+    for (const axis of axes) {
+        const { share } = axis;
+        // One axis without a share is enough: a running total with a hole in it
+        // reads as a total, and would be wrong by however much the hole holds.
+        if (share === undefined || !Number.isFinite(share))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=projectionTabs.js.map

package/lib/projection/core/projectionTabs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectionTabs.js","sourceRoot":"","sources":["../../../src/projection/core/projectionTabs.ts"],"names":[],"mappings":"AAKA,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAwB,EACxB,OAAkC;IAElC,MAAM,IAAI,GAAoB,CAAC,KAAK,CAAC,CAAC;IACtC,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,IAAI,kBAAkB,CAAC;IAE5D,IAAI,UAAU;QAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS;QAAE,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC1D,IAAI,UAAU,IAAI,wBAAwB,CAAC,MAAM,CAAC,IAAI,CAAC;QAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7E,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAEvC,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;IACnC,MAAM,IAAI,GAAoB,EAAE,CAAC;IACjC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAC5C,CAAC;AAED,SAAS,wBAAwB,CAAC,IAA+B;IAC/D,KAAK,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;QACxB,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;QACvB,wEAAwE;QACxE,uEAAuE;QACvE,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;IACnE,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/lib/projection/core/variableAxis.d.ts

@@ -0,0 +1,106 @@
+/** Measurements laid out along a number line — a spectrum, a chromatogram. */
+export interface ContinuousVariableAxis {
+    /** Discriminant. */
+    kind: 'continuous';
+    /** One value per measurement, in column order, e.g. wavenumbers. */
+    values: readonly number[];
+    /** What the axis measures, e.g. `Wavenumber`. */
+    label: string;
+    /**
+     * Written after a value, e.g. `cm⁻¹`.
+     * @default '' — no unit is written
+     */
+    unit?: string;
+    /**
+     * Which way the axis runs. `descending` puts high values on the left, the
+     * way an infrared or an NMR spectrum is read.
+     * @default 'ascending'
+     */
+    direction?: 'ascending' | 'descending';
+}
+/**
+ * Measurements picked out of a spectrum rather than sampled across one — the
+ * m/z of a peak list, the shifts of an NMR signal list, a band table.
+ *
+ * It carries the same fields as a continuous axis and is a separate kind
+ * because the two are drawn differently and the difference is not one the
+ * panel can see in the numbers. A sampled spectrum sits on a grid, so its
+ * measurements can be laid out in even slots and joined with a line without
+ * saying anything untrue. A peak list does not: the gap between two peaks is a
+ * measurement in its own right, laying them out evenly would draw an empty
+ * stretch of a spectrum as though it were crowded, and joining them with a
+ * line would claim a signal between two masses that were measured apart.
+ * Peaks are drawn as sticks standing where they were measured.
+ */
+export interface PeaksVariableAxis {
+    /** Discriminant. */
+    kind: 'peaks';
+    /** Where each measurement sits, in column order, e.g. the m/z of each peak. */
+    values: readonly number[];
+    /** What the axis measures, e.g. `m/z`. */
+    label: string;
+    /**
+     * Written after a value, e.g. `Da`.
+     * @default '' — no unit is written
+     */
+    unit?: string;
+}
+/** Measurements that are a list of names — the columns of a table. */
+export interface NamedVariableAxis {
+    /** Discriminant. */
+    kind: 'named';
+    /** One name per measurement, in column order, e.g. `Petal length`. */
+    names: readonly string[];
+    /**
+     * What the names are, for the axis caption.
+     * @default 'Measurement'
+     */
+    label?: string;
+}
+/**
+ * How the original measurements are laid out, which decides how they are drawn.
+ *
+ * The caller states it; the panel never guesses from the data. A continuous
+ * axis is drawn as a line across even slots, a named one as bars from the zero
+ * line, and a peak list as sticks standing at the values themselves on a real
+ * number line.
+ */
+export type VariableAxis = ContinuousVariableAxis | NamedVariableAxis | PeaksVariableAxis;
+/**
+ * How many measurements an axis carries.
+ * @param axis - The axis.
+ * @returns The count.
+ */
+export declare function variableCount(axis: VariableAxis): number;
+/**
+ * Where each measurement sits, for an axis that is a number line.
+ * @param axis - The axis.
+ * @returns The positions, or `null` for a named axis, which has none.
+ */
+export declare function variablePositions(axis: VariableAxis): readonly number[] | null;
+/**
+ * What one measurement is called, written out.
+ * @param axis - The axis.
+ * @param index - Which measurement, from 0.
+ * @param decimals - Decimals the value is rounded to, from `variableDecimals`,
+ * for a label written under a tick.
+ * @default undefined — the number is written as it was handed in, which is
+ * what a readout naming one slot wants
+ * @returns The name, or the value with its unit — `1650 cm⁻¹`. An index
+ * outside the axis gives an empty string.
+ */
+export declare function variableLabel(axis: VariableAxis, index: number, decimals?: number): string;
+/**
+ * How many decimals the axis writes its own values with.
+ *
+ * About a hundred steps across the span the axis covers, which is finer than
+ * the dozen-odd ticks a chart labels and coarse enough to drop what a
+ * resampling left behind: a spectrum landed on its own grid carries values
+ * like 878.9834, where every digit past the second says something about the
+ * grid rather than about the measurement, so a tick reads `879 cm⁻¹`. A named
+ * axis has no values to write and gets none.
+ * @param axis - The axis.
+ * @returns The decimals, from 0 to 6.
+ */
+export declare function variableDecimals(axis: VariableAxis): number;
+//# sourceMappingURL=variableAxis.d.ts.map

package/lib/projection/core/variableAxis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variableAxis.d.ts","sourceRoot":"","sources":["../../../src/projection/core/variableAxis.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,MAAM,WAAW,sBAAsB;IACrC,oBAAoB;IACpB,IAAI,EAAE,YAAY,CAAC;IACnB,oEAAoE;IACpE,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,SAAS,CAAC,EAAE,WAAW,GAAG,YAAY,CAAC;CACxC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,iBAAiB;IAChC,oBAAoB;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,+EAA+E;IAC/E,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,sEAAsE;AACtE,MAAM,WAAW,iBAAiB;IAChC,oBAAoB;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,sEAAsE;IACtE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GACtB,sBAAsB,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAExD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,YAAY,GACjB,SAAS,MAAM,EAAE,GAAG,IAAI,CAE1B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAaR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAa3D"}