apex-analyst 0.1.0

package/lib/AnalystPanel.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The Analyst toolbar and result panel.
+ *
+ * Rendered into a Shadow DOM host, which is not decoration. This layer is meant
+ * to be dropped onto pages we did not write, so two things have to be true:
+ * host CSS must not be able to restyle the toolbar into uselessness, and the
+ * toolbar's own CSS must not leak out. A global `:root` token from an add-on has
+ * broken a real host page before (apexstock shipped one and the website still
+ * carries a guard for it), so an add-on rendering UI on customer pages gets a
+ * closed styling boundary from the start rather than after the first bug report.
+ *
+ * Theming still works: CSS custom properties pierce the shadow boundary, so a
+ * host sets `--apx-analyst-*` on the chart container and every fallback here
+ * gives way. Colors are declared once as tokens on `:host` so the dark scheme is
+ * a token swap rather than a second copy of the rules.
+ *
+ * The DOM is built with createElement and textContent throughout. Series names,
+ * category labels and title text all come from user data, and an innerHTML
+ * template would make an XSS sink out of a chart label.
+ *
+ * @module AnalystPanel
+ */
+export default class AnalystPanel {
+    private container;
+    /** The toolbar's shadow host. Retained so a re-render can put the same node back. */
+    readonly host: HTMLElement;
+    /** The readout's shadow host, which lives on the far side of the chart. */
+    readonly panelHost: HTMLElement;
+    private bar;
+    private panel;
+    private buttons;
+    /**
+     * Two hosts rather than one, because they belong on opposite sides of a chart
+     * this layer does not own.
+     *
+     * The buttons have to sit above the chart, where a toolbar is looked for. The
+     * readout must not: opening a panel above the chart pushes the chart down the
+     * page by the panel's height, so the thing you were reading moves out from
+     * under the pointer at the moment you asked to learn more about it. A summary
+     * table is tall enough to shift the chart off screen entirely.
+     *
+     * Putting the readout after the chart means a second shadow root, and the
+     * stylesheet is duplicated into it, which is a few hundred bytes for the
+     * chart staying where the reader left it.
+     *
+     * @param container the chart's own container element
+     * @param before insert the toolbar before this node, or append
+     */
+    constructor(container: HTMLElement, before: Element | null);
+    /** Attach a shadow root carrying the stylesheet, once per host. */
+    private static rootFor;
+    /** Toolbar before the chart, readout after it. */
+    private insert;
+    /**
+     * Put the host back after a re-render detached it.
+     *
+     * Every `updateSeries()` / `updateOptions()` empties the chart's container
+     * outright (the core clears every child of the caller's element, not just the
+     * SVG), so anything a plugin puts there is removed on every update and the
+     * toolbar vanished the first time a tool changed the chart. Only the parent
+     * link is cut, and the host element object is still held here, so re-inserting
+     * the SAME node restores the shadow root, its stylesheet and the open panel in
+     * one DOM operation. Rebuilding it would drop the readout and leak a shadow
+     * root per update.
+     */
+    reattach(container: HTMLElement, before: Element | null): void;
+    /**
+     * (Re)build the button row.
+     * @param tools already filtered to the tools that apply to this chart
+     */
+    setTools(tools: Array<{
+        id: string;
+        label: string;
+    }>, onClick: (id: string) => void): void;
+    setPressed(id: string, on: boolean): void;
+    /** Clear the panel and return the element a tool should render into. */
+    openPanel(): HTMLElement;
+    closePanel(): void;
+    teardown(): void;
+}
+//# sourceMappingURL=AnalystPanel.d.ts.map

package/lib/AnalystPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnalystPanel.d.ts","sourceRoot":"","sources":["../../../libs/analyst/src/lib/AnalystPanel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AA6GH,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,OAAO,CAAC,SAAS,CAAc;IAC/B,qFAAqF;IACrF,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,OAAO,CAAC,GAAG,CAAc;IACzB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAwC;IAEvD;;;;;;;;;;;;;;;;OAgBG;gBACS,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IA4B1D,mEAAmE;IACnE,OAAO,CAAC,MAAM,CAAC,OAAO;IAQtB,kDAAkD;IAClD,OAAO,CAAC,MAAM;IAcd;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI;IAM9D;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAcxF,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI;IAKzC,wEAAwE;IACxE,SAAS,IAAI,WAAW;IAMxB,UAAU,IAAI,IAAI;IAKlB,QAAQ,IAAI,IAAI;CAMjB"}

package/lib/SeriesModel.d.ts

@@ -0,0 +1,39 @@
+import { WeaveAPI } from './weave';
+
+export interface AnalystSeries {
+    /** index into the chart's series array */
+    index: number;
+    name: string;
+    /** false when the viewer has toggled it off */
+    visible: boolean;
+    /** y values, gaps preserved as null */
+    values: Array<number | null>;
+    /**
+     * The x per position, as the host parsed it: the basis `api.scales.x()`
+     * projects, so a drawing tool can hand these straight to the scales.
+     */
+    xs: number[];
+    /** finite (x,y) pairs for fitting, gaps dropped */
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+}
+export interface AnalystModel {
+    /** true for line/area/bar/..., false for pie/donut */
+    axis: boolean;
+    /** the type the caller asked for */
+    type: string;
+    timeX: boolean;
+    /**
+     * Bar chart with horizontal:true, which swaps the value axis onto x, so a
+     * tool projecting y values through the scales would draw sideways.
+     */
+    horizontalBars: boolean;
+    series: AnalystSeries[];
+    /** x labels (axis charts) or slice labels */
+    categories: string[];
+}
+/** Snapshot a chart into the Analyst model. */
+export declare function buildModel(api: WeaveAPI): AnalystModel;
+//# sourceMappingURL=SeriesModel.d.ts.map

package/lib/SeriesModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SeriesModel.d.ts","sourceRoot":"","sources":["../../../libs/analyst/src/lib/SeriesModel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,SAAS,CAAC;AAEtC,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,uCAAuC;IACvC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC7B;;;OAGG;IACH,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,mDAAmD;IACnD,MAAM,EAAE,KAAK,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,YAAY;IAC3B,sDAAsD;IACtD,IAAI,EAAE,OAAO,CAAC;IACd,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAaD,+CAA+C;AAC/C,wBAAgB,UAAU,CAAC,GAAG,EAAE,QAAQ,GAAG,YAAY,CAsDtD"}

package/lib/clip.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Clipping drawn geometry to the chart's grid.
+ *
+ * Plugin layers are not covered by the chart's own grid clip mask, so anything
+ * drawn past the grid edge paints over the axes. A fitted line does exactly
+ * that whenever its endpoints fall outside the visible y range, which zooming
+ * makes routine, so overlay tools clip in pixel space before drawing.
+ *
+ * @module clip
+ */
+/** The grid rectangle in pixel space, as the scales report it. */
+export interface PixelRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+/**
+ * Clip a line segment to a rectangle (Liang-Barsky).
+ *
+ * @returns the visible part as `[x1, y1, x2, y2]`, or null when the segment
+ *   misses the rectangle entirely.
+ */
+export declare function clipSegment(x1: number, y1: number, x2: number, y2: number, rect: PixelRect): [number, number, number, number] | null;
+//# sourceMappingURL=clip.d.ts.map

package/lib/clip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clip.d.ts","sourceRoot":"","sources":["../../../libs/analyst/src/lib/clip.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,kEAAkE;AAClE,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,SAAS,GACd,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAgCzC"}

package/lib/emitLike.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Emit a derived datum in the same shape as the series it was derived from.
+ *
+ * ## Why not infer the axis
+ *
+ * A derived series has to match the axis: `{x,y}` pairs on a positional axis
+ * parse to all-null y, and a flat array on a datetime axis parses to all-null
+ * x. Both fail silently, so getting it wrong means a series sits on the chart
+ * drawing nothing.
+ *
+ * The first attempt inferred which case applied from the chart's internals, and
+ * every candidate signal turned out to be unusable:
+ *
+ *   - `config.xaxis.type` is rewritten to 'numeric' even when the caller passed
+ *     `xaxis.categories`
+ *   - `globals.isXNumeric` is true for every axis chart
+ *   - `globals.seriesX` is populated with 1-based slots on a category axis, so
+ *     its presence proves nothing about the axis
+ *   - `globals.categoryLabels` is correct on mount and EMPTY after an
+ *     `updateSeries()`, so the same chart classified differently depending on
+ *     which render path had just run
+ *
+ * That last one is the reason this module exists. Inference read state that is
+ * not stable across render paths, so a trend line emitted correctly on mount
+ * was emitted in the broken shape after any update.
+ *
+ * So nothing is inferred. The source datum IS the template: whatever shape the
+ * chart already accepts for this series, the derived series reuses, carrying
+ * the source's own x across verbatim. A string x ('Mon') travels as a string, an
+ * epoch number as an epoch number, and a bare value stays bare.
+ *
+ * @module emitLike
+ */
+/**
+ * @param datum the source series datum at the same position
+ * @param y the derived value
+ * @returns a datum in the source's shape
+ */
+export declare function emitLike(datum: unknown, y: number): unknown;
+/** How many decimal places the source values actually use. */
+export declare function decimalsOf(values: ReadonlyArray<number | null | undefined> | undefined): number;
+/**
+ * Round a computed value to the precision of the data it was derived from.
+ *
+ * A fitted value lands on 29.999999999999996 rather than 30, and an axis sizes
+ * its tick labels to the decimal count present in the data, so adding a trend
+ * line turned a bar chart whose ticks read 0 / 10 / 20 / 30 into one reading
+ * 0.0000000000000000 / 10.0000000000000000. Rounding to 12 significant digits
+ * was not enough: 100.434782608696 still asks the axis for nine decimals.
+ *
+ * Matching the source's own precision is also the honest rule. A least-squares
+ * fit over integer counts is not more precise than integer counts, and the
+ * residual visual error is half of one unit of a resolution the chart was
+ * already rounding to. Full precision stays available to a readout, which is
+ * where it belongs.
+ *
+ * @param decimals from decimalsOf() on the source series
+ */
+export declare function roundLike(y: number, decimals: number): number;
+/**
+ * The numeric x to fit against for a datum at position `index`.
+ *
+ * Derived from the source data rather than from the chart's parsed x array, for
+ * the same stability reason as above: that array is empty on some render paths,
+ * which silently changed the x basis of a refit.
+ *
+ * A non-numeric x (a category name) falls back to the ordinal position, which
+ * is the honest reading: a trend across named categories is a trend against
+ * their order. The fit and the prediction use the same basis either way, so a
+ * uniform shift in x leaves the predicted y values unchanged.
+ */
+export declare function xFor(datum: unknown, index: number): number;
+//# sourceMappingURL=emitLike.d.ts.map

package/lib/emitLike.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitLike.d.ts","sourceRoot":"","sources":["../../../libs/analyst/src/lib/emitLike.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAKH;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAa3D;AAED,8DAA8D;AAC9D,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,SAAS,GAAG,MAAM,CAqB/F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAS7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAY1D"}

package/lib/format.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Number formatting for Analyst readouts.
+ *
+ * Analysis output is read side by side with the chart, so a statistic printed
+ * at full float precision (`3.3000000000000003`) reads as a bug in the library
+ * rather than as floating point. These helpers are shared so every tool rounds
+ * the same way and a mean in the summary panel matches the same mean quoted in
+ * a trend readout.
+ *
+ * @module format
+ */
+/** Shown wherever a statistic has no defined value. */
+export declare const NO_VALUE = "n/a";
+/**
+ * Format a statistic for display.
+ *
+ * Significant digits rather than fixed decimals, because a chart's y values may
+ * be percentages (0.043), counts (128) or revenue (1284000) and one fixed
+ * decimal count is wrong for at least two of those. Locale-aware grouping,
+ * since these are numbers a person reads rather than parses.
+ *
+ * @param sig significant digits, default 6
+ */
+export declare function formatNumber(v: number | null | undefined, sig?: number): string;
+/** Format a 0..1 ratio as a percentage. */
+export declare function formatPercent(v: number | null | undefined): string;
+//# sourceMappingURL=format.d.ts.map

package/lib/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../libs/analyst/src/lib/format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uDAAuD;AACvD,eAAO,MAAM,QAAQ,QAAQ,CAAC;AAE9B;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,SAAI,GAAG,MAAM,CAkB1E;AAED,2CAA2C;AAC3C,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAGlE"}

package/lib/plugin.d.ts

@@ -0,0 +1,37 @@
+import { ApexChartsCtor, WeavePluginDefinition } from './weave';
+import { AnalystOptions } from './Analyst';
+
+export declare const PLUGIN_NAME = "analyst";
+/** The Weave plugin definition. */
+export declare const analystPlugin: WeavePluginDefinition;
+/**
+ * Register the plugin with an ApexCharts constructor.
+ *
+ * Idempotent. Charts opt in individually with `plugins: [{name: 'analyst'}]`.
+ */
+export declare function install(ApexCharts: ApexChartsCtor): void;
+/**
+ * Register the plugin AND make every chart created afterwards use it.
+ *
+ * Writes the plugin into the library's global chart defaults, so no chart needs
+ * a `plugins` entry of its own.
+ *
+ * One caveat, stated because it is silent otherwise: a chart that declares its
+ * own top-level `plugins` array overrides the global default rather than
+ * merging with it, so such a chart must list `analyst` itself.
+ *
+ * @param options passed to every chart's Analyst instance
+ */
+export declare function installOnEveryChart(ApexCharts: ApexChartsCtor, options?: AnalystOptions): void;
+/**
+ * Show the toolbar on every chart that already has the plugin.
+ *
+ * Only useful alongside `plugins: [{name: 'analyst', options: {enabled: false}}]`,
+ * where charts carry the plugin but render no toolbar until this is called.
+ * Charts created before the plugin was installed cannot be reached at all;
+ * this reports how many were missed rather than pretending to cover them.
+ *
+ * @returns how many charts the toolbar was attached to
+ */
+export declare function page(): number;
+//# sourceMappingURL=plugin.d.ts.map

package/lib/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../libs/analyst/src/lib/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,WAAW,CAAC;AAE9C,OAAO,KAAK,EAAC,cAAc,EAAY,qBAAqB,EAAC,MAAM,SAAS,CAAC;AAE7E,eAAO,MAAM,WAAW,YAAY,CAAC;AAErC,mCAAmC;AACnC,eAAO,MAAM,aAAa,EAAE,qBAW3B,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI,CAExD;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAS9F;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,IAAI,MAAM,CA0B7B"}

package/lib/registry.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The page-level registry of live Analyst instances.
+ *
+ * `page()` needs every chart on the page, and the chart library's own
+ * `Apex._chartInstances` cannot supply that: a chart joins it only when the
+ * caller declares `chart.id`, which is optional and uncommon.
+ *
+ * Instances self-register from their constructor and unregister on teardown, so
+ * the set holds only mounted charts.
+ *
+ * Stored on a versioned `globalThis` slot, matching the registries inside the
+ * chart library itself. A module-level Set would live once per copy of this
+ * module, and a page can hold two (a bundled import plus a script tag).
+ *
+ * @module registry
+ */
+type Registrable = {
+    attach(): void;
+};
+export declare function register(analyst: Registrable): void;
+export declare function unregister(analyst: Registrable): void;
+/**
+ * Every registered Analyst, in creation order (a Set preserves insertion order,
+ * which is the order the charts were created and so the reading order of the
+ * page in the overwhelmingly common case).
+ */
+export declare function all(): Registrable[];
+/**
+ * How many ApexCharts charts are actually in the document.
+ *
+ * Compared against the registry size to detect the load-order mistake: a chart
+ * created before the plugin was installed never got an Analyst instance and
+ * cannot be reached. Counts `.apexcharts-canvas` nodes, the wrap element the
+ * chart library creates for every chart on every render path.
+ *
+ * @returns -1 when there is no document to count (SSR)
+ */
+export declare function countChartsInDom(): number;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/lib/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../libs/analyst/src/lib/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,KAAK,WAAW,GAAG;IAAC,MAAM,IAAI,IAAI,CAAA;CAAC,CAAC;AAYpC,wBAAgB,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAEnD;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAErD;AAED;;;;GAIG;AACH,wBAAgB,GAAG,IAAI,WAAW,EAAE,CAEnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAGzC"}

package/lib/stats/Descriptive.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Descriptive statistics.
+ *
+ * Pure functions over `Array<number|null|undefined>`, because that is what a
+ * chart series actually holds: a null is a gap, and every one of these
+ * summaries has to skip gaps rather than read them as zero. Each function
+ * filters internally instead of trusting the caller to have cleaned the input,
+ * and reports how many values it dropped.
+ *
+ * No dependencies and no chart knowledge. The panel, a derived series and (in a
+ * later phase) an AI payload all read the same numbers from here rather than
+ * each reimplementing a mean.
+ *
+ * @module stats/Descriptive
+ */
+export interface Summary {
+    /** finite values used */
+    count: number;
+    /** values skipped (null / NaN / non-numeric) */
+    missing: number;
+    min: number;
+    max: number;
+    range: number;
+    sum: number;
+    mean: number;
+    median: number;
+    q1: number;
+    q3: number;
+    iqr: number;
+    /** sample variance (n-1) */
+    variance: number;
+    stdDev: number;
+}
+/**
+ * The finite numbers in a raw series, in order.
+ *
+ * `Number.isFinite` rather than `!= null` on purpose: NaN and Infinity reach a
+ * series through user formatters and arithmetic on missing values, and either
+ * one poisons a mean into NaN for the whole chart.
+ */
+export declare function finite(values: ReadonlyArray<number | null | undefined> | undefined): number[];
+/**
+ * Summarize one series.
+ *
+ * Returns null rather than a zero-filled object when there is nothing to
+ * summarize, so a caller has to decide what to show for an empty series instead
+ * of silently rendering "mean 0" for no data.
+ */
+export declare function summarize(values: ReadonlyArray<number | null | undefined> | undefined): Summary | null;
+//# sourceMappingURL=Descriptive.d.ts.map

package/lib/stats/Descriptive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Descriptive.d.ts","sourceRoot":"","sources":["../../../../libs/analyst/src/lib/stats/Descriptive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,OAAO;IACtB,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,SAAS,GAAG,MAAM,EAAE,CAQ7F;AAgBD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,SAAS,GAAG,OAAO,GAAG,IAAI,CA+CtG"}

package/lib/stats/Regression.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Ordinary-least-squares line fitting.
+ *
+ * Used by the trend tool now and by the forecast tool later, which is why the
+ * fit is returned as a describable object (slope, intercept, r2, predict)
+ * rather than as the two endpoints the trend line happens to need. A forecast
+ * extrapolates from the same fit, and a readout needs to say how well the line
+ * actually explains the data.
+ *
+ * @module stats/Regression
+ */
+export interface LinearFit {
+    /** change in y per unit x */
+    slope: number;
+    /** y at x = 0 */
+    intercept: number;
+    /** coefficient of determination, 0..1 */
+    r2: number;
+    /** points used */
+    n: number;
+    predict(x: number): number;
+}
+export interface FitPoint {
+    x: number;
+    y: number;
+}
+/**
+ * Fit y = slope*x + intercept by least squares.
+ *
+ * Pairs where either coordinate is non-finite are dropped: a series gap must
+ * not contribute a point at y=0, and an x gap has no position to contribute at
+ * all. Returns null when fewer than two usable pairs remain, or when every x is
+ * identical (a vertical line has no finite slope) rather than returning an
+ * Infinity a caller would then have to detect.
+ *
+ * x is centered before accumulating the sums. Chart x values are frequently
+ * epoch milliseconds, where x^2 is around 1e24 and the textbook
+ * `n*Sxy - Sx*Sy` form loses most of its significant digits to cancellation.
+ * Centering keeps the magnitudes small and costs one extra pass.
+ */
+export declare function linearFit(points: ReadonlyArray<FitPoint> | undefined): LinearFit | null;
+//# sourceMappingURL=Regression.d.ts.map

package/lib/stats/Regression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Regression.d.ts","sourceRoot":"","sources":["../../../../libs/analyst/src/lib/stats/Regression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,SAAS;IACxB,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,kBAAkB;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,GAAG,SAAS,GAAG,SAAS,GAAG,IAAI,CAwDvF"}

package/lib/testing/fakeWeave.d.ts

@@ -0,0 +1,59 @@
+import { WeaveAPI, WeaveChartInfo } from '../weave';
+
+/**
+ * The fixed grid the fake scales project into. Exported so tests can predict
+ * pixels. `left`/`top` are non-zero ON PURPOSE: the real rc.2 host bakes the
+ * layout translate into its scales while the layer group is already translated,
+ * and Analyst has to rebase them to layer space. A fake whose scales started at
+ * zero could not tell a rebased drawing from an unrebased one.
+ */
+export declare const FAKE_GRID: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export interface FakeChartSpec {
+    /** Series as the caller wrote them. */
+    series: Array<{
+        name: string;
+        data: unknown[];
+        hidden?: boolean;
+    }>;
+    categories?: string[];
+    info?: Partial<WeaveChartInfo>;
+    options?: Record<string, unknown>;
+}
+export interface FakeChart {
+    api: WeaveAPI;
+    el: HTMLElement;
+    /** Every series currently on the chart, in order. */
+    seriesNames(): string[];
+    seriesData(name: string): unknown[] | undefined;
+    /** Simulate the caller changing the data. */
+    update(series: Array<{
+        name: string;
+        data: unknown[];
+    }>): Promise<void>;
+    /** Fire the initial render hook. */
+    draw(): void;
+    destroy(): void;
+}
+export declare function makeFakeChart(spec: FakeChartSpec): FakeChart;
+/** The toolbar's shadow root for a given fake chart, or null. */
+export declare function shadowOf(chart: FakeChart): ShadowRoot | null;
+/**
+ * The readout's shadow root, which is a SEPARATE host from the toolbar's: the
+ * buttons go above the chart and the panel below it, so opening a readout
+ * cannot push the chart down the page.
+ */
+export declare function panelRootOf(chart: FakeChart): ShadowRoot | null;
+/** The readout element itself, or null when no toolbar is mounted. */
+export declare function panelOf(chart: FakeChart): HTMLElement | null;
+/** The plugin's drawing group inside the fake chart's SVG, or null. */
+export declare function overlayOf(chart: FakeChart): SVGGElement | null;
+/** The `<line>` elements currently drawn on the overlay. */
+export declare function overlayLines(chart: FakeChart): SVGLineElement[];
+export declare function buttonLabels(chart: FakeChart): string[];
+export declare function clickButton(chart: FakeChart, label: string): HTMLButtonElement;
+//# sourceMappingURL=fakeWeave.d.ts.map

package/lib/testing/fakeWeave.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeWeave.d.ts","sourceRoot":"","sources":["../../../../libs/analyst/src/lib/testing/fakeWeave.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAC,QAAQ,EAAE,cAAc,EAAkD,MAAM,UAAU,CAAC;AAIxG;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;;;;CAA+C,CAAC;AAEtE,MAAM,WAAW,aAAa;IAC5B,uCAAuC;IACvC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,EAAE,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC,CAAC;IACjE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,QAAQ,CAAC;IACd,EAAE,EAAE,WAAW,CAAC;IAChB,qDAAqD;IACrD,WAAW,IAAI,MAAM,EAAE,CAAC;IACxB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,GAAG,SAAS,CAAC;IAChD,6CAA6C;IAC7C,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,EAAE,CAAA;KAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtE,oCAAoC;IACpC,IAAI,IAAI,IAAI,CAAC;IACb,OAAO,IAAI,IAAI,CAAC;CACjB;AA8ED,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,CA4J5D;AAED,iEAAiE;AACjE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,IAAI,CAG5D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,IAAI,CAG/D;AAED,sEAAsE;AACtE,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,WAAW,GAAG,IAAI,CAE5D;AAED,uEAAuE;AACvE,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,WAAW,GAAG,IAAI,CAE9D;AAED,4DAA4D;AAC5D,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,EAAE,CAE/D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,EAAE,CAIvD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAS9E"}

package/lib/testing/jsdomSetup.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The shims a real ApexCharts instance needs to render under jsdom.
+ *
+ * jsdom implements the SVG DOM but none of its geometry, so anything that
+ * measures (`getBBox`) returns undefined and the chart throws while laying out
+ * axis labels. `ResizeObserver` is missing outright. Both are the same shims the
+ * chart library uses for its own jsdom suite; they are here rather than imported
+ * because the library does not publish its test scaffolding.
+ *
+ * The fixed 10x10 box means nothing rendered here is a claim about layout. These
+ * tests assert what the plugin puts INTO the chart and gets back out of it, and
+ * a real browser is where pixels are checked.
+ *
+ * @module testing/jsdomSetup
+ */
+declare const BOX: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+/** TypeScript's DOM lib has no `getBBox`, so the prototype is widened to add it. */
+type Measurable = {
+    getBBox?: () => typeof BOX;
+};
+declare function stubBBox(proto: object | undefined): void;
+//# sourceMappingURL=jsdomSetup.d.ts.map

package/lib/testing/jsdomSetup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsdomSetup.d.ts","sourceRoot":"","sources":["../../../../libs/analyst/src/lib/testing/jsdomSetup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,QAAA,MAAM,GAAG;;;;;;;;;CAA8E,CAAC;AAExF,oFAAoF;AACpF,KAAK,UAAU,GAAG;IAAC,OAAO,CAAC,EAAE,MAAM,OAAO,GAAG,CAAA;CAAC,CAAC;AAE/C,iBAAS,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAKjD"}

package/lib/testing/realChart.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Mounting a real ApexCharts instance, for the tests that have to.
+ *
+ * The chart library is a peer dependency of the published package and a dev
+ * dependency of this workspace. See the note in fakeWeave for which tests belong
+ * here and which belong against the fake host.
+ *
+ * The dev dependency is pinned exactly to `7.2.0-rc.2`. Exactly, not a range:
+ * this package declares `apiVersion: 2`, so the host it is tested against is
+ * the contract, and moving off it should be a decision rather than something an
+ * install does on its own. Moving the pin means running this file's tests
+ * against the new host and reading what changed under `src/modules/weave`.
+ *
+ * The peer range stays `>=7.2.0-rc.1`, which is the earliest host that carries
+ * Weave v2 and is the honest floor for a consumer. It is deliberately wider
+ * than the pin: the pin says what we test, the range says what works.
+ *
+ * When 7.2.0 stable lands, move the pin to it and tighten the peer range to
+ * `>=7.2.0`, so a consumer is not pointed at a prerelease.
+ *
+ * @module testing/realChart
+ */
+/** The chart internals these tests read. Not part of any public contract. */
+interface ChartInternals {
+    w: {
+        config: {
+            series: Array<{
+                name?: string;
+                data?: unknown[];
+            }>;
+            dataLabels?: {
+                enabled?: boolean;
+                enabledOnSeries?: number[];
+            };
+        };
+        globals: {
+            series: number[][];
+            seriesX: number[][];
+            initialSeries: Array<{
+                name?: string;
+                data?: unknown[];
+            }>;
+        };
+    };
+    render(): Promise<unknown>;
+    updateSeries(series: unknown[]): Promise<unknown>;
+    resetSeries(): void;
+    destroy(): void;
+}
+export interface RealChart {
+    chart: ChartInternals;
+    el: HTMLElement;
+    /** Every series on the chart, in order, derived ones included. */
+    names(): string[];
+    /** The data array as it sits in config: the shape the plugin emitted. */
+    raw(name: string): unknown[] | undefined;
+    /** Parsed y values. A wrong emitted shape shows up here as all-null. */
+    y(name: string): Array<number | null> | undefined;
+    /** Parsed x positions. A derived series must land on the source's. */
+    x(name: string): number[] | undefined;
+    destroy(): void;
+}
+/** Let a queued chart update and the render it causes finish. */
+export declare function settle(rounds?: number): Promise<void>;
+/**
+ * Render a chart with the analyst plugin attached.
+ *
+ * Animations are off because an animated update resolves on a timer, and a test
+ * that waits for one is measuring the machine.
+ */
+export declare function mountChart(options: Record<string, unknown>): Promise<RealChart>;
+/** The toolbar's shadow root for a real chart, or null when none attached. */
+export declare function shadowOf(chart: RealChart): ShadowRoot | null;
+export declare function buttonLabels(chart: RealChart): string[];
+/** Click a toolbar button and wait for whatever it queued against the chart. */
+export declare function clickButton(chart: RealChart, label: string): Promise<void>;
+/**
+ * The readout's shadow root, which is a SEPARATE host from the toolbar's: the
+ * buttons go above the chart and the panel below it, so opening a readout
+ * cannot push the chart down the page.
+ */
+export declare function panelRootOf(chart: RealChart): ShadowRoot | null;
+/** Text of the open readout panel. */
+export declare function panelText(chart: RealChart): string;
+/**
+ * The plugin's drawing group inside the REAL chart's SVG, or null. Its
+ * placement is the host's `_layer()` contract: a `<g class="apexcharts-plugin-
+ * analyst">` appended to the chart's graphical group, so it ships in the
+ * chart's own exports and needs no position syncing.
+ */
+export declare function overlayOf(chart: RealChart): SVGGElement | null;
+/** The `<line>` elements currently drawn on the overlay. */
+export declare function overlayLines(chart: RealChart): SVGLineElement[];
+export {};
+//# sourceMappingURL=realChart.d.ts.map