@compstats/core 0.2.0

package/dist/plot/sampling.d.ts

@@ -0,0 +1,159 @@
+/**
+ * The three-panel sampling demonstration: a population, the samples drawn
+ * from it, and how their statistic scatters.
+ *
+ * This is the drawing half of `plot_sampling()` in
+ * `../compstatslib/R/sampling_plot.R`. The panels, top to bottom:
+ *
+ * 1. the population's density, dotted;
+ * 2. this draw's samples — each sample's own density in translucent gray,
+ *    with the density of all of them pooled drawn over the top;
+ * 3. a histogram of every statistic drawn so far, this call and all before it.
+ *
+ * All three share one horizontal window, frozen on the first call at the range
+ * of the population. Later calls keep it however wide the population passed to
+ * them happens to be, which is what lets the picture stay still while the
+ * statistics pile up. A bar or a curve outside that window is clipped.
+ *
+ * **The state is the caller's.** R returns a `vars` list and its gadget hands
+ * it back on the next call, which is how the window stays frozen and the
+ * statistics accumulate. Nothing is kept here between calls: `plotSampling`
+ * takes the state it was given, returns the state it made, and the caller —
+ * `interactiveSampling`, or a demo page — holds it in between. That is the
+ * port plan's rule against hidden accumulation.
+ *
+ * **`replot_population` is not ported.** R declares and documents it, and
+ * `interactive_sampling()` passes `FALSE` for it, but `plot_sampling()`'s body
+ * never reads it: the population panel is always redrawn. Porting a parameter
+ * that does nothing would carry the defect forward as if it were a feature.
+ */
+import type { Histogram } from "../core/histogram";
+import type { Rng } from "../core/rng";
+import type { Extent, Scale } from "./axes";
+import type { PlotTarget } from "./target";
+/** Which of the three stacked panels a scale belongs to. */
+export type SamplingPanel = "population" | "samples" | "statistic";
+/**
+ * What one draw hands to the next.
+ *
+ * This is R's `vars` list, less the entries that are arguments anyway: R keeps
+ * the population, the sample size and the statistic in there as well, and this
+ * port takes all three afresh on every call, so holding them twice would let
+ * the two copies disagree.
+ */
+export interface SamplingState {
+    /** The left edge of the frozen window. R's `xmin`. */
+    readonly xMin: number;
+    /** The right edge of the frozen window. R's `xmax`. */
+    readonly xMax: number;
+    /** Every statistic drawn so far, oldest first. R's `sample_theta`. */
+    readonly sampleTheta: readonly number[];
+}
+/** What to draw. The interactive layer forwards these untouched. */
+export interface PlotSamplingOptions {
+    /**
+     * How many values in each sample. R's `sample_size`.
+     *
+     * R's `plot_sampling()` has no default here and fails without one; its
+     * gadget defaults to 10. This port takes the gadget's default so that
+     * `plotSampling(target, population)` draws something, which is the
+     * no-argument-works property the port plan asks bundled demos to keep.
+     */
+    readonly sampleSize?: number;
+    /** How many samples this draw takes. R's `reps`, 1 by default. */
+    readonly reps?: number;
+    /** The statistic to take from each sample. R's `theta`, the mean. */
+    readonly theta?: (sample: readonly number[]) => number;
+    /**
+     * Where the randomness comes from.
+     *
+     * R reads one global stream, so its repeated draws carry on where the last
+     * left off. A caller who draws more than once must pass one generator and
+     * keep passing it — the default builds a new one per call, and two calls
+     * that each build their own would each start from the beginning.
+     *
+     * The default is seeded from `Math.random()`, so a demo that says nothing
+     * about seeds still gets a different draw each time, as an R session does.
+     * Only the seed comes from there: pass `seededRng(42)` and every draw down
+     * that stream repeats exactly.
+     */
+    readonly rng?: Rng;
+    /**
+     * What the last call returned, or nothing on the first call.
+     *
+     * R's `vars` argument, which its gadget caches. This is what freezes the
+     * window and accumulates the statistics.
+     */
+    readonly state?: SamplingState | null;
+    /**
+     * Where every density curve puts its grid.
+     *
+     * `"data"`, the default, is R: each `density()` call spreads its 512 grid
+     * points over the range of the values it was given. That is right while the
+     * values and the window are of one size.
+     *
+     * `"frozen"` spreads them over the drawn window instead, through R's own
+     * `from` and `to` arguments. A population that reaches far outside the
+     * window needs this: at 512 points over a range a thousand times the window,
+     * one grid step is wider than the whole panel, and the curve draws as a
+     * straight line. The samples take the frozen grid as well, for the same
+     * reason and so that every curve in the picture is comparable.
+     */
+    readonly densityWindow?: "data" | "frozen";
+}
+/** Everything this draw produced, for the caller to hold and to read. */
+export interface PlotSamplingResult {
+    /** The state to hand back on the next call. */
+    readonly state: SamplingState;
+    /** The samples this call drew, in draw order. */
+    readonly samples: readonly (readonly number[])[];
+    /** The statistic of each of those samples. */
+    readonly thetas: readonly number[];
+    /**
+     * The histogram the third panel drew, or null when there was nothing to
+     * count. Handed back so a caller need not bin the statistics again.
+     *
+     * It counts the statistics inside the window, not the whole pile. The panel
+     * clips a bar outside the window anyway, and a statistic it cannot draw must
+     * not set the width of the cells either — see `plotSampling`.
+     */
+    readonly histogram: Histogram | null;
+}
+/**
+ * Build the scale for one panel.
+ *
+ * The three panels are stacked in equal bands and share the window, so the
+ * same world x lands in the same pixel column in each. The interactive layer
+ * and any demo read their geometry from here rather than restating it.
+ *
+ * @param width The pixel width of the surface.
+ * @param height The pixel height of the surface.
+ * @param panel Which band to build.
+ * @param window The frozen horizontal window, shared by all three.
+ * @param yMax The tallest value the panel has to show. Zero is always the
+ *   foot of the panel, as it is for a density and for a count.
+ * @returns The map between world values and pixels for that panel.
+ */
+export declare function samplingScale(width: number, height: number, panel: SamplingPanel, window: Extent, yMax: number): Scale;
+/**
+ * Draw one round of sampling, and hand back what the next round needs.
+ *
+ * A population of fewer than two values has no density, and R's `density()`
+ * stops there. A library cannot stop: this draws the three panels and their
+ * axes with nothing in them, takes no samples, and returns a state with the
+ * window set and no statistics. The same holds for the samples themselves —
+ * a sample of one value gets no curve of its own, though it still counts
+ * toward the pooled one and toward the histogram.
+ *
+ * @param target A canvas, or a context and a size. See `./target.ts`.
+ * @param population The values to sample from.
+ * @param options The sample size, the repetitions, the statistic, the
+ *   generator, and the state of the last call.
+ * @returns This draw's samples and statistics, the histogram drawn from the
+ *   accumulated statistics, and the state to pass back next time.
+ * @throws RangeError If the sample size is larger than the population, or if
+ *   a count is negative or fractional — both from `drawSamples`, which is
+ *   where R's own refusals live.
+ */
+export declare function plotSampling(target: PlotTarget, population: readonly number[], options?: PlotSamplingOptions): PlotSamplingResult;
+//# sourceMappingURL=sampling.d.ts.map

package/dist/plot/sampling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.d.ts","sourceRoot":"","sources":["../../src/plot/sampling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAOnD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAGvC,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAG5C,OAAO,KAAK,EAAa,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtD,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,SAAS,GAAG,WAAW,CAAC;AAEnE;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,KAAK,MAAM,CAAC;IACvD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC;IACnB;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACtC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;CAC5C;AAED,yEAAyE;AACzE,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;IACjD,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;CACtC;AA0CD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,KAAK,CAiBP;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,GAAE,mBAAwB,GAChC,kBAAkB,CAiEpB"}

package/dist/plot/scatter3d.d.ts

@@ -0,0 +1,164 @@
+/**
+ * The 3D scatterplot: three numeric columns as a cloud of points, with an
+ * optional fourth column driving the color.
+ *
+ * This is `plot_scatter3d()` of `../compstatslib/R/scatter3d_plot.R`, drawn
+ * through Plotly as the R original is. The trace and the layout follow the
+ * object R actually builds, dumped in `.claude/plans/moderation-fixtures.md`
+ * section 5.
+ *
+ * Four things are worth knowing before reading the code.
+ *
+ * **The work is the specification.** `scatter3dSpec` builds the traces and the
+ * layout and touches nothing outside itself. `plotScatter3d` resolves the
+ * engine and draws that specification. The split keeps every rule of the port
+ * testable without a browser, and it gives the interactive layer a cheap way
+ * to ask what a set of options would draw.
+ *
+ * **Nothing is drawn until everything is checked.** R validates the style,
+ * then the axis arguments, then the columns, and only then calls Plotly. That
+ * order was confirmed by tracing `plot_ly()`: every error fires with the
+ * engine untouched. This module keeps the order and the wording, and the tests
+ * count the calls to prove it.
+ *
+ * **The default axes are the first three numeric columns, in frame order.**
+ * With the bundled `moderation_data` that is `y, x, z`, so the plot's own x
+ * axis is titled "y". The collision is confusing, and it is R's, so the port
+ * keeps it. A note names the chosen and the skipped columns, as R's
+ * `message()` does; a library cannot write to a console, so the note is
+ * returned and the caller decides whether to show it.
+ *
+ * **Color is the one place the port must invent.** R hands the color column
+ * to plotly-R, which decides by itself what a numeric or a categorical column
+ * means. Plotly.js decides nothing: the caller must build the traces. So a
+ * numeric column becomes one trace carrying a value per point with a color
+ * bar beside it, and a categorical column becomes one trace per level, named,
+ * listed in the legend, and colored from Plotly's own sequence. The rule
+ * follows what plotly-R does; the exact colors are Plotly's choice, in both
+ * languages.
+ */
+import type { DataFrame } from "../core/frame";
+import type { PlotlyCamera, PlotlyHTMLElement, PlotlyLayout, PlotlyLike, Scatter3dTrace } from "./plotly";
+/** How the markers are drawn, apart from the data. */
+export interface Scatter3dStyle {
+    /** The x, y and z proportions of the box the points sit in. */
+    readonly aspect: readonly number[];
+    /** How solid each marker is, in (0, 1]. */
+    readonly opacity: number;
+    /** How large each marker is, in pixels. */
+    readonly size: number;
+}
+/**
+ * R's own defaults: `aspect = c(1, 1, 1), opacity = 0.8, size = 5`.
+ *
+ * `interactive_scatter3d()` repeats these three numbers in its own signature.
+ * The port states them once, here, so the gadget's sliders and the plot they
+ * drive cannot start from different places.
+ */
+export declare const DEFAULT_SCATTER3D_STYLE: Scatter3dStyle;
+/** Titles to write on the axes instead of the column names. */
+export interface Scatter3dTitles {
+    readonly x?: string;
+    readonly y?: string;
+    readonly z?: string;
+}
+/** What to draw, and how. Every option is R's, with R's default. */
+export interface Scatter3dSpecOptions {
+    /** The column on the first horizontal axis. */
+    readonly x?: string;
+    /** The column on the second horizontal axis. */
+    readonly y?: string;
+    /** The column on the vertical axis. */
+    readonly z?: string;
+    /**
+     * Any column to map to color. A numeric column gives a continuous scale
+     * with a color bar; a text or true-or-false column gives one trace per
+     * level, with a legend.
+     */
+    readonly color?: string;
+    /**
+     * The x, y and z proportions of the box the points sit in: three positive
+     * numbers, `[1, 1, 1]` by default.
+     */
+    readonly aspect?: readonly number[];
+    /** How solid each marker is, in (0, 1]. */
+    readonly opacity?: number;
+    /** How large each marker is, in pixels. */
+    readonly size?: number;
+    /**
+     * Where the camera starts. Absent by default, which leaves Plotly's own
+     * view. Pass a camera to reopen a plot at an angle captured earlier.
+     */
+    readonly camera?: PlotlyCamera;
+    /** Axis titles. Each axis falls back to the name of its column. */
+    readonly titles?: Scatter3dTitles;
+}
+/** The options of `plotScatter3d`: the specification, and the engine. */
+export interface PlotScatter3dOptions extends Scatter3dSpecOptions {
+    /**
+     * The Plotly engine. `loadPlotly()` by default, which fetches the library on
+     * first use. Pass your own to draw through a copy you already hold, or to
+     * record what would be drawn.
+     */
+    readonly plotly?: PlotlyLike;
+}
+/** What a set of options draws. */
+export interface Scatter3dSpec {
+    /** One trace, or one for each level of a categorical color column. */
+    readonly traces: readonly Scatter3dTrace[];
+    readonly layout: PlotlyLayout;
+    /**
+     * What R says in its `message()`: which columns were chosen, and which were
+     * skipped. Null when the caller named every axis, or when no numeric column
+     * was left over.
+     */
+    readonly note: string | null;
+}
+/** A drawn scatterplot: its specification, its element, and its engine. */
+export interface Scatter3dHandle extends Scatter3dSpec {
+    /**
+     * The element Plotly drew into. Plotly returns it with an event emitter
+     * attached, which is how the interactive layer hears about rotation.
+     */
+    readonly element: PlotlyHTMLElement;
+    /** The engine that drew, ready for the next redraw and for teardown. */
+    readonly plotly: PlotlyLike;
+}
+/**
+ * Build the traces and the layout of a 3D scatterplot.
+ *
+ * @param data The frame to read.
+ * @param options Which columns to draw, and how.
+ * @returns The traces, the layout, and the note about the column choice.
+ * @throws RangeError If the style is out of range, if the frame is ragged, if
+ *   fewer than three numeric columns are available, or if a named column is
+ *   absent or, on an axis, not numeric.
+ */
+export declare function scatter3dSpec(data: DataFrame, options?: Scatter3dSpecOptions): Scatter3dSpec;
+/**
+ * Draw a 3D scatterplot.
+ *
+ * @param target The element to draw into. Plotly fills it.
+ * @param data The frame to read.
+ * @param options Which columns to draw, how, and through which engine.
+ * @returns The drawn plot: its element, its specification, and its engine.
+ * @throws RangeError Everything `scatter3dSpec` throws, as a rejected promise.
+ *   No option reaches the engine until every check has passed.
+ */
+export declare function plotScatter3d(target: HTMLElement, data: DataFrame, options?: PlotScatter3dOptions): Promise<Scatter3dHandle>;
+/**
+ * R's `scatter3d_validate_style()`, less the checks the compiler makes.
+ *
+ * Exported because R shares this check between the plot and the gadget, and
+ * the gadget runs it before it builds anything. Note what it does **not** do:
+ * it refuses a style no plot could be drawn with, and says nothing about the
+ * bounds of the gadget's sliders. An aspect of 12 passes here and is then
+ * clamped by the slider, which is R's behavior exactly.
+ *
+ * @param aspect The three axis proportions.
+ * @param opacity How solid a marker is.
+ * @param size How large a marker is.
+ * @throws RangeError With R's own wording, in R's own order.
+ */
+export declare function validateScatter3dStyle(aspect: readonly number[], opacity: number, size: number): void;
+//# sourceMappingURL=scatter3d.d.ts.map

package/dist/plot/scatter3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatter3d.d.ts","sourceRoot":"","sources":["../../src/plot/scatter3d.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAQH,OAAO,KAAK,EAAU,SAAS,EAAE,MAAM,eAAe,CAAC;AAEvD,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,UAAU,EAEV,cAAc,EACf,MAAM,UAAU,CAAC;AAelB,sDAAsD;AACtD,MAAM,WAAW,cAAc;IAC7B,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,cAIrC,CAAC;AAEF,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,oEAAoE;AACpE,MAAM,WAAW,oBAAoB;IACnC,+CAA+C;IAC/C,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;CACnC;AAED,yEAAyE;AACzE,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB;IAChE;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC;CAC9B;AAED,mCAAmC;AACnC,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,2EAA2E;AAC3E,MAAM,WAAW,eAAgB,SAAQ,aAAa;IACpD;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC7B;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,SAAS,EACf,OAAO,GAAE,oBAAyB,GACjC,aAAa,CAkDf;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,SAAS,EACf,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,eAAe,CAAC,CAO1B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,IAAI,CAeN"}

package/dist/plot/tTest.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The t-test plot: two distributions, the regions they decide between, and an
+ * optional matrix of the four outcomes.
+ *
+ * This is the drawing half of `plot_t_test()` in
+ * `../compstatslib/R/t_statistic_plot.R`, whose work is spread across
+ * `t_null_plot()`, `t_alt_lines()`, `plott()`, `plotdist()`, and
+ * `plot_error_matrix()`. Every number comes from `tTestStats` in
+ * `src/core/ttest.ts` and every curve height from `dt` in
+ * `src/core/tdist.ts`; this module computes no statistics of its own.
+ */
+import type { TTestOptions, TTestStats } from "../core/ttest";
+import type { Scale } from "./axes";
+import type { PlotTarget } from "./target";
+/**
+ * What to draw. The four test parameters pass straight through to
+ * `tTestStats`, which is the pass-through R does with its own arguments.
+ */
+export interface PlotTTestOptions extends TTestOptions {
+    /** Show the matrix of the four outcomes. False by default, as in R. */
+    readonly errorMatrix?: boolean;
+}
+/**
+ * Build the scale that `plotTTest` draws through.
+ *
+ * The x window is R's fixed `c(-6, 6)`. The y window follows R's default,
+ * which is the range of the plotted density widened by four percent at each
+ * end, except that showing the error matrix raises the top enough to hold it.
+ * R leaves the window alone there and lets the matrix fall outside the plot
+ * region, where base graphics clip it away: at one degree of freedom the null
+ * curve only reaches 0.32 and the top row of cells is cut off. Growing the
+ * window instead keeps the panel whole.
+ *
+ * @param width The pixel width of the surface.
+ * @param height The pixel height of the surface.
+ * @param options The same options `plotTTest` takes.
+ * @returns The map between world values and pixels.
+ */
+export declare function tTestScale(width: number, height: number, options?: PlotTTestOptions): Scale;
+/**
+ * Draw the null and alternative distributions of a t test.
+ *
+ * @param target A canvas, or a context and a size. See `./target.ts`.
+ * @param options The test parameters, and whether to show the error matrix.
+ * @returns The statistics behind the picture. R returns these invisibly from
+ * `t_alt_lines()`; a browser caller wants them, so they come back here.
+ */
+export declare function plotTTest(target: PlotTarget, options?: PlotTTestOptions): TTestStats;
+//# sourceMappingURL=tTest.d.ts.map

package/dist/plot/tTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tTest.d.ts","sourceRoot":"","sources":["../../src/plot/tTest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE9D,OAAO,KAAK,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AAI5C,OAAO,KAAK,EAAa,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtD;;;GAGG;AACH,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,uEAAuE;IACvE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAiED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,gBAAqB,GAC7B,KAAK,CAGP;AAuBD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,gBAAqB,GAC7B,UAAU,CAwBZ"}

package/dist/plot/target.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The drawing surface that every 2D plot writes to.
+ *
+ * R's base graphics draw to a current device. Nothing here does: a plot
+ * function receives its target and draws only to that target.
+ *
+ * `Context2D` lists the exact members of `CanvasRenderingContext2D` that this
+ * library uses. A real context satisfies the type, and a test can pass any
+ * object that implements those members. This matters because happy-dom has no
+ * 2D canvas context, so a DOM alone cannot exercise a plot function. See
+ * `test/recording-context.ts` for the stub the plot tests use.
+ */
+/** The part of a canvas 2D context that the plot functions draw through. */
+export type Context2D = Pick<CanvasRenderingContext2D, "fillStyle" | "strokeStyle" | "lineWidth" | "font" | "textAlign" | "textBaseline" | "save" | "restore" | "beginPath" | "moveTo" | "lineTo" | "arc" | "rect" | "fillRect" | "clip" | "fill" | "stroke" | "fillText" | "setLineDash" | "translate" | "rotate">;
+/** A context together with the pixel size of its surface. */
+export interface RenderTarget {
+    readonly ctx: Context2D;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * What a plot function accepts.
+ *
+ * Pass a canvas in a browser. Pass a `RenderTarget` to draw through your own
+ * context, which is how the tests run without a DOM.
+ */
+export type PlotTarget = HTMLCanvasElement | RenderTarget;
+/**
+ * Reduce a plot target to a context and a size.
+ *
+ * A canvas reports the size of its pixel store, which is the size the plot
+ * draws in. On a dense screen those two part company: the store has to hold
+ * more pixels than the layout does, or the browser stretches the image and
+ * softens every edge.
+ *
+ * This function never touches a canvas the caller passed in — the caller owns
+ * it, and resizing it under them would throw away whatever else they drew. So
+ * a caller who wants a crisp picture on such a screen does three things:
+ *
+ * 1. size the store at the layout size times `devicePixelRatio`, and set the
+ *    CSS width and height to the layout size;
+ * 2. call `ctx.scale(ratio, ratio)` once, so drawing carries on in layout
+ *    pixels;
+ * 3. pass `{ ctx, width, height }` with the **layout** size, rather than the
+ *    canvas.
+ *
+ * The third step matters. Handing over the canvas would report the store size
+ * on top of a context that already scales, and the picture would come out at
+ * the square of the ratio. Reporting layout pixels also keeps `eventPixel`
+ * right, since it divides the surface size by the size of the client
+ * rectangle. `resolveControlTarget` in `../interactive/target.ts` does all
+ * three for the canvas it builds itself.
+ */
+export declare function resolveTarget(target: PlotTarget): RenderTarget;
+//# sourceMappingURL=target.d.ts.map

package/dist/plot/target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../src/plot/target.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,4EAA4E;AAC5E,MAAM,MAAM,SAAS,GAAG,IAAI,CAC1B,wBAAwB,EACtB,WAAW,GACX,aAAa,GACb,WAAW,GACX,MAAM,GACN,WAAW,GACX,cAAc,GACd,MAAM,GACN,SAAS,GACT,WAAW,GACX,QAAQ,GACR,QAAQ,GACR,KAAK,GACL,MAAM,GACN,UAAU,GACV,MAAM,GACN,MAAM,GACN,QAAQ,GACR,UAAU,GACV,aAAa,GACb,WAAW,GACX,QAAQ,CACX,CAAC;AAEF,6DAA6D;AAC7D,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,iBAAiB,GAAG,YAAY,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,YAAY,CAY9D"}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@compstats/core",
+  "version": "0.2.0",
+  "type": "module",
+  "description": "Interactive 2D and 3D visualization of data and statistical concepts, in the browser.",
+  "license": "MIT",
+  "author": "Soumya Ray <soumya.ray@gmail.com>",
+  "contributors": [
+    "Daniele Melotti <danielemelotti@hotmail.com>"
+  ],
+  "keywords": [
+    "statistics",
+    "visualization",
+    "interactive",
+    "canvas",
+    "plotly",
+    "regression",
+    "logistic-regression",
+    "pca",
+    "moderation",
+    "sampling-distribution",
+    "confidence-interval",
+    "t-test",
+    "teaching",
+    "browser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/compstatslib/compstatslib-ts.git"
+  },
+  "homepage": "https://github.com/compstatslib/compstatslib-ts",
+  "bugs": {
+    "url": "https://github.com/compstatslib/compstatslib-ts/issues"
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./3d": {
+      "types": "./dist/3d.d.ts",
+      "import": "./dist/3d.js",
+      "default": "./dist/3d.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts src/3d.ts --outdir dist --target browser --format esm --sourcemap=linked --external plotly.js-dist-min && bunx tsc -p tsconfig.build.json",
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test",
+    "dev": "bun run demo/server.ts",
+    "prepublishOnly": "bun test && bun run typecheck && bun run build"
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^20.0.0",
+    "@types/bun": "^1.3.0",
+    "happy-dom": "^20.0.0",
+    "typescript": "^5.9.0"
+  },
+  "dependencies": {
+    "plotly.js-dist-min": "^3.7.0"
+  }
+}