@weasel-js/plot 0.0.0-stage → 1.15.1

package/dist/scales.d.ts

@@ -0,0 +1,2 @@
+export { B as BandScale, g as BandScaleOptions, C as ContinuousScale, h as ContinuousScaleFactory, L as LinearScale, i as LinearScaleOptions, j as LogScale, k as LogScaleOptions, O as OrdinalScale, l as OrdinalScaleOptions, c as PolarScale, m as PolarScaleOptions, S as Scale, p as SpacedTickOptions, q as TickFormatCtx, r as TickFormatter, s as TickSet, T as TimeScale, t as TimeScaleOptions, u as bandScale, v as decimalsOf, w as formatInstant, x as formatNumber, y as formatTick, z as linearScale, A as logScale, D as niceDomain, E as niceStep, F as ordinalScale, G as polarScale, H as stepTicks, I as tickDecimals, J as tickStep, K as timeScale } from './scales.entry-BoLQpsxi.js';
+import '@weasel-js/geom';

package/dist/scales.entry-BoLQpsxi.d.ts

@@ -0,0 +1,275 @@
+import { Path } from '@weasel-js/geom';
+
+/** What every positional scale answers, and what an axis is drawn from: where a value sits along its range, the
+ *  values an axis marks, and how one reads. */
+interface Scale<T> {
+    readonly kind: 'linear' | 'log' | 'band' | 'time';
+    /** Where the scale's output runs, in drawing units: start to end, either way round. */
+    readonly range: readonly [number, number];
+    /** Where `value` sits along the range. A band scale answers its band's center. */
+    position(value: T): number;
+    /** The values an axis marks, about `count` of them where the scale chooses. */
+    ticks(count?: number): T[];
+    /** `value` as an axis label reads it. */
+    format(value: T): string;
+}
+/** A scale over numbers that maps both ways. */
+interface ContinuousScale extends Scale<number> {
+    readonly kind: 'linear' | 'log' | 'time';
+    readonly domain: readonly [number, number];
+    /** `value` along the range; the same as {@link Scale.position}. */
+    map(value: number): number;
+    /** The value at `at` along the range. */
+    invert(at: number): number;
+}
+/** What builds a continuous scale from its two ends: `linearScale`, `logScale`, `timeScale`, or one of your own.
+ *  A control that places values along its track takes one and calls it with a range of `[0, 1]`. */
+type ContinuousScaleFactory = (opts: {
+    domain: readonly [number, number];
+    range: readonly [number, number];
+}) => ContinuousScale;
+
+/** Options for {@link linearScale}. */
+interface LinearScaleOptions {
+    domain: readonly [number, number];
+    range: readonly [number, number];
+    /** Widen the domain out to whole tick steps for about this many ticks. Default no widening. */
+    nice?: number;
+}
+/** Options for {@link LinearScale.spacedTicks}. */
+interface SpacedTickOptions {
+    /** Smallest gap between neighboring ticks, in range units (px, for a scale onto the screen). */
+    minSpacing: number;
+    /** Ticks closer than this to either end of the range are dropped, in range units. Default 0. */
+    inset?: number;
+}
+/** A column of ticks and the facts its labels share. */
+interface TickSet {
+    /** Ascending, whichever way the domain runs. */
+    values: number[];
+    /** Distance between neighboring ticks. */
+    step: number;
+    /** Places after the point every label in the column shares. */
+    decimals: number;
+}
+/** A scale that maps numbers proportionally, as a value axis does. */
+interface LinearScale extends ContinuousScale {
+    readonly kind: 'linear';
+    /** The distance between ticks when about `count` are asked for. */
+    tickStep(count?: number): number;
+    /** Ticks on the finest 1/2/5 step that keeps neighbors `minSpacing` apart along the range, so a longer axis
+     *  gets more of them. Empty for an empty domain or range. */
+    spacedTicks(options: SpacedTickOptions): TickSet;
+}
+/** The round step, 1, 2 or 5 times a power of ten, that cuts `lo`..`hi` into about `count` pieces. */
+declare function tickStep(lo: number, hi: number, count?: number): number;
+/** How many decimals a value on a grid of `step` needs; 0 for a step that is not a positive number. */
+declare function decimalsOf(step: number): number;
+/** The smallest of 1, 2 or 5 times a power of ten that is at least `rough`. Unlike {@link tickStep}, which
+ *  rounds to the nearest, this never goes under: a minimum spacing stays a minimum. */
+declare function niceStep(rough: number): number;
+/** Every multiple of `step` from `lo` to `hi`, inclusive. */
+declare function stepTicks(lo: number, hi: number, step: number): number[];
+/** `value` written as plainly as a grid of `step` allows: no trailing zeros, no exponent. */
+declare function formatNumber(value: number, step: number): string;
+/** `domain` widened to whole steps of a tick grid of about `count` ticks. */
+declare function niceDomain(domain: readonly [number, number], count?: number): [number, number];
+/** A linear scale from `domain` onto `range`. */
+declare function linearScale(opts: LinearScaleOptions): LinearScale;
+
+/** What a tick label formatter knows about the column it is part of. */
+interface TickFormatCtx {
+    /** Places after the point that every label in the column shares. */
+    decimals: number;
+    /** Distance between neighboring ticks, or 0 when the ticks were given explicitly and are not evenly spaced. */
+    step: number;
+}
+/** Turns a tick value into its label. */
+type TickFormatter = (value: number, ctx: TickFormatCtx) => string;
+/** The most places after the point any of `values` needs, for a column of ticks given rather than generated. */
+declare function tickDecimals(values: readonly number[]): number;
+/** `value` fixed to its column's shared decimals, with no negative zero, so a column of labels lines up. */
+declare function formatTick(value: number, ctx: TickFormatCtx): string;
+
+/** Options for {@link logScale}. */
+interface LogScaleOptions {
+    /** Both ends above zero. */
+    domain: readonly [number, number];
+    range: readonly [number, number];
+    /** Default 10. */
+    base?: number;
+}
+/** A scale that maps the logarithm of a value proportionally. */
+interface LogScale extends ContinuousScale {
+    readonly kind: 'log';
+    readonly base: number;
+}
+/** A logarithmic scale from `domain`, whose ends must both be above zero, onto `range`. */
+declare function logScale(opts: LogScaleOptions): LogScale;
+
+/** Options for {@link bandScale}. */
+interface BandScaleOptions {
+    /** The categories, one band each, in order. */
+    domain: readonly string[];
+    range: readonly [number, number];
+    /** The share of each step left empty between bands, 0 to 1. Default 0.2. */
+    paddingInner?: number;
+    /** The room before the first band and after the last, in steps. Default half of `paddingInner`. */
+    paddingOuter?: number;
+}
+/** A scale that cuts its range into equal bands, one per category, as a bar chart's category axis does. */
+interface BandScale extends Scale<string> {
+    readonly kind: 'band';
+    readonly domain: readonly string[];
+    /** The width of each band. */
+    readonly bandwidth: number;
+    /** From one band's start to the next's. */
+    readonly step: number;
+    /** Where `key`'s band starts, or `NaN` for a key not in the domain. */
+    start(key: string): number;
+    /** The key whose band is nearest `at`; `undefined` for an empty domain. */
+    invert(at: number): string | undefined;
+}
+/** A band scale over `domain`. */
+declare function bandScale(opts: BandScaleOptions): BandScale;
+
+/** Options for {@link timeScale}. */
+interface TimeScaleOptions {
+    /** Milliseconds since the epoch, as `Date.getTime` gives them. */
+    domain: readonly [number, number];
+    range: readonly [number, number];
+}
+/** A scale over instants, whose ticks fall on whole seconds, minutes, hours, days, months or years, in UTC. */
+interface TimeScale extends ContinuousScale {
+    readonly kind: 'time';
+}
+type Unit = 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year';
+/** `t` written to the precision of `unit`. */
+declare function formatInstant(t: number, unit: Unit): string;
+/** A time scale from `domain`, in milliseconds since the epoch, onto `range`. */
+declare function timeScale(opts: TimeScaleOptions): TimeScale;
+
+/** Options for {@link ordinalScale}. */
+interface OrdinalScaleOptions<T> {
+    /** The keys, in order. */
+    domain: readonly string[];
+    /** What each key maps to, in domain order, wrapping when there are fewer than keys. */
+    range: readonly T[];
+}
+/** A scale from keys to values in turn, as a series' colors are chosen. */
+interface OrdinalScale<T> {
+    readonly kind: 'ordinal';
+    readonly domain: readonly string[];
+    readonly range: readonly T[];
+    /** `key`'s value; a key not in the domain takes the next value after the last, and joins the domain. */
+    map(key: string): T;
+    /** The keys a legend lists. */
+    ticks(): string[];
+    format(key: string): string;
+}
+/** An ordinal scale from `domain` to `range`. Throws on an empty range. */
+declare function ordinalScale<T>(opts: OrdinalScaleOptions<T>): OrdinalScale<T>;
+
+/** The kinds of mark a chart is drawn with. */
+type MarkKind = 'bar' | 'span' | 'line' | 'area' | 'point' | 'arc' | 'ribbon' | 'rule' | 'text';
+/** The value a mark stands for, as plain fields: a series and index, a category, a value. */
+type PlotDatum = Readonly<Record<string, string | number | boolean>>;
+/** What a mark's scene data says about it: its kind, and the datum it draws. */
+interface PlotMarkTrait {
+    kind: MarkKind;
+    datum?: PlotDatum;
+}
+/** A solid paint, as the kit's painters read one. */
+interface SolidFill {
+    paint: {
+        color: string;
+        opacity?: number;
+    };
+}
+/** A solid stroke, as the kit's painters read one. */
+interface SolidStroke {
+    paint: {
+        color: string;
+    };
+    width: number;
+    dash?: number[];
+    cap?: 'butt' | 'round' | 'square';
+    join?: 'miter' | 'round' | 'bevel';
+}
+/**
+ * A mark's scene data: the trait under `plotMark`, and the fields the kit's
+ * painters draw it from — `path` for a shape, a line or a region, `text` for
+ * a label.
+ */
+interface PlotMarkData {
+    plotMark: PlotMarkTrait;
+    path?: Path;
+    fill?: SolidFill;
+    stroke?: SolidStroke;
+    text?: string;
+    style?: {
+        fontFamily: string;
+        fontSize: number;
+        align?: 'left' | 'center' | 'right';
+        fontWeight?: number;
+    };
+    verticalAlign?: 'top' | 'center' | 'bottom';
+}
+/** A box, in the plot's own coordinates: from its root's corner. */
+interface PlotBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Radians about the box's center. */
+    rotation?: number;
+}
+/** One mark, ready to be a scene node: a key unique within its plot, where it is drawn, and its data. */
+interface PlotMark {
+    key: string;
+    pose: PlotBox;
+    data: PlotMarkData;
+}
+/** A point in the plot's coordinates. */
+interface PlotPoint {
+    x: number;
+    y: number;
+}
+
+/** Options for {@link polarScale}. */
+interface PolarScaleOptions {
+    center: PlotPoint;
+    /** The radius the domain's ends sit at: inner, then outer. */
+    radius: readonly [number, number];
+    domain: readonly [number, number];
+    /** How many spokes share the turn, evenly. */
+    axes: number;
+    /** Axis 0's angle, radians clockwise from twelve o'clock. Default 0. */
+    startAngle?: number;
+}
+/** A scale over spokes from a center, as a radar chart's axes are: a value along each of `axes` evenly spaced spokes. */
+interface PolarScale {
+    readonly kind: 'polar';
+    readonly center: PlotPoint;
+    readonly radius: readonly [number, number];
+    readonly domain: readonly [number, number];
+    readonly axes: number;
+    /** Axis `i`'s angle, radians clockwise from twelve o'clock, as `arcMark`'s are. */
+    angle(i: number): number;
+    /** How far from the center `value` sits on every axis. */
+    radiusAt(value: number): number;
+    /** Where `value` sits on axis `i`. */
+    point(i: number, value: number): PlotPoint;
+    /** The value of the point on axis `i` nearest `at`, clamped to the domain. */
+    valueAt(i: number, at: PlotPoint): number;
+    /** The distance between ticks when about `count` are asked for. */
+    tickStep(count?: number): number;
+    /** Round values across the domain, about `count` of them. */
+    ticks(count?: number): number[];
+    /** `value` as a tick label reads it. */
+    format(value: number): string;
+}
+/** A polar scale: values from `domain` out along `axes` spokes from `center`, `radius[0]` to `radius[1]` away. */
+declare function polarScale(opts: PolarScaleOptions): PolarScale;
+
+export { logScale as A, type BandScale as B, type ContinuousScale as C, niceDomain as D, niceStep as E, ordinalScale as F, polarScale as G, stepTicks as H, tickDecimals as I, tickStep as J, timeScale as K, type LinearScale as L, type MarkKind as M, type OrdinalScale as O, type PlotDatum as P, type Scale as S, type TimeScale as T, type PlotMark as a, type PlotPoint as b, type PolarScale as c, type PlotMarkData as d, type PlotMarkTrait as e, type PlotBox as f, type BandScaleOptions as g, type ContinuousScaleFactory as h, type LinearScaleOptions as i, type LogScale as j, type LogScaleOptions as k, type OrdinalScaleOptions as l, type PolarScaleOptions as m, type SolidFill as n, type SolidStroke as o, type SpacedTickOptions as p, type TickFormatCtx as q, type TickFormatter as r, type TickSet as s, type TimeScaleOptions as t, bandScale as u, decimalsOf as v, formatInstant as w, formatNumber as x, formatTick as y, linearScale as z };

package/dist/scales.js

@@ -0,0 +1,3 @@
+export { bandScale, decimalsOf, formatInstant, formatNumber, formatTick, linearScale, logScale, niceDomain, niceStep, ordinalScale, polarScale, stepTicks, tickDecimals, tickStep, timeScale } from './chunk-HA77BIQF.js';
+//# sourceMappingURL=scales.js.map
+//# sourceMappingURL=scales.js.map

package/dist/scales.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"scales.js"}

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@weasel-js/plot",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.15.1",
+  "description": "Charts on weasel's scene graph: scales, axes, and marks that keep their data, and chart specs compiled to them, edited by dragging the marks.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./scales": {
+      "import": "./dist/scales.js",
+      "types": "./dist/scales.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "author": "orochi235",
+  "homepage": "https://orochi235.github.io/weasel/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orochi235/weasel.git",
+    "directory": "packages/plot"
+  },
+  "bugs": {
+    "url": "https://github.com/orochi235/weasel/issues"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@weasel-js/geom": "1.15.1",
+    "@weasel-js/text": "1.15.1",
+    "@weasel-js/theme": "1.15.1"
+  },
+  "peerDependencies": {
+    "@weasel-js/core": "1.15.1",
+    "react": ">=18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}