@compstats/core 0.2.0

package/dist/interactive/controls.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The controls the 3D components build, and the rule for where a slider may
+ * stand.
+ *
+ * Both 3D gadgets of the R package are panels of shiny inputs above a plot,
+ * and both need the same three things: a labeled slider that shows its own
+ * value, a labeled picker, and a line of text for what R would have written
+ * to the console. They are here so that the two components differ in what
+ * they control, not in how a control is made.
+ *
+ * The 2D components came first and built their controls inline. The reuse
+ * audit at the end of the port found the same builders written out again in
+ * each of them, so they share this module too: `interactiveTTest` and
+ * `interactiveMatrixInverse` for the slider and the standing rule,
+ * `interactiveSampling` for the picker.
+ */
+/** Where a slider may stand: R's `min`, `max` and `step`. */
+export interface SliderRange {
+    readonly min: number;
+    readonly max: number;
+    readonly step: number;
+}
+/** A control, its label, and the element the component listens to. */
+export interface BuiltSlider {
+    /** The label element that holds the caption, the value, and the input. */
+    readonly wrapper: HTMLElement;
+    readonly input: HTMLInputElement;
+    /** The element that shows the current value beside the caption. */
+    readonly readout: HTMLElement;
+}
+/** A picker, its label, and the element the component listens to. */
+export interface BuiltSelect {
+    readonly wrapper: HTMLElement;
+    readonly input: HTMLSelectElement;
+}
+/** A line of text for what R writes to the console. */
+export interface BuiltNote {
+    readonly element: HTMLElement;
+    /** Show a note, or take the line away when there is none. */
+    show(text: string | null): void;
+}
+/**
+ * Correct a starting value to something the slider can stand at.
+ *
+ * Three rules, in order, taken from the `validate()` of the
+ * `ion.rangeSlider.js` that ships inside shiny. A value that is not a number
+ * becomes the minimum; a value outside the range moves to the nearer bound; a
+ * value that misses the step moves to the nearest step, counted from the
+ * minimum.
+ *
+ * The third rule is not R's — R leaves the handle wherever it was asked to
+ * stand — but an HTML range input rounds a step-mismatched value by itself,
+ * so a component that kept the asked-for number would draw one picture and
+ * show a slider standing at another.
+ *
+ * @param given The value the caller asked for, or nothing.
+ * @param fallback The value R's own argument defaults to.
+ * @param range Where the slider may stand.
+ * @returns A value on the slider's own grid.
+ */
+export declare function startingSliderValue(given: number | undefined, fallback: number, range: SliderRange): number;
+/**
+ * Build one labeled slider that shows its own value.
+ *
+ * @param owner The document to build in.
+ * @param name The name the component reads the event by.
+ * @param label R's own caption.
+ * @param range Where the slider may stand.
+ * @param value Where it starts. Pass a value `startingSliderValue` returned.
+ * @returns The wrapper to append, the input to listen to, and the readout.
+ */
+export declare function buildSlider(owner: Document, name: string, label: string, range: SliderRange, value: number): BuiltSlider;
+/**
+ * Build one labeled picker.
+ *
+ * @param owner The document to build in.
+ * @param name The name the component reads the event by.
+ * @param label R's own caption.
+ * @param choices The options, in the order R lists them. A numeric choice
+ *   reaches the DOM as its own text, which is how R's own numeric choices
+ *   arrive there.
+ * @param selected The option to start on.
+ * @returns The wrapper to append, and the input to listen to.
+ */
+export declare function buildSelect(owner: Document, name: string, label: string, choices: readonly (string | number)[], selected: string | number): BuiltSelect;
+/**
+ * Build the line that carries what R writes to the console.
+ *
+ * A library cannot write to a console, and the plot layer therefore returns
+ * its message instead of printing it. One element, whose text is replaced,
+ * so that a hundred redraws leave one sentence rather than a hundred.
+ *
+ * @param owner The document to build in.
+ * @returns The element to append, and the way to set its text.
+ */
+export declare function buildNote(owner: Document): BuiltNote;
+//# sourceMappingURL=controls.d.ts.map

package/dist/interactive/controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controls.d.ts","sourceRoot":"","sources":["../../src/interactive/controls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,6DAA6D;AAC7D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,sEAAsE;AACtE,MAAM,WAAW,WAAW;IAC1B,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;CAC/B;AAED,qEAAqE;AACrE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC;AAED,uDAAuD;AACvD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,6DAA6D;IAC7D,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,WAAW,GACjB,MAAM,CAqBR;AAOD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,MAAM,GACZ,WAAW,CAuBb;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACrC,QAAQ,EAAE,MAAM,GAAG,MAAM,GACxB,WAAW,CAqBb;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAcpD"}

package/dist/interactive/logit.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The interactive logit: click to add an outcome, and watch the curve move.
+ *
+ * This is the port of `interactive_logit()` in
+ * `../compstatslib/R/logit_interactive.R`. R holds the points in a reactive
+ * value and calls `plot_logit()` on every change, forwarding its `...`
+ * arguments. This module does the same: it owns the points and the clicks, and
+ * it hands every draw to `plotLogit`. It contains no drawing code and no
+ * statistics.
+ *
+ * R's `runGadget()` blocks and returns the points when the user clicks "Done".
+ * A browser blocks at nothing, so this returns a handle at once. Read the
+ * points from `getPoints()`, or call `done()` to hand them to the `onDone`
+ * callback.
+ */
+import type { Point } from "../core/regression";
+import type { PlotLogitOptions } from "../plot/logit";
+import type { InteractiveTarget } from "./target";
+/**
+ * What the component accepts.
+ *
+ * The options of `plotLogit` pass through to it unchanged. This is the
+ * equivalent of R's `...` forwarding.
+ */
+export interface InteractiveLogitOptions extends PlotLogitOptions {
+    /** Points to start from. R takes these as its `points` argument. */
+    readonly initialPoints?: readonly Point[];
+    /** What to run on `done()`. */
+    readonly onDone?: (points: readonly Point[]) => void;
+}
+/** What the caller holds after the component starts. */
+export interface InteractiveLogitHandle {
+    /** Return the points collected so far, in click order. */
+    getPoints(): readonly Point[];
+    /** Drop every point and redraw. This drops the initial points too. */
+    reset(): void;
+    /** Hand the points to the `onDone` callback. */
+    done(): void;
+    /** Stop listening. The points stay readable. */
+    destroy(): void;
+}
+/**
+ * Start an interactive logit on a target.
+ *
+ * The component draws at once, so an empty start shows empty axes. Each click
+ * inside the plot area adds one point and redraws. A click outside that area
+ * does nothing, because the world window ends at the edge of the area and a
+ * point beyond it would not appear.
+ *
+ * @param target A canvas, or a surface and an element. See `./target.ts`.
+ * @param options Points to start from, a done callback, and the options of
+ * `plotLogit`.
+ * @returns The handle to the running component.
+ * @throws Error If a canvas gives no 2D context.
+ */
+export declare function interactiveLogit(target: InteractiveTarget, options?: InteractiveLogitOptions): InteractiveLogitHandle;
+//# sourceMappingURL=logit.d.ts.map

package/dist/interactive/logit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logit.d.ts","sourceRoot":"","sources":["../../src/interactive/logit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD;;;;;GAKG;AACH,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAC/D,oEAAoE;IACpE,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;IAC1C,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,KAAK,IAAI,CAAC;CACtD;AAED,wDAAwD;AACxD,MAAM,WAAW,sBAAsB;IACrC,0DAA0D;IAC1D,SAAS,IAAI,SAAS,KAAK,EAAE,CAAC;IAC9B,sEAAsE;IACtE,KAAK,IAAI,IAAI,CAAC;IACd,gDAAgD;IAChD,IAAI,IAAI,IAAI,CAAC;IACb,gDAAgD;IAChD,OAAO,IAAI,IAAI,CAAC;CACjB;AAYD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,uBAA4B,GACpC,sBAAsB,CAyExB"}

package/dist/interactive/matrixInverse.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The interactive matrix inverse: move the four sliders and watch the inverse
+ * answer.
+ *
+ * This is the port of `interactive_matrix_inverse()` in
+ * `../compstatslib/R/matrix_inverse_interactive.R`. R builds a miniUI gadget
+ * with four sliders, one for each entry of the matrix, and re-runs
+ * `plot_matrix_inverse()` whenever one moves. This module does the same: it
+ * owns the controls and the matrix in them, and hands every draw to
+ * `plotMatrixInverse`. It contains no drawing of the picture and no
+ * arithmetic.
+ *
+ * `plotMatrixInverse` takes no options, so there is nothing for this module to
+ * forward and the forwarding rule of CLAUDE.md is met by having nothing to
+ * pass. **A plot option added later must be threaded through here**, in the
+ * way `interactiveTTest` does it: pull the component's own fields out of the
+ * options object and pass the rest to the plot untouched.
+ *
+ * R's `runGadget()` blocks until "Done" and then returns nothing at all —
+ * `stopApp(NULL)`, from both Done and Cancel, and there is no Reset. Nothing
+ * blocks in a browser, so this returns a handle at once. `getValues()` reads
+ * the sliders and `getResult()` reads what was last drawn. `done()` reports
+ * the current matrix to the `onDone` callback: R hands back nothing, but a
+ * callback with no argument would only send the caller back to the handle for
+ * the values it just asked about.
+ *
+ * **The component draws one thing itself: the notice.** When the matrix has no
+ * inverse, `plotMatrixInverse` makes no drawing call at all, because R's
+ * `solve()` stops the R function before it draws. In R the user is not left
+ * looking at the last picture: shiny catches the error and prints it in the
+ * plot panel, which is not part of `plot_matrix_inverse`. So this module
+ * clears the surface and writes R's own message on it. That is the state of
+ * the gadget, reported to the user, and not a second way to draw a matrix.
+ */
+import type { Matrix2, MatrixInversion } from "../core/matrix";
+import type { ControlTarget } from "./target";
+/**
+ * Where the sliders start: R's `x1_init = 1, y1_init = 2, x2_init = 2,
+ * y2_init = 1`.
+ *
+ * The matrix inverts, and both of its columns and both columns of its inverse
+ * are inside the fixed window of the plot.
+ */
+export declare const DEFAULT_MATRIX_INVERSE_VALUES: Matrix2;
+/**
+ * What the component accepts.
+ *
+ * The four entries are the starting positions of the sliders, named as R names
+ * the matrix. R calls its own arguments `x1_init` and so on, to keep them
+ * apart from the reactive inputs of the same name; an options object is
+ * already the starting state, so the suffix would say nothing here.
+ *
+ * A value outside the slider range, or one that misses its step, is corrected
+ * at construction. See `startingValue`.
+ */
+export interface InteractiveMatrixInverseOptions extends Partial<Matrix2> {
+    /** What to run on `done()`. */
+    readonly onDone?: (values: Matrix2) => void;
+}
+/** What the caller holds after the component starts. */
+export interface InteractiveMatrixInverseHandle {
+    /** Return the matrix the sliders stand at now. */
+    getValues(): Matrix2;
+    /**
+     * Return what the last draw reported: the determinant, the inverse, and the
+     * singularity. The inverse is null exactly when the picture is a notice.
+     */
+    getResult(): MatrixInversion;
+    /** Hand the current matrix to the `onDone` callback. */
+    done(): void;
+    /** Stop listening and take back the controls that were built. */
+    destroy(): void;
+}
+/**
+ * Start an interactive matrix inverse on a target.
+ *
+ * The component builds its controls, draws once, and redraws on every change.
+ *
+ * @param target A container element, or a surface and a controls host. See
+ * `./target.ts`.
+ * @param options Starting entries and a done callback.
+ * @returns The handle to the running component.
+ * @throws Error If the target is a canvas, or if a canvas gives no 2D context.
+ */
+export declare function interactiveMatrixInverse(target: ControlTarget, options?: InteractiveMatrixInverseOptions): InteractiveMatrixInverseHandle;
+//# sourceMappingURL=matrixInverse.d.ts.map

package/dist/interactive/matrixInverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrixInverse.d.ts","sourceRoot":"","sources":["../../src/interactive/matrixInverse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAM/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,EAAE,OAK3C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,WAAW,+BAAgC,SAAQ,OAAO,CAAC,OAAO,CAAC;IACvE,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;CAC7C;AAED,wDAAwD;AACxD,MAAM,WAAW,8BAA8B;IAC7C,kDAAkD;IAClD,SAAS,IAAI,OAAO,CAAC;IACrB;;;OAGG;IACH,SAAS,IAAI,eAAe,CAAC;IAC7B,wDAAwD;IACxD,IAAI,IAAI,IAAI,CAAC;IACb,iEAAiE;IACjE,OAAO,IAAI,IAAI,CAAC;CACjB;AA8BD;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,aAAa,EACrB,OAAO,GAAE,+BAAoC,GAC5C,8BAA8B,CAwFhC"}

package/dist/interactive/moderation3d.d.ts

@@ -0,0 +1,103 @@
+/**
+ * The interactive moderation surface: turn the wireframe and watch the twist
+ * of the interaction appear and disappear.
+ *
+ * This is the port of `interactive_moderation_3d()` in
+ * `../compstatslib/R/moderation_3d_interactive.R`. R builds a shiny gadget
+ * with two rotation sliders and re-runs `plot_moderation_3d()` whenever one
+ * moves. This module does the same: it owns the two sliders and hands every
+ * draw to `plotModeration3d`. It fits nothing and draws nothing itself.
+ *
+ * Three things are worth knowing before reading the code.
+ *
+ * **The sliders are kept, although a browser can drag the camera.** They are
+ * what R's help teaches with: "Try 0 to align the IV slope plane with the
+ * screen, or 270 to align the moderator slope plane." A free drag cannot name
+ * an angle, and those two angles are the lesson. Dragging still works, and
+ * the two live together: a drag is preserved until a slider asks for
+ * something else.
+ *
+ * **A slider must push the camera at the plot.** The plot layer sets a
+ * constant `uirevision`, which is what keeps a drag across a redraw. Plotly
+ * honours it literally: once the user has turned the plot, a later `react`
+ * carrying a different `scene.camera` is ignored, because the user's own edit
+ * wins. The sliders would then move nothing. So a rotation change is sent
+ * after the redraw as a `relayout`, which is an instruction rather than a
+ * preference. The alternative — changing the `uirevision` whenever a slider
+ * moves — would have to reach into the layout the plot layer owns, and would
+ * throw away the drag on every redraw whether or not the view changed.
+ * Nothing new is pushed when the rotations have not moved, so a redraw for
+ * any other reason leaves the user's own view alone. The one other push this
+ * component makes runs the opposite way: a camera the user drags to is
+ * written back into Plotly's stored layout (see `handleRelayout`), because
+ * the modebar's own buttons relayout the scene from that layout and would
+ * otherwise snap the view to the sliders' angles.
+ *
+ * **Done hands back the current view.** R returns `data`, which the caller
+ * already holds and which says nothing about the picture. The rotations do,
+ * and together with the model they reopen the same plot — the same choice the
+ * t-test component made for the same reason.
+ *
+ * There is no Reset: R has Done and Cancel only. There is no validation of
+ * the model here either. R's gadget opens and lets `plot_moderation_3d()`
+ * report a bad column in the plot pane; the port's equivalent is a rejected
+ * `rendered()`, so a caller that wants to hear about it must await.
+ */
+import type { DataFrame } from "../core/frame";
+import type { ModerationOptions, ModerationSurface } from "../core/moderation";
+import type { Moderation3dSpec, Moderation3dViewOptions, PlotModeration3dOptions } from "../plot/moderation3d";
+import type { Plot3dTarget } from "./target";
+/**
+ * Everything the panel holds: the two rotations, and the model behind the
+ * surface. Hand it back to `interactiveModeration3d` or to
+ * `plotModeration3d` to reopen the same picture.
+ */
+export interface Moderation3dValues extends ModerationOptions, Moderation3dViewOptions {
+    /** The turn about the vertical axis, in degrees. */
+    readonly zRot: number;
+    /** The tilt, in degrees. */
+    readonly xRot: number;
+}
+/**
+ * What the component accepts.
+ *
+ * Every option of `plotModeration3d` is a starting value, and anything the
+ * plot grows later reaches it untouched. The model itself — which column is
+ * the outcome, the IV and the moderator — is required, as it is by the plot.
+ */
+export interface InteractiveModeration3dOptions extends PlotModeration3dOptions {
+    /** What to run on `done()`. */
+    readonly onDone?: (values: Moderation3dValues) => void;
+}
+/** What the caller holds after the component starts. */
+export interface InteractiveModeration3dHandle {
+    /** Return the rotations the sliders stand at, and the model being drawn. */
+    getValues(): Moderation3dValues;
+    /** Return the fit and the grid behind the last picture. */
+    getSurface(): ModerationSurface | null;
+    /** Return the traces, the layout, and the note of the last draw. */
+    getSpec(): Moderation3dSpec | null;
+    /** Wait for the drawing now in flight. Drawing is asynchronous. */
+    rendered(): Promise<void>;
+    /** Hand the current values to the `onDone` callback. */
+    done(): void;
+    /** Stop listening, purge the plot, and take back what was built. */
+    destroy(): void;
+}
+/**
+ * Start an interactive moderation surface on a target.
+ *
+ * The component builds its two sliders, draws once, and redraws on every
+ * change.
+ *
+ * @param target A container element, or a plot element and a controls host.
+ *   See `./target.ts`.
+ * @param data The frame holding every column the model names.
+ * @param options The model, the starting rotations, a done callback, and the
+ *   options of `plotModeration3d`.
+ * @returns The handle to the running component. Await `rendered()` for the
+ *   first picture, and to hear about a model the data cannot carry.
+ * @throws Error If a canvas is passed as the container.
+ */
+export declare function interactiveModeration3d(target: Plot3dTarget, data: DataFrame, options: InteractiveModeration3dOptions): InteractiveModeration3dHandle;
+//# sourceMappingURL=moderation3d.d.ts.map

package/dist/interactive/moderation3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moderation3d.d.ts","sourceRoot":"","sources":["../../src/interactive/moderation3d.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE/E,OAAO,KAAK,EACV,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,sBAAsB,CAAC;AAW9B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;;;GAIG;AACH,MAAM,WAAW,kBACf,SAAQ,iBAAiB,EACvB,uBAAuB;IACzB,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4BAA4B;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,8BACf,SAAQ,uBAAuB;IAC/B,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;CACxD;AAED,wDAAwD;AACxD,MAAM,WAAW,6BAA6B;IAC5C,4EAA4E;IAC5E,SAAS,IAAI,kBAAkB,CAAC;IAChC,2DAA2D;IAC3D,UAAU,IAAI,iBAAiB,GAAG,IAAI,CAAC;IACvC,oEAAoE;IACpE,OAAO,IAAI,gBAAgB,GAAG,IAAI,CAAC;IACnC,mEAAmE;IACnE,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,wDAAwD;IACxD,IAAI,IAAI,IAAI,CAAC;IACb,oEAAoE;IACpE,OAAO,IAAI,IAAI,CAAC;CACjB;AA4BD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,8BAA8B,GACtC,6BAA6B,CA6M/B"}

package/dist/interactive/pca.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The interactive PCA: click to add a point, and watch the components turn.
+ *
+ * This is the port of `interactive_pca()` in
+ * `../compstatslib/R/pca_interactive.R`. R holds the points in a reactive
+ * value and calls `plot_pca()` on every change. This module does the same: it
+ * owns the points and the clicks, and it hands every draw to `plotPca`. It
+ * contains no drawing code and no statistics.
+ *
+ * R's `runGadget()` blocks and returns `list(points, pca)` when the user
+ * clicks "Done". A browser blocks at nothing, so this returns a handle at
+ * once. Read the two through `getPoints()` and `getFit()`, or call `done()` to
+ * hand both to the `onDone` callback.
+ *
+ * **A click is taken as it comes.** R appends `data.frame(x = click$x,
+ * y = click$y)` with no clamp, no rounding, and no test that the click landed
+ * inside the plot area — and shiny reports a coordinate for a click anywhere
+ * on the plot image, margins included. So this accepts a click anywhere on the
+ * surface and keeps the world coordinate whole. That is a deliberate
+ * difference from `interactiveRegression`, which ignores a click outside the
+ * plot area because its window ends there, and from `interactiveLogit`, which
+ * must clamp and round because its outcome is 0 or 1. Here a point outside the
+ * window is a real state, and the plot clips it out of sight while it goes on
+ * counting towards the components.
+ */
+import type { PcaResult } from "../core/pca";
+import type { Point } from "../core/regression";
+import type { PlotPcaOptions } from "../plot/pca";
+import type { InteractiveTarget } from "./target";
+/**
+ * What `done()` hands over: R's `list(points = ..., pca = ...)`.
+ *
+ * R's `pca` field is `fit` here. Inside a component that is already about
+ * PCA, a field called `pca` says nothing, and "the fit" is what this port
+ * calls the thing a plot computed from a set of points everywhere else —
+ * `plotRegression` and `plotLogit` both return one.
+ */
+export interface InteractivePcaResult {
+    /** The points collected, in click order. */
+    readonly points: readonly Point[];
+    /** What the last draw computed, or null below three points. */
+    readonly fit: PcaResult | null;
+}
+/**
+ * What the component accepts.
+ *
+ * The options of `plotPca` pass through to it unchanged. This is the
+ * equivalent of R's `...` forwarding, though R's own `interactive_pca()`
+ * exposes only `meancenter` and leaves the window at the `plot_pca` defaults.
+ */
+export interface InteractivePcaOptions extends PlotPcaOptions {
+    /** Points to start from. R starts from an empty data frame. */
+    readonly initialPoints?: readonly Point[];
+    /** What to run on `done()`. */
+    readonly onDone?: (result: InteractivePcaResult) => void;
+}
+/** What the caller holds after the component starts. */
+export interface InteractivePcaHandle {
+    /** Return the points collected so far, in click order. */
+    getPoints(): readonly Point[];
+    /**
+     * Return what the last draw computed.
+     *
+     * Null below three points, which is `plot_pca`'s own guard: R's
+     * `pca_result` holds whatever the last `plot_pca()` returned, and that is
+     * NULL there too.
+     */
+    getFit(): PcaResult | null;
+    /** Drop every point and redraw. This drops the initial points too. */
+    reset(): void;
+    /** Hand the points and the fit to the `onDone` callback. */
+    done(): void;
+    /** Stop listening. The points and the fit stay readable. */
+    destroy(): void;
+}
+/**
+ * Start an interactive PCA on a target.
+ *
+ * The component draws at once, so an empty start shows empty axes. Each click
+ * adds one point and redraws. From the third point the two component arrows
+ * appear and turn with every point after it.
+ *
+ * @param target A canvas, or a surface and an element. See `./target.ts`.
+ * @param options Points to start from, a done callback, and the options of
+ *   `plotPca`.
+ * @returns The handle to the running component.
+ * @throws Error If a canvas gives no 2D context.
+ */
+export declare function interactivePca(target: InteractiveTarget, options?: InteractivePcaOptions): InteractivePcaHandle;
+//# sourceMappingURL=pca.d.ts.map

package/dist/interactive/pca.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pca.d.ts","sourceRoot":"","sources":["../../src/interactive/pca.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,+DAA+D;IAC/D,QAAQ,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;CAChC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC3D,+DAA+D;IAC/D,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;IAC1C,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;CAC1D;AAED,wDAAwD;AACxD,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,SAAS,IAAI,SAAS,KAAK,EAAE,CAAC;IAC9B;;;;;;OAMG;IACH,MAAM,IAAI,SAAS,GAAG,IAAI,CAAC;IAC3B,sEAAsE;IACtE,KAAK,IAAI,IAAI,CAAC;IACd,4DAA4D;IAC5D,IAAI,IAAI,IAAI,CAAC;IACb,4DAA4D;IAC5D,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,qBAA0B,GAClC,oBAAoB,CAyCtB"}

package/dist/interactive/regression.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The interactive regression: click to add a point, and watch the line move.
+ *
+ * This is the port of `interactive_regression()` in
+ * `../compstatslib/R/regression_interactive.R`. R holds the points in a
+ * reactive value and calls `plot_regression()` on every change, forwarding its `...`
+ * arguments. This module does the same: it owns the points and the clicks, and
+ * it hands every draw to `plotRegression`. It contains no drawing code and no
+ * statistics.
+ *
+ * R's `runGadget()` blocks and returns the points when the user clicks "Done".
+ * A browser blocks at nothing, so this returns a handle at once. Read the
+ * points from `getPoints()`, or call `done()` to hand them to the `onDone`
+ * callback.
+ */
+import type { Point } from "../core/regression";
+import type { PlotRegressionOptions } from "../plot/regression";
+import type { InteractiveTarget } from "./target";
+/**
+ * What the component accepts.
+ *
+ * The options of `plotRegression` pass through to it unchanged. This is the
+ * equivalent of R's `...` forwarding.
+ */
+export interface InteractiveRegressionOptions extends PlotRegressionOptions {
+    /** Points to start from. R takes these as its `points` argument. */
+    readonly initialPoints?: readonly Point[];
+    /** What to run on `done()`. */
+    readonly onDone?: (points: readonly Point[]) => void;
+}
+/** What the caller holds after the component starts. */
+export interface InteractiveRegressionHandle {
+    /** Return the points collected so far, in click order. */
+    getPoints(): readonly Point[];
+    /** Drop every point and redraw. This drops the initial points too. */
+    reset(): void;
+    /** Hand the points to the `onDone` callback. */
+    done(): void;
+    /** Stop listening. The points stay readable. */
+    destroy(): void;
+}
+/**
+ * Start an interactive regression on a target.
+ *
+ * The component draws at once, so an empty start shows empty axes. Each click
+ * inside the plot area adds one point and redraws. A click outside the plot
+ * area does nothing, because the world window of the plot ends at the edge of
+ * that area and a point beyond it would not appear.
+ *
+ * @param target A canvas, or a surface and an element. See `./target.ts`.
+ * @param options Points to start from, a done callback, and the options of
+ * `plotRegression`.
+ * @returns The handle to the running component.
+ * @throws Error If a canvas gives no 2D context.
+ */
+export declare function interactiveRegression(target: InteractiveTarget, options?: InteractiveRegressionOptions): InteractiveRegressionHandle;
+//# sourceMappingURL=regression.d.ts.map

package/dist/interactive/regression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regression.d.ts","sourceRoot":"","sources":["../../src/interactive/regression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAGhD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD;;;;;GAKG;AACH,MAAM,WAAW,4BAA6B,SAAQ,qBAAqB;IACzE,oEAAoE;IACpE,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;IAC1C,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,KAAK,IAAI,CAAC;CACtD;AAED,wDAAwD;AACxD,MAAM,WAAW,2BAA2B;IAC1C,0DAA0D;IAC1D,SAAS,IAAI,SAAS,KAAK,EAAE,CAAC;IAC9B,sEAAsE;IACtE,KAAK,IAAI,IAAI,CAAC;IACd,gDAAgD;IAChD,IAAI,IAAI,IAAI,CAAC;IACb,gDAAgD;IAChD,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,4BAAiC,GACzC,2BAA2B,CAuC7B"}

package/dist/interactive/sampling.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The interactive sampling demonstration: press Sample and watch the
+ * distribution of the statistic fill in.
+ *
+ * This is the port of `interactive_sampling()` in
+ * `../compstatslib/R/sampling_interactive.R`. R builds a miniUI gadget with
+ * two selects and a button, and re-runs `plot_sampling()` when the button is
+ * pressed. This module does the same: it owns the controls, one generator, and
+ * the state that piles up between draws, and hands every draw to
+ * `plotSampling`. It contains no drawing code and no statistics.
+ *
+ * Three things set this gadget apart from the other three in the port:
+ *
+ * - **The button is the only thing that draws.** R wires the button to a
+ *   trigger and isolates the selects (`shiny::isolate`), so moving a select
+ *   changes what the *next* press will do and nothing more. A gadget that
+ *   redrew on every change would resample ten thousand values each time a
+ *   reader browsed the menu.
+ * - **It keeps drawing down one stream.** R reads one global generator, so
+ *   each press carries on where the last stopped. One generator is built here
+ *   when the component starts and used for every draw after.
+ * - **Done hands back the cache.** R's `stopApp(cache())` returns everything
+ *   drawn so far; the t-test and logit gadgets return nothing at all.
+ *
+ * `reset()` has no counterpart in R, as in the other click-collectors. It
+ * empties the pile and redraws with no new samples, so the panels come back
+ * blank and the window is set again from the population.
+ */
+import type { PlotSamplingOptions, SamplingState } from "../plot/sampling";
+import type { ControlTarget } from "./target";
+/** Everything the panel of controls holds. */
+export interface SamplingValues {
+    /** How many values each sample takes. R's `sample_size` select. */
+    readonly sampleSize: number;
+    /** How many samples the next press draws. R's `reps` select. */
+    readonly reps: number;
+}
+/**
+ * What the component accepts.
+ *
+ * The options of `plotSampling` pass through to it, and the sample size and
+ * repetition count double as the starting positions of the two selects. This
+ * is the equivalent of R's `...` forwarding.
+ */
+export interface InteractiveSamplingOptions extends PlotSamplingOptions {
+    /** What to run on `done()`. */
+    readonly onDone?: (state: SamplingState) => void;
+}
+/** What the caller holds after the component starts. */
+export interface InteractiveSamplingHandle {
+    /** Return where the two selects stand now. */
+    getValues(): SamplingValues;
+    /** Return everything drawn so far — R's gadget cache. */
+    getState(): SamplingState;
+    /** Empty the pile and redraw with no samples. */
+    reset(): void;
+    /** Hand the accumulated state to the `onDone` callback. */
+    done(): void;
+    /** Stop listening and take back the controls that were built. */
+    destroy(): void;
+}
+/**
+ * Start an interactive sampling demonstration on a target.
+ *
+ * The component builds its controls, draws once, and redraws on every press
+ * of its button.
+ *
+ * @param target A container element, or a surface and a controls host. See
+ *   `./target.ts`.
+ * @param population The values to sample from.
+ * @param options Starting values, a done callback, and the options of
+ *   `plotSampling`.
+ * @returns The handle to the running component.
+ * @throws Error If a canvas is passed as the container, or gives no 2D
+ *   context.
+ */
+export declare function interactiveSampling(target: ControlTarget, population: readonly number[], options?: InteractiveSamplingOptions): InteractiveSamplingHandle;
+//# sourceMappingURL=sampling.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.d.ts","sourceRoot":"","sources":["../../src/interactive/sampling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,OAAO,KAAK,EACV,mBAAmB,EAEnB,aAAa,EACd,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,8CAA8C;AAC9C,MAAM,WAAW,cAAc;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,0BAA2B,SAAQ,mBAAmB;IACrE,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CAClD;AAED,wDAAwD;AACxD,MAAM,WAAW,yBAAyB;IACxC,8CAA8C;IAC9C,SAAS,IAAI,cAAc,CAAC;IAC5B,yDAAyD;IACzD,QAAQ,IAAI,aAAa,CAAC;IAC1B,iDAAiD;IACjD,KAAK,IAAI,IAAI,CAAC;IACd,2DAA2D;IAC3D,IAAI,IAAI,IAAI,CAAC;IACb,iEAAiE;IACjE,OAAO,IAAI,IAAI,CAAC;CACjB;AAaD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,GAAE,0BAA+B,GACvC,yBAAyB,CAmH3B"}