@sportsdataverse/sdvplot 0.0.0-stage → 0.1.0

package/dist/chartjs-surface.d.ts

@@ -0,0 +1,42 @@
+import { Scene } from '@sportsdataverse/sporty';
+import { Plugin } from 'chart.js';
+import { S as SurfaceSceneOptions } from './surfaces-ChaD9nei.js';
+import { L as League } from './types-C7n6gJF3.js';
+import './resolve-CQW-jzvr.js';
+
+/**
+ * Chart.js 4 court / field / rink background: `surface(league, o)` paints a team-painted sporty scene under the
+ * datasets. Split from `sdvplot/chartjs` because it draws through `@sportsdataverse/sporty/canvas`, which the logo and
+ * colour plugins do not need. sporty is an optional peer, but this entry imports it when it loads, so install it to use
+ * `sdvplot/chartjs/surface`. `chart.js` is a type-only import (optional peer, 4.4 or later).
+ */
+
+interface ChartSurfaceOptions extends SurfaceSceneOptions {
+    /** The linear x scale's id (default `"x"`). */
+    xAxisID?: string;
+    /** The linear y scale's id (default `"y"`). */
+    yAxisID?: string;
+}
+interface LinearScale {
+    type: "linear";
+    min: number;
+    max: number;
+}
+interface ChartSurface {
+    /** Paints the surface before the datasets (`beforeDatasetsDraw`), clipped to the chart area. */
+    plugin: Plugin;
+    /** Linear scales spanning the surface, for `options.scales` (keep both axes linear). */
+    scales: {
+        x: LinearScale;
+        y: LinearScale;
+    };
+    scene: Scene;
+}
+/**
+ * A team-painted sporty surface as a Chart.js background: a shot chart is a scatter (a hexbin, a bubble chart) over a
+ * court. Throws `InputError` for a league without a surface, or for a scene whose bbox is empty (an `xlim` or `ylim` of
+ * zero width) here, when it is built, not inside a Chart.js draw. A non-linear axis is left unpainted, with one warning.
+ */
+declare function surface(league: League, o?: ChartSurfaceOptions): ChartSurface;
+
+export { type ChartSurface, type ChartSurfaceOptions, type LinearScale, surface };

package/dist/chartjs-surface.js

@@ -0,0 +1,65 @@
+import { surfaceScene } from './chunk-TDNBAEQB.js';
+import './chunk-J6R2LEJ7.js';
+import './chunk-TAXO3VXH.js';
+import { InputError, warn } from './chunk-E7G7VSLV.js';
+import { drawScene } from '@sportsdataverse/sporty/canvas';
+
+function surface(league, o = {}) {
+  const { xAxisID = "x", yAxisID = "y", ...rest } = o;
+  const scene = surfaceScene(league, rest);
+  const [x0, y0, x1, y1] = scene.bbox;
+  if (!(x1 > x0 && y1 > y0 && Number.isFinite(x1 - x0 + y1 - y0)))
+    throw new InputError(
+      `surface("${league}"): the scene's bbox [${scene.bbox.join(", ")}] is empty, so there is nothing to draw (check xlim / ylim)`
+    );
+  return {
+    plugin: {
+      id: "sdvplotSurface",
+      // Chart.js has no plugin priority: inline plugins run in array order, so a watermark listed first is painted over
+      start: (chart) => {
+        const ps = chart.config.plugins ?? [];
+        const own = ps.findIndex((p) => p.id === "sdvplotSurface");
+        const wm = ps.findIndex((p) => p.id === "sdvplotLogoWatermarks");
+        if (wm !== -1 && (own === -1 || wm < own))
+          warn(
+            "chartjs:surface:order",
+            "logoWatermarks is listed before the surface plugin, so the court is painted over it; list court.plugin first"
+          );
+      },
+      beforeDatasetsDraw: (chart) => paintScene(chart, scene, xAxisID, yAxisID)
+    },
+    scales: { x: { type: "linear", min: x0, max: x1 }, y: { type: "linear", min: y0, max: y1 } },
+    scene
+  };
+}
+function paintScene(chart, scene, xId, yId) {
+  const { ctx, chartArea: a } = chart;
+  const xs = chart.scales[xId];
+  const ys = chart.scales[yId];
+  if (!a || xs === void 0 || ys === void 0) return;
+  if (xs.type !== "linear" || ys.type !== "linear") {
+    warn(
+      `chartjs:surface:${xId}:${yId}`,
+      `surface needs linear scales (pass court.scales); ${xId} is ${xs.type} and ${yId} is ${ys.type}, so it is not drawn`
+    );
+    return;
+  }
+  const ox = xs.getPixelForValue(0);
+  const oy = ys.getPixelForValue(0);
+  const kx = xs.getPixelForValue(1) - ox;
+  const ky = ys.getPixelForValue(1) - oy;
+  const s = Math.abs(kx);
+  if (!(s > 0 && Number.isFinite(s + ky))) return;
+  const [x0, , , y1] = scene.bbox;
+  ctx.save();
+  ctx.beginPath();
+  ctx.rect(a.left, a.top, a.right - a.left, a.bottom - a.top);
+  ctx.clip();
+  ctx.transform(kx / s, 0, 0, -ky / s, ox + kx * x0, oy + ky * y1);
+  drawScene(ctx, scene, { scale: s });
+  ctx.restore();
+}
+
+export { surface };
+//# sourceMappingURL=chartjs-surface.js.map
+//# sourceMappingURL=chartjs-surface.js.map

package/dist/chartjs-surface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/chartjs-surface.ts"],"names":[],"mappings":"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","file":"chartjs-surface.js","sourcesContent":["/**\n * Chart.js 4 court / field / rink background: `surface(league, o)` paints a team-painted sporty scene under the\n * datasets. Split from `sdvplot/chartjs` because it draws through `@sportsdataverse/sporty/canvas`, which the logo and\n * colour plugins do not need. sporty is an optional peer, but this entry imports it when it loads, so install it to use\n * `sdvplot/chartjs/surface`. `chart.js` is a type-only import (optional peer, 4.4 or later).\n */\nimport type { Scene } from \"@sportsdataverse/sporty\";\nimport { drawScene } from \"@sportsdataverse/sporty/canvas\";\nimport type { Chart, Plugin } from \"chart.js\";\nimport { InputError, warn } from \"./errors.js\";\nimport { type SurfaceSceneOptions, surfaceScene } from \"./surfaces.js\";\nimport type { League } from \"./types.js\";\n\nexport interface ChartSurfaceOptions extends SurfaceSceneOptions {\n  /** The linear x scale's id (default `\"x\"`). */\n  xAxisID?: string;\n  /** The linear y scale's id (default `\"y\"`). */\n  yAxisID?: string;\n}\nexport interface LinearScale {\n  type: \"linear\";\n  min: number;\n  max: number;\n}\nexport interface ChartSurface {\n  /** Paints the surface before the datasets (`beforeDatasetsDraw`), clipped to the chart area. */\n  plugin: Plugin;\n  /** Linear scales spanning the surface, for `options.scales` (keep both axes linear). */\n  scales: { x: LinearScale; y: LinearScale };\n  scene: Scene;\n}\n/**\n * A team-painted sporty surface as a Chart.js background: a shot chart is a scatter (a hexbin, a bubble chart) over a\n * court. Throws `InputError` for a league without a surface, or for a scene whose bbox is empty (an `xlim` or `ylim` of\n * zero width) here, when it is built, not inside a Chart.js draw. A non-linear axis is left unpainted, with one warning.\n */\nexport function surface(league: League, o: ChartSurfaceOptions = {}): ChartSurface {\n  const { xAxisID = \"x\", yAxisID = \"y\", ...rest } = o;\n  const scene = surfaceScene(league, rest);\n  const [x0, y0, x1, y1] = scene.bbox;\n  // drawScene would throw sporty's InputError on the first draw, inside Chart.js's render loop\n  if (!(x1 > x0 && y1 > y0 && Number.isFinite(x1 - x0 + y1 - y0)))\n    throw new InputError(\n      `surface(\"${league}\"): the scene's bbox [${scene.bbox.join(\", \")}] is empty, so there is nothing to draw (check xlim / ylim)`,\n    );\n  return {\n    plugin: {\n      id: \"sdvplotSurface\",\n      // Chart.js has no plugin priority: inline plugins run in array order, so a watermark listed first is painted over\n      start: (chart) => {\n        const ps = chart.config.plugins ?? [];\n        const own = ps.findIndex((p) => p.id === \"sdvplotSurface\");\n        const wm = ps.findIndex((p) => p.id === \"sdvplotLogoWatermarks\");\n        if (wm !== -1 && (own === -1 || wm < own))\n          warn(\n            \"chartjs:surface:order\",\n            \"logoWatermarks is listed before the surface plugin, so the court is painted over it; list court.plugin first\",\n          );\n      },\n      beforeDatasetsDraw: (chart) => paintScene(chart, scene, xAxisID, yAxisID),\n    },\n    scales: { x: { type: \"linear\", min: x0, max: x1 }, y: { type: \"linear\", min: y0, max: y1 } },\n    scene,\n  };\n}\nfunction paintScene(chart: Chart, scene: Scene, xId: string, yId: string): void {\n  const { ctx, chartArea: a } = chart;\n  const xs = chart.scales[xId];\n  const ys = chart.scales[yId];\n  if (!a || xs === undefined || ys === undefined) return; // a draw before the first layout\n  if (xs.type !== \"linear\" || ys.type !== \"linear\") {\n    warn(\n      `chartjs:surface:${xId}:${yId}`,\n      `surface needs linear scales (pass court.scales); ${xId} is ${xs.type} and ${yId} is ${ys.type}, so it is not drawn`,\n    );\n    return;\n  }\n  const ox = xs.getPixelForValue(0);\n  const oy = ys.getPixelForValue(0);\n  const kx = xs.getPixelForValue(1) - ox; // px per scene unit; negative on a reversed axis\n  const ky = ys.getPixelForValue(1) - oy; // negative: y points up\n  const s = Math.abs(kx);\n  if (!(s > 0 && Number.isFinite(s + ky))) return; // a zero-size chart area\n  const [x0, , , y1] = scene.bbox;\n  ctx.save();\n  ctx.beginPath();\n  ctx.rect(a.left, a.top, a.right - a.left, a.bottom - a.top);\n  ctx.clip();\n  // drawScene paints (x, y) at (s(x - x0), s(y1 - y)) and composes with the current transform (the chart's own\n  // device-pixel-ratio transform stays under both): this map turns that into the chart's scales, axis by axis.\n  ctx.transform(kx / s, 0, 0, -ky / s, ox + kx * x0, oy + ky * y1);\n  drawScene(ctx, scene, { scale: s }); // strokes are 1/s scene units: one px wide\n  ctx.restore();\n}\n"]}

package/dist/chartjs.d.ts

@@ -0,0 +1,132 @@
+import { PointStyle, Plugin } from 'chart.js';
+import { E as EspnHeadshotLeague } from './headshots-B2J_LOO8.js';
+import { V as Value } from './resolve-CQW-jzvr.js';
+import { L as League, S as SeasonInput, V as Variant, I as IdSystem, H as HeadshotIdSystem, W as Which } from './types-C7n6gJF3.js';
+
+/**
+ * Chart.js 4 helpers: team logo / wordmark / headshot point styles, axis-tick logos, faint logo watermarks, team
+ * colours and a sporty surface background. `chart.js` is a type-only import (optional peer, 4.4 or later): everything
+ * here is a dataset option or a plugin object, so Svelte, Astro, React or plain scripts pass it to `new Chart(...)`
+ * unchanged.
+ * The sporty court background lives in `sdvplot/chartjs/surface`, so this entry never needs `@sportsdataverse/sporty`.
+ * Call after `loadLeague(league)` / `preloadAll()`; point styles and plugins need a DOM (build them client-side) unless
+ * given `loadImage`, which in Node is `@napi-rs/canvas`'s.
+ */
+
+interface PointOptions {
+    league: League;
+    /** Half the image height in px; also the dataset's `pointRadius` (hit area). Default 12. */
+    radius?: number;
+    season?: SeasonInput | readonly SeasonInput[];
+    variant?: Variant;
+    idSystem?: IdSystem;
+    /** What an unresolved value draws: `"text"` (its own label, the default) or any Chart.js point style. */
+    fallback?: PointStyle | "text";
+    /** The chart's background colour, so the text fallback reads on it (default white, or black with `variant: "dark"`). */
+    background?: string;
+    /**
+     * Loads each image instead of a DOM image element, so this also runs in Node: pass `@napi-rs/canvas`'s `loadImage`.
+     * See {@link ImageLike}.
+     */
+    loadImage?: (url: string) => Promise<ImageLike>;
+}
+interface HeadshotPointOptions {
+    league: EspnHeadshotLeague;
+    radius?: number;
+    idSystem?: HeadshotIdSystem;
+    fallback?: PointStyle | "text";
+    /** The chart's background colour, so the text fallback reads on it (default white). */
+    background?: string;
+    /**
+     * Loads each image instead of a DOM image element, so this also runs in Node: pass `@napi-rs/canvas`'s `loadImage`.
+     * See {@link ImageLike}.
+     */
+    loadImage?: (url: string) => Promise<ImageLike>;
+}
+/** Spread into a scatter / bubble / line dataset: one style per data point, in data order. */
+interface PointStyles {
+    pointStyle: PointStyle[];
+    pointRadius: number;
+}
+/**
+ * An image a `loadImage` option resolves: anything the chart's 2D context can `drawImage`, such as `@napi-rs/canvas`'s
+ * `Image` in Node or an `HTMLImageElement` in the browser. `loadImage` is called once per URL and drawn size, and the
+ * image's `width` and `height` are then set to that size (Chart.js draws an image point style at its own size), so
+ * resolve a new image on every call, as `@napi-rs/canvas`'s `loadImage` does.
+ */
+interface ImageLike {
+    readonly width: number;
+    readonly height: number;
+}
+/** Team logos as point styles: `{ data, ...logoPoints(teams, { league: "nfl", radius: 12 }) }`. Add `pointImages` to `plugins`. */
+declare function logoPoints(teams: readonly Value[], o: PointOptions): PointStyles;
+/** As `logoPoints`, with wordmarks. */
+declare function wordmarkPoints(teams: readonly Value[], o: PointOptions): PointStyles;
+/** ESPN player headshots as point styles; `idSystem: "gsis"` needs `loadGsis()` first. */
+declare function headshotPoints(players: readonly Value[], o: HeadshotPointOptions): PointStyles;
+/** Redraws the chart as each image point style finishes loading (Chart.js does not watch them). */
+declare const pointImages: Plugin;
+interface TeamColorOptions {
+    which?: Which;
+    season?: SeasonInput;
+    idSystem?: IdSystem;
+    /** Opacity in [0, 1]; below 1 the colour is written `rgba(r, g, b, a)`. */
+    alpha?: number;
+    /** The colour of an unresolved team (default `#808080`). */
+    fallback?: string;
+    /** Return black or white, whichever reads on the team colour (labels, point borders). */
+    onColor?: boolean;
+}
+type ColorsFor<T> = T extends readonly Value[] ? string[] : string;
+/** Team colour(s) for `backgroundColor` / `borderColor`: one team gives one string, an array gives one per team. */
+declare function teamColor<T extends Value | readonly Value[]>(teams: T, league: League, o?: TeamColorOptions): ColorsFor<T>;
+/** `teamColor` at 0.2 opacity by default: the fill under a radar or area dataset. */
+declare function teamFill<T extends Value | readonly Value[]>(teams: T, league: League, o?: TeamColorOptions): ColorsFor<T>;
+interface AxisLogoOptions {
+    league: League;
+    /** Image height in px (default 24); the width follows the mark's aspect. */
+    size?: number;
+    season?: SeasonInput;
+    variant?: Variant;
+    markType?: "logo" | "wordmark";
+    idSystem?: IdSystem;
+    /** The category scale's id (default: the axis letter). */
+    scaleId?: string;
+    /**
+     * Loads each image instead of a DOM image element, so this also runs in Node: pass `@napi-rs/canvas`'s `loadImage`.
+     * See {@link ImageLike}.
+     */
+    loadImage?: (url: string) => Promise<ImageLike>;
+}
+/**
+ * Swap a category axis's tick labels for team logos: resolved labels are painted as images (after the datasets, under
+ * the tooltip) and their text is blanked; unresolved labels keep their text, with one warning per distinct label set
+ * (J28). Any other scale type is left as it is, with one warning.
+ */
+declare function axisLogos(axis: "x" | "y", o: AxisLogoOptions): Plugin;
+interface WatermarkOptions {
+    league: League;
+    /** Image height in px (default 75, Game on Paper's win-probability chart); the width follows the mark's aspect. */
+    size?: number;
+    /** Opacity of the watermarks (default 0.4). */
+    alpha?: number;
+    /** Gap in px from the chart area's left edge and from its top / bottom (default 8). */
+    inset?: number;
+    season?: SeasonInput | readonly SeasonInput[];
+    variant?: Variant;
+    idSystem?: IdSystem;
+    /**
+     * Loads each image instead of a DOM image element, so this also runs in Node: pass `@napi-rs/canvas`'s `loadImage`.
+     * See {@link ImageLike}.
+     */
+    loadImage?: (url: string) => Promise<ImageLike>;
+}
+/**
+ * Faint team logos behind the datasets (Game on Paper's win-probability chart): the first team sits top-left of the
+ * chart area, the last bottom-left, any between spaced evenly down the left edge, so pass `[home, away]` under a home
+ * win-probability line. Unknown teams are skipped with one warning per call (J28); `variant: "dark"` falls back to a
+ * light mark by polarity, so no `onerror` retry is needed.
+ */
+declare function logoWatermarks(teams: readonly Value[], o: WatermarkOptions): Plugin;
+
+export { type AxisLogoOptions, type ColorsFor, type HeadshotPointOptions, type ImageLike, type PointOptions, type PointStyles, type TeamColorOptions, type WatermarkOptions, axisLogos, headshotPoints, logoPoints, logoWatermarks, pointImages, teamColor, teamFill, wordmarkPoints };

package/dist/chartjs.js

@@ -0,0 +1,339 @@
+import { checkAlpha, placeSync } from './chunk-RMT2GMFH.js';
+import './chunk-KKH6ABMA.js';
+import { hex6, onColor, contrast } from './chunk-J6R2LEJ7.js';
+import { teamColorsSync } from './chunk-TAXO3VXH.js';
+import { InputError, warn, UnsupportedTargetError } from './chunk-E7G7VSLV.js';
+
+// src/chartjs.ts
+function needDom(what) {
+  if (typeof document === "undefined")
+    throw new UnsupportedTargetError(
+      `${what} needs a DOM: build it in the browser (onMount, $effect, an Astro client:only island), not during SSR`
+    );
+  return document;
+}
+function checkSize(size, what) {
+  if (!(Number.isFinite(size) && size > 0))
+    throw new InputError(`${what} is an image height in px > 0, got ${size}`);
+  return size;
+}
+var images = /* @__PURE__ */ new Map();
+function image(url, h, aspect) {
+  const w = Math.round(h * aspect);
+  const key = `${w}x${h} ${url}`;
+  let img = images.get(key);
+  if (img === void 0) {
+    img = needDom("an image point style").createElement("img");
+    img.width = w;
+    img.height = h;
+    img.crossOrigin = "anonymous";
+    img.src = url;
+    images.set(key, img);
+  }
+  return img;
+}
+var Loading = class {
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+  }
+  width;
+  height;
+  img = void 0;
+  /** Point-style slots to fill, then charts to redraw, all in the first reaction to the loader's promise. */
+  slots = [];
+  on = /* @__PURE__ */ new Set();
+};
+var sizes = /* @__PURE__ */ new WeakMap();
+var DRAWN = ["[object HTMLImageElement]", "[object HTMLCanvasElement]"];
+function sized(img, w, h) {
+  const was = sizes.get(img);
+  if (was !== void 0 && (was.width !== w || was.height !== h)) {
+    warn(
+      "chartjs:loadImage:shared",
+      "loadImage returned an image already sized for another drawn size, so that use is not drawn: loadImage must return a fresh image per call (wrap a cache so each call returns a new image)"
+    );
+    return null;
+  }
+  const own = (value) => ({ value, writable: true, configurable: true });
+  const tag = DRAWN.includes(String(img)) ? {} : { toString: own(() => DRAWN[0]) };
+  try {
+    Object.defineProperties(img, { width: own(w), height: own(h), ...tag });
+  } catch (e) {
+    warn(
+      "chartjs:loadImage:unsizable",
+      `loadImage returned an image that cannot be sized (${String(e)}), so it is not drawn`
+    );
+    return null;
+  }
+  sizes.set(img, { width: w, height: h });
+  return img;
+}
+var loads = /* @__PURE__ */ new WeakMap();
+function loading(load, url, h, aspect) {
+  const w = Math.round(h * aspect);
+  const key = `${w}x${h} ${url}`;
+  const byKey = loads.get(load) ?? /* @__PURE__ */ new Map();
+  loads.set(load, byKey);
+  let m = byKey.get(key);
+  if (m === void 0) {
+    const it = new Loading(w, h);
+    const land = (img) => {
+      it.img = img;
+      if (img !== null) for (const [styles, i] of it.slots) styles[i] = img;
+      it.slots.length = 0;
+      const redraws2 = [...it.on];
+      it.on.clear();
+      for (const f of redraws2) f();
+    };
+    void load(url).then(
+      (img) => land(sized(img, w, h)),
+      (e) => {
+        warn(`chartjs:loadImage:${url}`, `loadImage failed for ${url} (${String(e)}), so it is not drawn`);
+        land(null);
+      }
+    );
+    m = it;
+    byKey.set(key, m);
+  }
+  return m;
+}
+function textInk(background) {
+  return contrast("#555555", background) >= contrast("#e8e6e3", background) ? "#555555" : "#e8e6e3";
+}
+function textStyle(label, h, ink) {
+  if (typeof document === "undefined") return "circle";
+  const c = document.createElement("canvas");
+  const g = c.getContext("2d");
+  if (g === null) return "circle";
+  const font = `bold ${Math.round(h * 0.45)}px sans-serif`;
+  g.font = font;
+  c.width = Math.max(h, Math.ceil(g.measureText(label).width) + 4);
+  c.height = h;
+  g.font = font;
+  g.textAlign = "center";
+  g.textBaseline = "middle";
+  g.fillStyle = ink;
+  g.fillText(label, c.width / 2, h / 2);
+  return c;
+}
+function imagesFor(values, h, place, load) {
+  const out = new Array(values.length);
+  const idx = values.map((_, i) => i);
+  for (const p of placeSync(idx, idx, values, place))
+    out[p.index] = load === void 0 ? image(p.url, h, p.aspect ?? 1) : loading(load, p.url, h, p.aspect ?? 1);
+  return out;
+}
+var pending = /* @__PURE__ */ new WeakMap();
+function points(values, kind, radius, fallback, background, place, load) {
+  if (load === void 0) needDom("point styles");
+  const r = radius ?? 12;
+  if (!(Number.isFinite(r) && r > 0))
+    throw new InputError(`radius is a point radius in px > 0, got ${String(radius)}`);
+  const ink = textInk(background ?? (place.variant === "dark" ? "#000000" : "#ffffff"));
+  const styles = new Array(values.length);
+  const waiting = [];
+  imagesFor(values, 2 * r, { ...place, kind }, load).forEach((m, i) => {
+    if (m === void 0) return;
+    if (!(m instanceof Loading)) {
+      styles[i] = m;
+      return;
+    }
+    styles[i] = m.img ?? false;
+    if (m.img !== void 0) return;
+    m.slots.push([styles, i]);
+    waiting.push(m);
+  });
+  if (waiting.length > 0) pending.set(styles, waiting);
+  for (let i = 0; i < values.length; i++)
+    styles[i] ??= fallback === void 0 || fallback === "text" ? textStyle(String(values[i] ?? ""), 2 * r, ink) : fallback;
+  return { pointStyle: styles, pointRadius: r };
+}
+function teamPoints(teams, kind, o) {
+  const { league, radius, fallback, background, loadImage, ...rest } = o;
+  return points(teams, kind, radius, fallback, background, { league, ...rest }, loadImage);
+}
+function logoPoints(teams, o) {
+  return teamPoints(teams, "logo", o);
+}
+function wordmarkPoints(teams, o) {
+  return teamPoints(teams, "wordmark", o);
+}
+function headshotPoints(players, o) {
+  return points(
+    players,
+    "headshot",
+    o.radius,
+    o.fallback,
+    o.background,
+    { league: o.league, idSystem: o.idSystem ?? "espn" },
+    o.loadImage
+  );
+}
+var redraws = /* @__PURE__ */ new WeakMap();
+var isImage = (v) => Object.prototype.toString.call(v) === "[object HTMLImageElement]";
+function redrawsOf(chart) {
+  let r = redraws.get(chart);
+  if (r === void 0) {
+    r = {
+      redraw: () => {
+        if (chart.ctx) chart.draw();
+      },
+      refresh: () => {
+        if (chart.ctx) chart.update("none");
+      },
+      stop: new AbortController()
+    };
+    redraws.set(chart, r);
+  }
+  return r;
+}
+function redrawOnLoad(chart, img) {
+  if (img.complete) return;
+  const r = redrawsOf(chart);
+  img.addEventListener("load", r.redraw, { once: true, signal: r.stop.signal });
+}
+function redrawOnLanding(chart, m, how) {
+  const r = redrawsOf(chart);
+  const f = r[how];
+  if (m.on.has(f)) return;
+  m.on.add(f);
+  r.stop.signal.addEventListener("abort", () => m.on.delete(f), { once: true });
+}
+function paint(chart, m) {
+  if (m === void 0) return void 0;
+  if (m instanceof Loading) {
+    if (m.img === void 0) redrawOnLanding(chart, m, "redraw");
+    return m.img ?? void 0;
+  }
+  if (!m.complete || m.naturalWidth === 0) {
+    redrawOnLoad(chart, m);
+    return void 0;
+  }
+  return m;
+}
+function forget(chart) {
+  redraws.get(chart)?.stop.abort();
+  redraws.delete(chart);
+}
+var pointImages = {
+  id: "sdvplotPointImages",
+  afterDestroy: forget,
+  afterDraw(chart) {
+    for (const ds of chart.data.datasets) {
+      const s = ds.pointStyle;
+      for (const v of Array.isArray(s) ? s : [s]) if (isImage(v)) redrawOnLoad(chart, v);
+      for (const m of Array.isArray(s) && pending.get(s) || [])
+        if (m.img === void 0) redrawOnLanding(chart, m, "refresh");
+    }
+  }
+};
+function teamColor(teams, league, o = {}) {
+  const { alpha = 1, fallback = "#808080", onColor: ink = false, ...co } = o;
+  const a = checkAlpha(alpha);
+  const paint2 = (c) => {
+    const hex = hex6(typeof c === "string" ? c : fallback, { dropAlpha: true });
+    if (ink) return onColor(hex);
+    if (a === 1) return hex;
+    const n = Number.parseInt(hex.slice(1), 16);
+    return `rgba(${n >> 16}, ${n >> 8 & 255}, ${n & 255}, ${a})`;
+  };
+  const got = teamColorsSync(league, teams, co);
+  return Array.isArray(got) ? got.map(paint2) : paint2(got);
+}
+function teamFill(teams, league, o = {}) {
+  return teamColor(teams, league, { alpha: 0.2, ...o });
+}
+function axisLogos(axis, o) {
+  if (axis !== "x" && axis !== "y")
+    throw new InputError(`axis must be "x" or "y", got ${JSON.stringify(axis)}`);
+  const { league, size = 24, markType = "logo", scaleId = axis, loadImage, ...rest } = o;
+  checkSize(size, "size");
+  const byChart = /* @__PURE__ */ new WeakMap();
+  const bases = /* @__PURE__ */ new WeakMap();
+  return {
+    id: `sdvplotAxisLogos${axis.toUpperCase()}`,
+    afterDestroy: forget,
+    beforeUpdate(chart) {
+      const conf = chart.config;
+      const scale = conf.options.scales?.[scaleId];
+      if (scale?.type !== "category") {
+        byChart.delete(chart);
+        warn(
+          `chartjs:axisLogos:${scaleId}`,
+          `axisLogos needs a category scale; scale ${JSON.stringify(scaleId)} is ${scale?.type ?? "missing"}, so its ticks are left as they are`
+        );
+        return;
+      }
+      const labels = (chart.data.labels ?? []).map(String);
+      const m = /* @__PURE__ */ new Map();
+      imagesFor(labels, size, { league, kind: markType, ...rest }, loadImage).forEach((img, i) => {
+        if (img !== void 0) m.set(labels[i] ?? "", img);
+      });
+      const band = axis === "y" ? Math.max(size, ...[...m.values()].map((img) => img.width)) : size;
+      byChart.set(chart, { m, band });
+      scale.ticks ??= {};
+      const ticks = scale.ticks;
+      const user = ticks.callback;
+      let base = user === void 0 ? void 0 : bases.get(user);
+      if (base === void 0) {
+        base = ticks.padding ?? 3;
+        const callback = function(value, index, all) {
+          const label = this.getLabelForValue(Number(value));
+          if (byChart.get(chart)?.m.has(label)) return "";
+          return user === void 0 ? label : user.call(this, value, index, all);
+        };
+        bases.set(callback, base);
+        ticks.callback = callback;
+      }
+      ticks.padding = base + band;
+    },
+    afterDatasetsDraw(chart) {
+      const scale = chart.scales[scaleId];
+      const got = byChart.get(chart);
+      if (scale === void 0 || got === void 0) return;
+      const { m, band } = got;
+      const { grid, ticks } = scale.options;
+      const gap = (grid.display && grid.drawTicks ? grid.tickLength : 0) + ticks.padding - band;
+      scale.ticks.forEach((t, i) => {
+        const img = paint(chart, m.get(scale.getLabelForValue(t.value)));
+        if (img === void 0) return;
+        const at = scale.getPixelForTick(i);
+        const { width: w, height: h } = img;
+        const x = axis === "y" ? scale.position === "right" ? scale.left + gap : scale.right - gap - w : at - w / 2;
+        const y = axis === "x" ? scale.position === "top" ? scale.bottom - gap - h : scale.top + gap : at - h / 2;
+        chart.ctx.drawImage(img, x, y, w, h);
+      });
+    }
+  };
+}
+function logoWatermarks(teams, o) {
+  if (o.loadImage === void 0) needDom("logo watermarks");
+  const { league, size = 75, alpha = 0.4, inset = 8, loadImage, ...rest } = o;
+  checkSize(size, "size");
+  const a = checkAlpha(alpha);
+  const imgs = imagesFor(teams, size, { league, kind: "logo", ...rest }, loadImage);
+  const n = imgs.length;
+  return {
+    id: "sdvplotLogoWatermarks",
+    afterDestroy: forget,
+    beforeDatasetsDraw(chart) {
+      const { ctx, chartArea: ar } = chart;
+      if (!ar) return;
+      ctx.save();
+      ctx.globalAlpha = a;
+      imgs.forEach((m, i) => {
+        const img = paint(chart, m);
+        if (img === void 0) return;
+        const t = n > 1 ? i / (n - 1) : 0;
+        const y = ar.top + inset + t * (ar.bottom - ar.top - 2 * inset - img.height);
+        ctx.drawImage(img, ar.left + inset, y, img.width, img.height);
+      });
+      ctx.restore();
+    }
+  };
+}
+
+export { axisLogos, headshotPoints, logoPoints, logoWatermarks, pointImages, teamColor, teamFill, wordmarkPoints };
+//# sourceMappingURL=chartjs.js.map
+//# sourceMappingURL=chartjs.js.map