react-cheminfo 0.9.0 → 0.11.0

package/lib/overlay/core/emptiestCorner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emptiestCorner.js","sourceRoot":"","sources":["../../../src/overlay/core/emptiestCorner.ts"],"names":[],"mappings":"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"}

package/lib/overlay/core/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Where a floating control sits over a figure, and how big it is.
+ *
+ * The geometry lives apart from the components that use it so it can be
+ * reasoned about and tested without a browser: which corner of a scatter is
+ * emptiest, whether a panel has room for a labelled strip or only a gear, and
+ * where a card must flip so it stays on screen.
+ */
+export type { EmptiestCornerOptions } from './emptiestCorner.ts';
+export { emptiestCorner } from './emptiestCorner.ts';
+export { shouldCollapseOverlay } from './overlayCollapse.ts';
+export type { OverlayMarkShape } from './overlayMarks.ts';
+export { OVERLAY_MARK_SHAPES, isFilledMark } from './overlayMarks.ts';
+export type { OverlayDensity, OverlayMetrics, OverlayPointerKind, } from './overlayMetrics.ts';
+export { overlayMetrics } from './overlayMetrics.ts';
+export type { OverlayCorner, OverlayCornerStyle, OverlayPlacement, } from './overlayPlacement.ts';
+export { overlayCornerStyle } from './overlayPlacement.ts';
+export type { OverlayTierRoom, OverlayTierSetting } from './overlayTierRoom.ts';
+export type { OverlayTier, OverlayTierWidths } from './overlayTiers.ts';
+export { overlayTier, overlayTierWidths } from './overlayTiers.ts';
+export type { OverlayCardPlacement, OverlayCardPlacementOptions, } from './placeOverlayCard.ts';
+export { placeOverlayCard } from './placeOverlayCard.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/overlay/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/overlay/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtE,YAAY,EACV,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,YAAY,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAChF,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACnE,YAAY,EACV,oBAAoB,EACpB,2BAA2B,GAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}

package/lib/overlay/core/index.js

@@ -0,0 +1,16 @@
+/**
+ * Where a floating control sits over a figure, and how big it is.
+ *
+ * The geometry lives apart from the components that use it so it can be
+ * reasoned about and tested without a browser: which corner of a scatter is
+ * emptiest, whether a panel has room for a labelled strip or only a gear, and
+ * where a card must flip so it stays on screen.
+ */
+export { emptiestCorner } from "./emptiestCorner.js";
+export { shouldCollapseOverlay } from "./overlayCollapse.js";
+export { OVERLAY_MARK_SHAPES, isFilledMark } from "./overlayMarks.js";
+export { overlayMetrics } from "./overlayMetrics.js";
+export { overlayCornerStyle } from "./overlayPlacement.js";
+export { overlayTier, overlayTierWidths } from "./overlayTiers.js";
+export { placeOverlayCard } from "./placeOverlayCard.js";
+//# sourceMappingURL=index.js.map

package/lib/overlay/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/overlay/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAMtE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAMrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAG3D,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAKnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}

package/lib/overlay/core/overlayCollapse.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Whether a floating card folds into a single button at this figure width.
+ *
+ * A width of zero — which is what a figure reports before it has been measured,
+ * and what a server render always reports — keeps the card expanded, so the
+ * string-rendering tests and the first paint both see the real controls. A
+ * threshold that is not a real number is read the same way, so a missing
+ * breakpoint never silently hides every control on the figure.
+ * @param width - Width of the figure, in pixels.
+ * @param collapseBelow - The width under which the card folds.
+ * @returns Whether it folds.
+ */
+export declare function shouldCollapseOverlay(width: number, collapseBelow: number): boolean;
+//# sourceMappingURL=overlayCollapse.d.ts.map

package/lib/overlay/core/overlayCollapse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayCollapse.d.ts","sourceRoot":"","sources":["../../../src/overlay/core/overlayCollapse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,OAAO,CAIT"}

package/lib/overlay/core/overlayCollapse.js

@@ -0,0 +1,20 @@
+/**
+ * Whether a floating card folds into a single button at this figure width.
+ *
+ * A width of zero — which is what a figure reports before it has been measured,
+ * and what a server render always reports — keeps the card expanded, so the
+ * string-rendering tests and the first paint both see the real controls. A
+ * threshold that is not a real number is read the same way, so a missing
+ * breakpoint never silently hides every control on the figure.
+ * @param width - Width of the figure, in pixels.
+ * @param collapseBelow - The width under which the card folds.
+ * @returns Whether it folds.
+ */
+export function shouldCollapseOverlay(width, collapseBelow) {
+    if (!Number.isFinite(width) || width <= 0)
+        return false;
+    if (!Number.isFinite(collapseBelow))
+        return false;
+    return width < collapseBelow;
+}
+//# sourceMappingURL=overlayCollapse.js.map

package/lib/overlay/core/overlayCollapse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayCollapse.js","sourceRoot":"","sources":["../../../src/overlay/core/overlayCollapse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAa,EACb,aAAqB;IAErB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IACxD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC;QAAE,OAAO,KAAK,CAAC;IAClD,OAAO,KAAK,GAAG,aAAa,CAAC;AAC/B,CAAC"}

package/lib/overlay/core/overlayMarks.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The marks a legend entry, a reference point or a series can be drawn with.
+ *
+ * It lives in the framework-free half although only a component ever draws
+ * one, because the data that names a mark is written far from the drawing: a
+ * k-means centroid says it is a cross while it is still a plain object, long
+ * before any of it reaches React. Keeping the union here is what lets a result
+ * describe its own marks without a `core` module reaching into a `ui` one.
+ */
+/** Which mark a legend entry, a marker or a series stands for. */
+export type OverlayMarkShape = 'dot' | 'ring' | 'square' | 'line' | 'dashed' | 'cross';
+/**
+ * Every mark, in the order a picker offers them.
+ *
+ * The first three separate one filled thing from another by colour alone; the
+ * last three carry a second meaning on one figure — a line for a component
+ * beside dots for the samples — which is what keeps a figure readable when the
+ * colours run out or the reader does not separate two of them.
+ */
+export declare const OVERLAY_MARK_SHAPES: readonly OverlayMarkShape[];
+/**
+ * Whether a mark is drawn as a solid area rather than as a stroke.
+ *
+ * A solid mark takes its colour as a fill and a stroked one as a stroke, which
+ * is the one thing every renderer of a mark has to know and the one thing that
+ * is easy to get wrong in each of them separately.
+ * @param shape - The mark.
+ * @returns `true` for the filled marks, `false` for the drawn ones.
+ */
+export declare function isFilledMark(shape: OverlayMarkShape): boolean;
+//# sourceMappingURL=overlayMarks.d.ts.map

package/lib/overlay/core/overlayMarks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayMarks.d.ts","sourceRoot":"","sources":["../../../src/overlay/core/overlayMarks.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,kEAAkE;AAClE,MAAM,MAAM,gBAAgB,GAC1B,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE1D;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,gBAAgB,EAO1D,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAE7D"}

package/lib/overlay/core/overlayMarks.js

@@ -0,0 +1,38 @@
+/**
+ * The marks a legend entry, a reference point or a series can be drawn with.
+ *
+ * It lives in the framework-free half although only a component ever draws
+ * one, because the data that names a mark is written far from the drawing: a
+ * k-means centroid says it is a cross while it is still a plain object, long
+ * before any of it reaches React. Keeping the union here is what lets a result
+ * describe its own marks without a `core` module reaching into a `ui` one.
+ */
+/**
+ * Every mark, in the order a picker offers them.
+ *
+ * The first three separate one filled thing from another by colour alone; the
+ * last three carry a second meaning on one figure — a line for a component
+ * beside dots for the samples — which is what keeps a figure readable when the
+ * colours run out or the reader does not separate two of them.
+ */
+export const OVERLAY_MARK_SHAPES = [
+    'dot',
+    'ring',
+    'square',
+    'line',
+    'dashed',
+    'cross',
+];
+/**
+ * Whether a mark is drawn as a solid area rather than as a stroke.
+ *
+ * A solid mark takes its colour as a fill and a stroked one as a stroke, which
+ * is the one thing every renderer of a mark has to know and the one thing that
+ * is easy to get wrong in each of them separately.
+ * @param shape - The mark.
+ * @returns `true` for the filled marks, `false` for the drawn ones.
+ */
+export function isFilledMark(shape) {
+    return shape === 'dot' || shape === 'square';
+}
+//# sourceMappingURL=overlayMarks.js.map

package/lib/overlay/core/overlayMarks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayMarks.js","sourceRoot":"","sources":["../../../src/overlay/core/overlayMarks.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAgC;IAC9D,KAAK;IACL,MAAM;IACN,QAAQ;IACR,MAAM;IACN,QAAQ;IACR,OAAO;CACR,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,KAAuB;IAClD,OAAO,KAAK,KAAK,KAAK,IAAI,KAAK,KAAK,QAAQ,CAAC;AAC/C,CAAC"}

package/lib/overlay/core/overlayMetrics.d.ts

@@ -0,0 +1,41 @@
+/** How tightly a floating card packs its controls. */
+export type OverlayDensity = 'compact' | 'comfortable';
+/**
+ * What kind of pointer the reader has.
+ *
+ * A finger cannot hover and cannot aim at a twenty-four pixel target, so a
+ * coarse pointer overrides the density outright rather than nudging it.
+ */
+export type OverlayPointerKind = 'fine' | 'coarse';
+/** Every measurement a floating card and its controls are drawn from. */
+export interface OverlayMetrics {
+    /** Height of a control, in pixels. */
+    controlHeight: number;
+    /** Space between two controls, and between a caption and its control. */
+    gap: number;
+    /** Space inside the card, left and right. */
+    paddingX: number;
+    /** Space inside the card, top and bottom. */
+    paddingY: number;
+    /** Size of the text a control says. */
+    fontSize: number;
+    /** Size of the caption in front of a control. */
+    labelSize: number;
+    /** Corner radius of a control; the card itself uses `--radius`. */
+    controlRadius: number;
+    /** Space kept between the card and the edge of the figure. */
+    inset: number;
+    /** Side of the square button the card collapses to. */
+    buttonSize: number;
+    /** The size Blueprint's own controls are asked for. */
+    blueprintSize: 'small' | 'medium' | 'large';
+}
+/**
+ * The measurements a card is drawn from.
+ * @param density - How tightly the caller asked for the controls to be packed.
+ * @param pointer - What the reader is pointing with. Defaults to `'fine'`.
+ * @returns The measurements. A coarse pointer always gets the largest set,
+ * whatever the density says.
+ */
+export declare function overlayMetrics(density: OverlayDensity, pointer?: OverlayPointerKind): OverlayMetrics;
+//# sourceMappingURL=overlayMetrics.d.ts.map

package/lib/overlay/core/overlayMetrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayMetrics.d.ts","sourceRoot":"","sources":["../../../src/overlay/core/overlayMetrics.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,aAAa,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEnD,yEAAyE;AACzE,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,GAAG,EAAE,MAAM,CAAC;IACZ,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,aAAa,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,aAAa,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;CAC7C;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,cAAc,EACvB,OAAO,GAAE,kBAA2B,GACnC,cAAc,CAGhB"}

package/lib/overlay/core/overlayMetrics.js

@@ -0,0 +1,73 @@
+/**
+ * The measurements a card is drawn from.
+ * @param density - How tightly the caller asked for the controls to be packed.
+ * @param pointer - What the reader is pointing with. Defaults to `'fine'`.
+ * @returns The measurements. A coarse pointer always gets the largest set,
+ * whatever the density says.
+ */
+export function overlayMetrics(density, pointer = 'fine') {
+    if (pointer === 'coarse')
+        return COARSE_METRICS;
+    return density === 'compact' ? COMPACT_METRICS : COMFORTABLE_METRICS;
+}
+/**
+ * The set a figure embedded in somebody else's page is drawn from.
+ *
+ * A figure that is a guest on a page it does not own has to spend as little of
+ * that page as it can, so every measurement here is the smallest one that is
+ * still honest. The control stays at twenty-four pixels — the floor a mouse
+ * can be aimed at, and the reason nothing below it is offered at all — while
+ * the room around it goes: a four pixel gap, a three pixel band above and
+ * below, and a six pixel inset from the figure's edge. A bar built from these
+ * stands thirty pixels tall, which is one line of the host's own text.
+ *
+ * The type steps down a size with it. Eleven pixels is what a control says and
+ * ten is what its caption says, because the caption is read once to find the
+ * control and the control's own words are read every time it is used.
+ */
+const COMPACT_METRICS = {
+    controlHeight: 24,
+    gap: 4,
+    paddingX: 6,
+    paddingY: 3,
+    fontSize: 11,
+    labelSize: 10,
+    controlRadius: 5,
+    inset: 6,
+    buttonSize: 24,
+    blueprintSize: 'small',
+};
+/** The everyday set: room to read the captions without crowding the figure. */
+const COMFORTABLE_METRICS = {
+    controlHeight: 30,
+    gap: 8,
+    paddingX: 8,
+    paddingY: 6,
+    fontSize: 12,
+    labelSize: 11,
+    controlRadius: 6,
+    inset: 8,
+    buttonSize: 30,
+    blueprintSize: 'medium',
+};
+/**
+ * Forty pixels is the smallest target a fingertip hits reliably, and the type
+ * grows with it because a phone is held further from the eye than a screen.
+ *
+ * Nothing here follows the density down. A finger does not become smaller
+ * because the figure was embedded, so a compact chart on a phone is a compact
+ * chart whose controls are still forty pixels across.
+ */
+const COARSE_METRICS = {
+    controlHeight: 40,
+    gap: 10,
+    paddingX: 10,
+    paddingY: 8,
+    fontSize: 13,
+    labelSize: 12,
+    controlRadius: 8,
+    inset: 10,
+    buttonSize: 40,
+    blueprintSize: 'large',
+};
+//# sourceMappingURL=overlayMetrics.js.map

package/lib/overlay/core/overlayMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayMetrics.js","sourceRoot":"","sources":["../../../src/overlay/core/overlayMetrics.ts"],"names":[],"mappings":"AAmCA;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAC5B,OAAuB,EACvB,UAA8B,MAAM;IAEpC,IAAI,OAAO,KAAK,QAAQ;QAAE,OAAO,cAAc,CAAC;IAChD,OAAO,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,mBAAmB,CAAC;AACvE,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,eAAe,GAAmB;IACtC,aAAa,EAAE,EAAE;IACjB,GAAG,EAAE,CAAC;IACN,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,EAAE;IACZ,SAAS,EAAE,EAAE;IACb,aAAa,EAAE,CAAC;IAChB,KAAK,EAAE,CAAC;IACR,UAAU,EAAE,EAAE;IACd,aAAa,EAAE,OAAO;CACvB,CAAC;AAEF,+EAA+E;AAC/E,MAAM,mBAAmB,GAAmB;IAC1C,aAAa,EAAE,EAAE;IACjB,GAAG,EAAE,CAAC;IACN,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,EAAE;IACZ,SAAS,EAAE,EAAE;IACb,aAAa,EAAE,CAAC;IAChB,KAAK,EAAE,CAAC;IACR,UAAU,EAAE,EAAE;IACd,aAAa,EAAE,QAAQ;CACxB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,cAAc,GAAmB;IACrC,aAAa,EAAE,EAAE;IACjB,GAAG,EAAE,EAAE;IACP,QAAQ,EAAE,EAAE;IACZ,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,EAAE;IACZ,SAAS,EAAE,EAAE;IACb,aAAa,EAAE,CAAC;IAChB,KAAK,EAAE,EAAE;IACT,UAAU,EAAE,EAAE;IACd,aAAa,EAAE,OAAO;CACvB,CAAC"}

package/lib/overlay/core/overlayPlacement.d.ts

@@ -0,0 +1,60 @@
+/** Which corner of a figure a floating card sits in. */
+export type OverlayCorner = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+/**
+ * Where a floating card sits: over one of the figure's corners, or docked
+ * outside the picture entirely.
+ *
+ * The three docked forms are the escape hatch for a figure whose data reaches
+ * all four corners. A chart that cannot spare a corner should move its
+ * controls out rather than cover the one cluster the reader came for.
+ *
+ * `stretch` is the one that spans the whole width rather than sitting at one
+ * end of the row: the settings bar of a figure embedded in somebody else's
+ * page, which is chrome above the picture and not a card floating on it. It is
+ * deliberately not offered as a floating placement — a full-width strip over a
+ * figure covers the very data it is there to explain.
+ */
+export type OverlayPlacement = OverlayCorner | 'above' | 'below' | 'stretch';
+/**
+ * The offsets a placement gives a card.
+ *
+ * Written out as a plain object of numbers rather than borrowed from React, so
+ * the whole of this entry point stays free of the framework that eventually
+ * spreads it onto a `style` prop. Only the two edges a corner is actually
+ * measured from are present: a key carrying `undefined` would still win over
+ * an offset the caller had merged in underneath it.
+ */
+export interface OverlayCornerStyle {
+    /** Whether the card is lifted out of the flow, or left in it and docked. */
+    position: 'absolute' | 'static';
+    /**
+     * Distance from the figure's top edge, in pixels.
+     * @default undefined — absent unless the card sits in a top corner
+     */
+    top?: number;
+    /**
+     * Distance from the figure's right edge, in pixels.
+     * @default undefined — absent unless the card sits in a right corner
+     */
+    right?: number;
+    /**
+     * Distance from the figure's bottom edge, in pixels.
+     * @default undefined — absent unless the card sits in a bottom corner
+     */
+    bottom?: number;
+    /**
+     * Distance from the figure's left edge, in pixels.
+     * @default undefined — absent unless the card sits in a left corner
+     */
+    left?: number;
+}
+/**
+ * The positioning a placement gives a card.
+ * @param placement - Where the card sits.
+ * @param inset - Distance kept between the card and the figure's edge, in pixels.
+ * @returns The style to spread onto the card. Every docked placement returns
+ * `position: 'static'`, so the same component lays out in the flow without a
+ * second code path.
+ */
+export declare function overlayCornerStyle(placement: OverlayPlacement, inset: number): OverlayCornerStyle;
+//# sourceMappingURL=overlayPlacement.d.ts.map

package/lib/overlay/core/overlayPlacement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayPlacement.d.ts","sourceRoot":"","sources":["../../../src/overlay/core/overlayPlacement.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,MAAM,MAAM,aAAa,GACvB,UAAU,GAAG,WAAW,GAAG,aAAa,GAAG,cAAc,CAAC;AAE5D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AAE7E;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,4EAA4E;IAC5E,QAAQ,EAAE,UAAU,GAAG,QAAQ,CAAC;IAChC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAC3B,KAAK,EAAE,MAAM,GACZ,kBAAkB,CAcpB"}

package/lib/overlay/core/overlayPlacement.js

@@ -0,0 +1,24 @@
+/**
+ * The positioning a placement gives a card.
+ * @param placement - Where the card sits.
+ * @param inset - Distance kept between the card and the figure's edge, in pixels.
+ * @returns The style to spread onto the card. Every docked placement returns
+ * `position: 'static'`, so the same component lays out in the flow without a
+ * second code path.
+ */
+export function overlayCornerStyle(placement, inset) {
+    if (placement === 'top-left') {
+        return { position: 'absolute', top: inset, left: inset };
+    }
+    if (placement === 'top-right') {
+        return { position: 'absolute', top: inset, right: inset };
+    }
+    if (placement === 'bottom-left') {
+        return { position: 'absolute', bottom: inset, left: inset };
+    }
+    if (placement === 'bottom-right') {
+        return { position: 'absolute', bottom: inset, right: inset };
+    }
+    return { position: 'static' };
+}
+//# sourceMappingURL=overlayPlacement.js.map

package/lib/overlay/core/overlayPlacement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayPlacement.js","sourceRoot":"","sources":["../../../src/overlay/core/overlayPlacement.ts"],"names":[],"mappings":"AAsDA;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,SAA2B,EAC3B,KAAa;IAEb,IAAI,SAAS,KAAK,UAAU,EAAE,CAAC;QAC7B,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IAC3D,CAAC;IACD,IAAI,SAAS,KAAK,WAAW,EAAE,CAAC;QAC9B,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IAC5D,CAAC;IACD,IAAI,SAAS,KAAK,aAAa,EAAE,CAAC;QAChC,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IAC9D,CAAC;IACD,IAAI,SAAS,KAAK,cAAc,EAAE,CAAC;QACjC,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IAC/D,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAChC,CAAC"}

package/lib/overlay/core/overlayTierRoom.d.ts

@@ -0,0 +1,89 @@
+/**
+ * What a bar of controls is holding, and how much room each part of it needs.
+ *
+ * Every width here is an estimate of laid-out type rather than a measurement.
+ * Measuring the real labels would mean putting them in the document and
+ * reading their boxes back, which costs a layout pass on every render of every
+ * embedded figure on the page — and the answer would still arrive one frame
+ * after the width that prompted it. The estimate is deliberately generous: a
+ * bar that folds a word early costs the reader a caret, while one that folds
+ * late runs its controls off the edge of the figure.
+ *
+ * The geometry is restated here rather than read off the styles that draw it,
+ * because those styles are React's and this has to answer on a server, before
+ * anything exists to measure. Being an estimate is the point — it is allowed
+ * to be a few pixels out, and it is not allowed to need a browser.
+ */
+import type { OverlayMetrics } from './overlayMetrics.ts';
+/** One setting at the far end of a bar, for the room needed to write it. */
+export interface OverlayTierSetting {
+    /**
+     * The word written in front of the value where there is room — `Outlines`,
+     * `Colour`. It is the first thing dropped, because the name of a setting is
+     * read once and its value is read every time.
+     */
+    key: string;
+    /** What the setting currently reads: `Species`, `95%`. */
+    value: string;
+    /**
+     * Whether a row of the figure's own colours rides in front of the words.
+     * @default false
+     */
+    swatches?: boolean;
+}
+/** What a bar is holding, for the widths it needs to hold it. */
+export interface OverlayTierRoom {
+    /** What each tab reads. Empty for a figure with a single view. */
+    tabs: readonly string[];
+    /**
+     * The short form of each tab, in the same order — `Explains` for `How much
+     * each explains`. A tab with no short form keeps its long one, so shortening
+     * the two labels that are long does not blank the two that are not.
+     * @default the tabs themselves, which shortens nothing
+     */
+    shortTabs?: readonly string[];
+    /** The settings at the far end, in the order they are written. */
+    settings: readonly OverlayTierSetting[];
+    /**
+     * How many bare glyphs ride at the end: the `?` and the cog.
+     * @default 2
+     */
+    glyphs?: number;
+}
+/**
+ * The tab strip, sunken track and all.
+ * @param labels - What each tab reads.
+ * @param metrics - The measurements the bar is drawn from.
+ * @returns The width in pixels; `0` where there is no strip at all.
+ */
+export declare function overlayStripWidth(labels: readonly string[], metrics: OverlayMetrics): number;
+/**
+ * The settings, each written as a value button of its own.
+ * @param settings - What the bar holds at its far end.
+ * @param withKeys - Whether each value still carries its key word.
+ * @param metrics - The measurements the bar is drawn from.
+ * @returns The width in pixels, the gaps between the buttons included.
+ */
+export declare function overlaySettingsWidth(settings: readonly OverlayTierSetting[], withKeys: boolean, metrics: OverlayMetrics): number;
+/**
+ * Every setting gathered into one chip.
+ *
+ * What the chip saves is one button's worth of padding and one caret per
+ * setting it swallows — never the words themselves, which are the whole reason
+ * the reader is given a chip rather than a cog.
+ * @param settings - What the bar holds at its far end.
+ * @param metrics - The measurements the bar is drawn from.
+ * @returns The width in pixels.
+ */
+export declare function overlayChipRoom(settings: readonly OverlayTierSetting[], metrics: OverlayMetrics): number;
+/**
+ * The bare glyphs at the very end of the bar, with the bar's own padding.
+ *
+ * One extra gap is counted for the space between the two ends of the row,
+ * which is what a bar spanning the figure pushes its ends apart with.
+ * @param glyphs - How many bare glyphs ride at the end.
+ * @param metrics - The measurements the bar is drawn from.
+ * @returns The width in pixels.
+ */
+export declare function overlayTailWidth(glyphs: number, metrics: OverlayMetrics): number;
+//# sourceMappingURL=overlayTierRoom.d.ts.map

package/lib/overlay/core/overlayTierRoom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayTierRoom.d.ts","sourceRoot":"","sources":["../../../src/overlay/core/overlayTierRoom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,4EAA4E;AAC5E,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,kEAAkE;IAClE,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACxC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,EAAE,cAAc,GACtB,MAAM,CAQR;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,cAAc,GACtB,MAAM,CAYR;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,OAAO,EAAE,cAAc,GACtB,MAAM,CAeR;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,cAAc,GACtB,MAAM,CAIR"}

package/lib/overlay/core/overlayTierRoom.js

@@ -0,0 +1,135 @@
+/**
+ * What a bar of controls is holding, and how much room each part of it needs.
+ *
+ * Every width here is an estimate of laid-out type rather than a measurement.
+ * Measuring the real labels would mean putting them in the document and
+ * reading their boxes back, which costs a layout pass on every render of every
+ * embedded figure on the page — and the answer would still arrive one frame
+ * after the width that prompted it. The estimate is deliberately generous: a
+ * bar that folds a word early costs the reader a caret, while one that folds
+ * late runs its controls off the edge of the figure.
+ *
+ * The geometry is restated here rather than read off the styles that draw it,
+ * because those styles are React's and this has to answer on a server, before
+ * anything exists to measure. Being an estimate is the point — it is allowed
+ * to be a few pixels out, and it is not allowed to need a browser.
+ */
+/**
+ * The tab strip, sunken track and all.
+ * @param labels - What each tab reads.
+ * @param metrics - The measurements the bar is drawn from.
+ * @returns The width in pixels; `0` where there is no strip at all.
+ */
+export function overlayStripWidth(labels, metrics) {
+    if (labels.length === 0)
+        return 0;
+    const segment = 2 * (metrics.paddingX + 2) + OVERLAY_TRACK_PADDING;
+    let total = OVERLAY_TRACK_PADDING * 2;
+    for (const label of labels) {
+        total += overlayTextWidth(label, metrics) + segment;
+    }
+    return total;
+}
+/**
+ * The settings, each written as a value button of its own.
+ * @param settings - What the bar holds at its far end.
+ * @param withKeys - Whether each value still carries its key word.
+ * @param metrics - The measurements the bar is drawn from.
+ * @returns The width in pixels, the gaps between the buttons included.
+ */
+export function overlaySettingsWidth(settings, withKeys, metrics) {
+    let total = 0;
+    for (let index = 0; index < settings.length; index++) {
+        const setting = settings[index];
+        if (setting === undefined)
+            continue;
+        const written = withKeys
+            ? `${setting.key} ${setting.value}`
+            : setting.value;
+        total += controlWidth(written, setting.swatches === true, metrics);
+        if (index > 0)
+            total += metrics.gap;
+    }
+    return total;
+}
+/**
+ * Every setting gathered into one chip.
+ *
+ * What the chip saves is one button's worth of padding and one caret per
+ * setting it swallows — never the words themselves, which are the whole reason
+ * the reader is given a chip rather than a cog.
+ * @param settings - What the bar holds at its far end.
+ * @param metrics - The measurements the bar is drawn from.
+ * @returns The width in pixels.
+ */
+export function overlayChipRoom(settings, metrics) {
+    let written = '';
+    let swatches = false;
+    let separators = 0;
+    for (let index = 0; index < settings.length; index++) {
+        const setting = settings[index];
+        if (setting === undefined)
+            continue;
+        written += setting.value;
+        if (setting.swatches === true)
+            swatches = true;
+        if (index > 0)
+            separators++;
+    }
+    return (controlWidth(written, swatches, metrics) +
+        separators * OVERLAY_CHIP_SEPARATOR);
+}
+/**
+ * The bare glyphs at the very end of the bar, with the bar's own padding.
+ *
+ * One extra gap is counted for the space between the two ends of the row,
+ * which is what a bar spanning the figure pushes its ends apart with.
+ * @param glyphs - How many bare glyphs ride at the end.
+ * @param metrics - The measurements the bar is drawn from.
+ * @returns The width in pixels.
+ */
+export function overlayTailWidth(glyphs, metrics) {
+    const count = Number.isFinite(glyphs) ? Math.max(0, Math.floor(glyphs)) : 0;
+    const buttons = count * (metrics.buttonSize + metrics.gap);
+    return buttons + 2 * metrics.paddingX + metrics.gap;
+}
+/**
+ * The room a run of words takes.
+ * @param text - The words.
+ * @param metrics - The measurements the bar is drawn from.
+ * @returns The width in pixels.
+ */
+function overlayTextWidth(text, metrics) {
+    return text.length * metrics.fontSize * OVERLAY_CHARACTER_RATIO;
+}
+/**
+ * What one character of a label takes, as a fraction of the type size.
+ *
+ * A mixed-case interface sans averages a little over half its size per
+ * character. This sits above that average on purpose: the labels that decide a
+ * fold are the long ones, and a long label of wide letters is the case where
+ * being wrong runs the row off the figure rather than merely folding it early.
+ */
+const OVERLAY_CHARACTER_RATIO = 0.58;
+/** The band of sunken track showing around a segment, on every side. */
+const OVERLAY_TRACK_PADDING = 2;
+/** How many colours the swatch glyph draws before the last becomes a count. */
+const OVERLAY_SWATCH_DOTS = 4;
+/** What sits between two settings inside a chip, hairline and margins. */
+const OVERLAY_CHIP_SEPARATOR = 9;
+/**
+ * One button carrying words, a caret, and possibly a row of colours.
+ * @param written - The words on it.
+ * @param swatches - Whether the figure's colours ride in front of them.
+ * @param metrics - The measurements the bar is drawn from.
+ * @returns The width in pixels, never under the button's own floor.
+ */
+function controlWidth(written, swatches, metrics) {
+    const dot = Math.max(4, Math.round(metrics.buttonSize / 6));
+    const glyph = swatches
+        ? OVERLAY_SWATCH_DOTS * dot + (OVERLAY_SWATCH_DOTS - 1) * 2 + 4
+        : 0;
+    const room = 2 * metrics.paddingX + metrics.fontSize;
+    return Math.max(metrics.buttonSize, overlayTextWidth(written, metrics) + glyph + room);
+}
+//# sourceMappingURL=overlayTierRoom.js.map

package/lib/overlay/core/overlayTierRoom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayTierRoom.js","sourceRoot":"","sources":["../../../src/overlay/core/overlayTierRoom.ts"],"names":[],"mappings":"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"}