ngwr 15.0.1 → 15.2.0

package/types/ngwr-charts-waterfall-chart.d.ts

@@ -0,0 +1,338 @@
+import * as i0 from "@angular/core";
+import { WrChartTableData } from "ngwr/charts/core";
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * One step of a `<wr-waterfall-chart>`: a change that moves the running total, or — with
+ * `total` — a bar from zero that shows it.
+ */
+interface WrWaterfallStep {
+  /** The step's name, under its bar, in the tooltip, in its accessible name and as its row header in the data table. */
+  readonly label: string;
+  /**
+   * How much the step moves the running total: up for a positive value, down for a
+   * negative one. Zero is neither: a hairline at the running total in the chart's neutral
+   * `--wr-waterfall-chart-flat-color`, classed `--flat`, printed `0` with no sign. A value
+   * that is not a finite number counts as zero, and so is drawn the same way — one bad
+   * figure cannot break every total after it, nor pass for growth.
+   *
+   * On a `total` step it is the total itself, and the chart CHECKS it rather than draws
+   * it: the bar is the running total the steps above add up to, and in dev mode a value
+   * that differs warns. The one exception is a total that comes before every change, where
+   * there is nothing to add up yet: its value is where the running total starts — an
+   * opening balance.
+   */
+  readonly value: number;
+  /**
+   * Draw the step as a total: a full bar from zero to the running total, in the chart's
+   * `totalColor`, with its figure written unsigned. @default false
+   */
+  readonly total?: boolean;
+}
+/**
+ * Where a `<wr-waterfall-chart>` is about to write a figure, handed to its `valueFormat`
+ * as the second argument: `'label'` for the figure printed past a bar, where room is
+ * tight and a compact form fits (`1.2K`); `'tick'` for the value axis; `'value'` for the
+ * tooltip, the accessible names and the data table, where a reader goes for the exact
+ * figure.
+ */
+type WrWaterfallValueContext = 'label' | 'tick' | 'value';
+/** What a step is: a change up, a change down, a change of nothing, or a total from zero. */
+type Kind = 'increase' | 'decrease' | 'flat' | 'total';
+/** One step as drawn and announced. */
+interface DrawnStep {
+  readonly label: string;
+  readonly kind: Kind;
+  readonly start: number;
+  readonly end: number;
+  /** The bar's bottom and top, as percentages of the drawing's height from its bottom. */
+  readonly lo: number;
+  readonly hi: number;
+  /** The bar's paint, or `null` on a change of zero, which the stylesheet's neutral hook paints. */
+  readonly color: string | null;
+  /** The figure printed on the drawing: the signed change, or the total, as `valueFormat` writes a `'label'`. */
+  readonly display: string;
+  /** Whether that figure goes under the bar — a change down, a total below zero — rather than over it. */
+  readonly below: boolean;
+  /** The change in full with its sign, `''` on a total. */
+  readonly changeText: string;
+  /** The running total after the step, in full. */
+  readonly totalText: string;
+  /** What the step announces. */
+  readonly name: string;
+  /** The level of the connector to the next step, as a percentage of the drawing's height, or `null` for none. */
+  readonly connector: number | null;
+}
+/**
+ * Waterfall chart: how a figure gets from one value to another, one change at a time — an
+ * opening balance, the revenue and costs that move it, the balance it closes on. HTML
+ * marks laid out by the stylesheet, no dependency.
+ *
+ * @example
+ * ```html
+ * <wr-waterfall-chart
+ *   ariaLabel="Profit bridge, Q3"
+ *   [steps]="[
+ *     { label: 'Opening', value: 4200, total: true },
+ *     { label: 'Sales', value: 1800 },
+ *     { label: 'Refunds', value: -350 },
+ *     { label: 'Payroll', value: -900 },
+ *     { label: 'Closing', value: 4750, total: true }
+ *   ]"
+ * />
+ * ```
+ *
+ * **The arithmetic is the chart's.** A change step floats between the running total
+ * before it and after it; a total step is a full bar from zero to the running total. A
+ * total's own `value` is checked rather than drawn, so the bars cannot disagree with each
+ * other: the closing bar ends exactly where the last change does, and in dev mode a
+ * `value` that says otherwise warns — the steps above it do not add up to the figure the
+ * host expected. The one total that is not checked is one before every change, where
+ * nothing has run yet: its value is where the running total starts. A change that is not
+ * a finite number counts as zero.
+ *
+ * **Colour is not the only channel.** An increase is `increaseColor`, a decrease
+ * `decreaseColor` and a total `totalColor` — success, danger and primary unless told
+ * otherwise — and each is also told apart without hue: a change runs UP or DOWN from the
+ * thin connector that carries the previous running total to it, and its figure is printed
+ * on the side it runs to, with its sign (`+1,800`, `−350`); a total stands on the zero
+ * line, its figure has no `+` and its label is set in a heavier weight. A change of zero
+ * — or of a value that is not a finite number — is neither: a hairline at the running
+ * total in the neutral `--wr-waterfall-chart-flat-color`, printed `0` with no sign, and
+ * classed `--flat` rather than as an increase.
+ *
+ * Those cues are the figures and the connectors, so turning BOTH `showValues` and
+ * `showConnectors` off leaves colour alone to tell a change up from a change down on
+ * screen: a +100 and a following −100 float over the same span. Each step's name and the
+ * data table still carry the change; keep one of the two on wherever the chart has to
+ * read without hue. On a narrow chart a figure too wide for its column is left out (see
+ * `showValues`), and there the connectors are the cue that stays.
+ *
+ * Every figure below zero is written with `−` (U+2212 MINUS SIGN) in front of its
+ * magnitude — a change, a running total, a total and a tick alike — so a name reads
+ * "Eq: −900, running total −600" with one sign, not Intl's hyphen beside the chart's minus.
+ *
+ * **What a screen reader gets.** The chart is a named `role="group"` of one `role="img"`
+ * per step, as the bar chart's columns are, each named with its change and the running
+ * total after it — "Refunds: −350, running total 5,650" — or, for a total, "Closing:
+ * total 4,750". `dataTable` adds the same figures as a table to walk cell by cell. The
+ * tooltip is pointer only, and no part of the chart is a tab stop.
+ *
+ * The value axis always includes zero, so a total is a bar from the zero line and a
+ * running total that goes negative hangs below it. Under RTL the steps run from the
+ * right, with the value axis at the inline start, as every part of the layout is logical.
+ * The gap between two bars is `--wr-waterfall-chart-gap`, held to a quarter of one step's
+ * share of the drawing, so a chart of many steps narrows its gaps with its bars rather
+ * than running out of room.
+ *
+ * @see https://ngwr.dev/charts/waterfall-chart
+ */
+export declare class WrWaterfallChart {
+  /**
+   * The steps, in order. A step without `total` is a change to the running total; a step
+   * with it is a bar from zero showing the running total. See {@link WrWaterfallStep} for
+   * what a total's `value` does.
+   */
+  readonly steps: import("@angular/core").InputSignal<readonly WrWaterfallStep[]>;
+  /**
+   * Accessible name of the chart, and the data table's caption. Each step names itself, so
+   * say what the chart shows. Falls back to `waterfallChart.label` ("Waterfall chart").
+   */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+  protected readonly resolvedAriaLabel: import("@angular/core").Signal<string>;
+  /** The colour of a change up. Any CSS colour, `var(--wr-…)` included. @default 'var(--wr-color-success)' */
+  readonly increaseColor: import("@angular/core").InputSignal<string>;
+  /** The colour of a change down. Any CSS colour. @default 'var(--wr-color-danger)' */
+  readonly decreaseColor: import("@angular/core").InputSignal<string>;
+  /** The colour of a total. Any CSS colour. @default 'var(--wr-color-primary)' */
+  readonly totalColor: import("@angular/core").InputSignal<string>;
+  /** The plot's height in px, at least 80. @default 240 */
+  readonly height: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Show the gridlines and the value axis' tick labels. @default true */
+  readonly showGrid: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * Print each step's figure past the end of its bar: a change with its sign, over the bar
+   * when it runs up and under it when it runs down, and a total with no `+`. Compact from
+   * a thousand up (`+1.2K`) by default; with `valueFormat`, whatever it writes for
+   * `'label'`, so a formatter can go compact here and stay exact everywhere else.
+   *
+   * A figure is printed whole or not at all: one wider than its column and a quarter of
+   * the gap on either side — which keeps it clear of its neighbours' — is left out rather
+   * than cut, since `+$1,…` is not a figure and `−$9…` reads as −$9. The tooltip, the
+   * names and the data table carry every figure in full.
+   *
+   * The sign is one of the two cues besides colour that tell a change up from a change
+   * down; the connectors are the other. Off together with `showConnectors`, colour is the
+   * only one left on screen. @default true
+   */
+  readonly showValues: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * Draw the thin line that carries each running total across the gap to the next bar,
+   * which starts from it. None leads into a total that starts a running total of its own
+   * — one before every change, at a value the line would not meet.
+   *
+   * A change up leaves the line at its bottom and a change down at its top, so the line
+   * is one of the two cues besides colour that tell them apart; the signed figures are
+   * the other. Off together with `showValues`, colour is the only one left on screen.
+   * @default true
+   */
+  readonly showConnectors: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * Show a tooltip with the step's change and the running total after it on hover. Pointer
+   * only — each step's accessible name already carries both. @default true
+   */
+  readonly tooltip: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * Render the chart's figures as a table only assistive technology reaches, beside the
+   * drawing: a row per step, headed by its label, with its change (empty on a total) and
+   * the running total after it, each written as the tooltip writes it.
+   *
+   * Each step's accessible name already carries both figures; the table is for a reader
+   * who wants to move through them cell by cell, with the column headings read out. It is
+   * clipped to nothing: it takes no room, draws nothing and holds no tab stop.
+   * @default false
+   */
+  readonly dataTable: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * Writes every number the chart shows: the figures on the drawing, the axis ticks, the
+   * tooltip, the accessible names and the data table. Every figure is handed over as its
+   * MAGNITUDE, never below zero, and the chart writes the sign in front: `+` or `−`
+   * (U+2212 MINUS SIGN) on a change, `−` on a running total, a total or a tick below zero.
+   * So one formatter writes every figure, and one minus sign appears throughout.
+   *
+   * It is told where the figure goes (see {@link WrWaterfallValueContext}): `'label'` past
+   * a bar, where a compact form fits a narrow column; `'tick'` on the value axis; `'value'`
+   * in the tooltip, the names and the data table, which a reader goes to for the exact
+   * figure. A `(value) => string` written for another chart fits too, and writes all three
+   * alike. `null` uses `Intl.NumberFormat` in `LOCALE_ID`: compact past the bars from a
+   * thousand up, compact ticks (`1.2K`, `3.4M`) unless the full numbers are shorter, and
+   * the exact figure everywhere else.
+   */
+  readonly valueFormat: import("@angular/core").InputSignal<((value: number, context: WrWaterfallValueContext) => string) | null>;
+  /** The figures, the compact labels and the ticks, in `LOCALE_ID` unless `valueFormat` is given. */
+  private readonly numbers;
+  private readonly stepName;
+  private readonly changeName;
+  private readonly runningTotalName;
+  private readonly changeStepName;
+  private readonly totalStepName;
+  private readonly barEls;
+  constructor();
+  /**
+   * Every step with its arithmetic done. The running total starts at zero, and a total
+   * before every change sets it to its own value; a change moves it; a later total shows
+   * it and only checks its own value against it.
+   */
+  private readonly resolved;
+  /**
+   * The value axis, from `chartAxis` over every bar's two ends with zero always inside —
+   * a total stands on it — snapped outward to a readable step and lifted a step where the
+   * highest bar would end on the frame. With no step, the empty 0 to 1 frame.
+   */
+  protected readonly axis: import("@angular/core").Signal<import("ngwr/charts/core").WrChartAxis>;
+  /** Where zero is, as a percentage of the drawing's height from its bottom: the line every total stands on. */
+  protected readonly zero: import("@angular/core").Signal<number>;
+  /**
+   * The ticks, top to bottom: each value's label, and its gridline's distance from the
+   * drawing's top (for the label) and from its bottom (for the line).
+   */
+  protected readonly ticks: import("@angular/core").Signal<{
+    label: string;
+    bottom: number;
+    top: number;
+  }[]>;
+  /**
+   * The steps as drawn and announced: every figure written once, here, so the drawing, the
+   * names, the tooltip and the table cannot disagree.
+   */
+  protected readonly drawn: import("@angular/core").Signal<readonly DrawnStep[]>;
+  /**
+   * The figures for `dataTable`: the chart's name as the caption, a row per step headed by
+   * its label, and its change and the running total after it as the columns. A total has
+   * no change, so that cell is empty.
+   */
+  protected readonly tableData: import("@angular/core").Signal<WrChartTableData>;
+  /**
+   * One tooltip for the whole chart, for the step under the pointer: its swatch and label
+   * as the heading, then its change — a total has none — and the running total after it.
+   * It points at the top edge of the BAR rather than at the column, which is the full
+   * height of the plot; a change of zero keeps its hairline to point at, and no swatch,
+   * since its neutral paint says nothing. Each figure is isolated (see `isolate`), so a
+   * sign stays in front of its digits in an RTL document.
+   */
+  protected readonly tip: import("ngwr/popover").WrChartTooltip;
+  /** Where `value` sits on the axis, as a percentage of the drawing's height from its bottom. */
+  private level;
+  /** A change with its sign in front of its magnitude: `+` up, `−` down, and none for a change of zero. */
+  private signed;
+  /** A figure with `−` in front of its magnitude below zero and no sign otherwise: a running total, a total. */
+  private written;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WrWaterfallChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WrWaterfallChart, "wr-waterfall-chart", never, {
+    "steps": {
+      "alias": "steps";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "increaseColor": {
+      "alias": "increaseColor";
+      "required": false;
+      "isSignal": true;
+    };
+    "decreaseColor": {
+      "alias": "decreaseColor";
+      "required": false;
+      "isSignal": true;
+    };
+    "totalColor": {
+      "alias": "totalColor";
+      "required": false;
+      "isSignal": true;
+    };
+    "height": {
+      "alias": "height";
+      "required": false;
+      "isSignal": true;
+    };
+    "showGrid": {
+      "alias": "showGrid";
+      "required": false;
+      "isSignal": true;
+    };
+    "showValues": {
+      "alias": "showValues";
+      "required": false;
+      "isSignal": true;
+    };
+    "showConnectors": {
+      "alias": "showConnectors";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltip": {
+      "alias": "tooltip";
+      "required": false;
+      "isSignal": true;
+    };
+    "dataTable": {
+      "alias": "dataTable";
+      "required": false;
+      "isSignal": true;
+    };
+    "valueFormat": {
+      "alias": "valueFormat";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { WrWaterfallStep, WrWaterfallValueContext };

package/types/ngwr-color-picker.d.ts

@@ -98,18 +98,6 @@ export declare function parseHex(input: string): WrRgb | null;
  * ```
  */
 export declare function toHex(rgb: WrRgb, withAlpha?: boolean): string;
-/**
- * Read a colour written in any format `<wr-color-picker>` can emit — hex,
- * `rgb()` / `rgba()`, `hsl()` / `hsla()` — or `null` when it is none of them.
- *
- * The picker emits in whichever format it was given, so a `[(value)]` binding
- * hands its own output straight back on the next external write. Accepting only
- * hex there (which is what it used to do) turned every non-hex value into black.
- *
- * `null` rather than a throw or a black fallback: the caller is often a text
- * field mid-typing, where "not valid yet" is the normal state.
- */
-declare function parseColor(input: string): WrRgb | null;
 /**
  * @license
  *
@@ -129,15 +117,6 @@ declare function parseColor(input: string): WrRgb | null;
  * `[(value)]` binding round-trips its own output.
  */
 type WrColorFormat = 'hex' | 'rgba' | 'hsla';
-/**
- * Render a colour in the format a `<wr-color-picker>` was asked for.
- *
- * `withAlpha` follows the picker's own `alpha` input, so each format has an
- * opaque and a translucent spelling — `#3969e2` / `#3969e2ff`,
- * `rgb(…)` / `rgba(…)`, `hsl(…)` / `hsla(…)` — and a picker with the alpha
- * slider turned off never emits a channel the caller cannot see or edit.
- */
-declare function formatColor(rgb: WrRgb, format: WrColorFormat, withAlpha: boolean): string;
 type Tab = 'hex' | 'rgb' | 'hsl';
 type Edges = 'sv' | 'hue' | 'alpha';
 /**

package/types/ngwr-dropdown.d.ts

@@ -33,58 +33,6 @@ export declare class WrDropdownMenu {
  * Where the dropdown menu opens, relative to the trigger.
  */
 type WrDropdownPosition = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'right';
-/**
- * The CDK geometry for each placement — one position, no fallbacks.
- *
- * No `offsetX` / `offsetY`, unlike `wr-popover`'s table: the gap between the
- * trigger and the menu is PADDING on the pane (`.wr-dropdown-overlay--<placement>`),
- * so the pointer crossing it is still over the overlay and a `trigger="hover"`
- * menu does not close on the way in. It also means nothing here is
- * direction-dependent, which is why the directive needs no `wrMirrorOffsets`.
- *
- * @internal
- */
-declare const WR_DROPDOWN_POSITIONS: Record<WrDropdownPosition, ConnectedPosition>;
-/**
- * What each placement is allowed to flip to when it does not fit, best first.
- * The requested placement always leads, so a menu that fits never moves.
- *
- * The same chains as `wr-popover`'s, restricted to the eight placements a
- * dropdown offers — which needs no editing, since every link in those eight
- * chains is itself one of the eight. Alignment is kept down the chain, a
- * block-axis placement only flips to its opposite, and a side placement may
- * also fall below or above, because on a phone neither side of a mid-page
- * trigger has the room. Once it has, the directive drops the side links for as
- * long as the menu stays open — the gap changes axis with the placement, so a
- * pane is only measured correctly against links on one axis at a time.
- *
- * Each list used to hold ONE position. With `withPush(true)` and nothing to
- * fall back to, a menu that did not fit below its trigger was pushed back up
- * over it instead — measured in Chromium at 1280×700 with a `bottom-start`
- * trigger 40px above the fold: the menu's top landed at 626, inside the
- * trigger's 630–660 box, covering the control that opened it.
- *
- * @internal
- */
-declare const WR_DROPDOWN_FALLBACKS: Record<WrDropdownPosition, readonly WrDropdownPosition[]>;
-/**
- * The list `withPositions()` wants — the chain in `WR_DROPDOWN_FALLBACKS` order,
- * as fresh objects, so the directive can tell which link the CDK landed on by
- * the IDENTITY of the position it reports back.
- *
- * Deliberately untagged, and this is where the dropdown parts from `wr-popover`,
- * which puts each placement's class in the position's own `panelClass`. The CDK
- * takes those classes off the pane BEFORE it measures it for fit, and here the
- * class carries the gap, as padding — so a tagged list is measured without its
- * gap. A menu with less room than that gap was judged to fit and the flexible
- * bounding box squeezed it instead: measured in Chromium at 1280×700 with 2px to
- * spare below the trigger, the menu's box shrank from 74px to 68px and its last
- * row ran through the bottom border. The directive writes the class itself, which
- * the CDK leaves alone, so the pane is measured with the gap it will render with.
- *
- * @internal
- */
-declare function wrDropdownPositions(position: WrDropdownPosition): ConnectedPosition[];
 /**
  * @license
  *

package/types/ngwr-editor.d.ts

@@ -1,8 +1,8 @@
 import * as i0 from "@angular/core";
 import { Signal } from "@angular/core";
 import { FormValueControl } from "@angular/forms/signals";
-import { Mark, Schema } from "prosemirror-model";
-import { Command, EditorState, Plugin } from "prosemirror-state";
+import "prosemirror-model";
+import "prosemirror-state";
 import { WrFormFieldContext } from "ngwr/form";
 /**
  * @license
@@ -73,88 +73,6 @@ type WrEditorTool = 'bold' | 'italic' | 'underline' | 'strike' | 'code' | 'parag
 type WrEditorValue = WrEditorJson | null;
 /** Every tool but the separator. */
 type WrEditorCommandTool = Exclude<WrEditorTool, '|'>;
-/** A shortcut, always on the platform's primary modifier (⌘ on Apple, Ctrl elsewhere). */
-interface WrEditorShortcut {
-  readonly key: string;
-  readonly shift?: boolean;
-  readonly alt?: boolean;
-}
-/**
- * The keyboard half of each tool — the keymap below binds exactly these, so a
- * hint can never name a shortcut that does nothing.
- *
- * Where a convention exists it is followed: Google Docs for the block types
- * (Mod-Alt-0…3, Mod-Shift-7/8), and Tiptap / Notion for the three it does not
- * cover (Mod-Shift-S strikethrough, Mod-E inline code, Mod-Shift-B quote,
- * Mod-Alt-C code block). The horizontal rule has none. Tab is deliberately not
- * bound — indenting with it would be a keyboard trap (WCAG 2.1.2), so list items
- * move with Mod-] and Mod-[ — and neither is Escape, which `<wr-dialog>` needs.
- *
- * Where a layout types `[` and `]` with AltGr or Option (German, French, the
- * Nordic and Polish layouts), the bracket chords are also read with that Alt
- * held — see {@link bracketKeys} — since nothing else indents a list item. The
- * Mod-Alt chords are NOT widened the same way: on Windows, Ctrl+Alt is AltGr, and
- * on those layouts AltGr+0 types `}` and AltGr+C types `ć`. Taking the chord by
- * physical key would make those characters impossible to type in the editor, so
- * there the key types its character and the toolbar sets the block type.
- */
-declare const SHORTCUTS: Readonly<Partial<Record<WrEditorCommandTool, WrEditorShortcut>>>;
-/**
- * The tools a click toggles — the ones that carry `aria-pressed`. Not `link`,
- * which opens a panel: a popup button that also claimed to be pressed would say
- * two contradictory things.
- */
-declare const TOGGLES: ReadonlySet<WrEditorCommandTool>;
-/** Whether a tool's state is "on" at the selection — what `aria-pressed` reports. */
-declare function toolActive(tool: WrEditorCommandTool, state: EditorState): boolean;
-/** What a tool does. */
-declare function toolCommand(tool: WrEditorCommandTool, schema: Schema): Command;
-/** Mod-Enter in a table: out of it, onto a new line below — what `exitCode` does for a code block. */
-declare const exitTable: Command;
-/**
- * The arrow key off the edge of a table nothing can be reached past: ArrowDown on
- * the last line of its last row with no text anywhere after it, ArrowUp on the
- * first line of its first row with none before. Anywhere else the key moves the
- * caret as it always does. Up and down only — left and right swap ends under
- * `dir="rtl"`, and the vertical pair means the same thing in both directions.
- */
-declare function leaveTable(side: 'before' | 'after'): Command;
-/**
- * The run of text carrying one link around the selection — the whole link, when
- * the caret merely sits in it — or `null` when there is none.
- */
-declare function linkRange(state: EditorState): {
-  readonly from: number;
-  readonly to: number;
-  readonly mark: Mark;
-} | null;
-/**
- * Link the selection to `href` — replacing the link it sits in when the caret
- * is inside one, and inserting the address as its own text when nothing is
- * selected at all. `href` has already passed the URL policy.
- */
-declare function setLink(href: string): Command;
-/** Remove the link the selection is in or covers. */
-declare const removeLink: Command;
-/**
- * The editor's plugin stack, in precedence order: its own keys, history keys,
- * ProseMirror's base keymap, then history and the markdown-style input rules.
- *
- * `canEdit` is asked for every document-changing transaction, because
- * `view.dispatch()` does not consult `editable` — a toolbar click or a plugin
- * would otherwise change a read-only document. Outside writes never pass here:
- * they replace the state wholesale.
- *
- * The input rules are the block shortcuts only. The typographic ones (smart
- * quotes, the em dash, the ellipsis) are left out on purpose: in a form control
- * they silently rewrite what someone typed into a name, a code or a reference.
- */
-declare function editorPlugins(schema: Schema, options: {
-  readonly apple: boolean;
-  readonly canEdit: () => boolean;
-}): Plugin[];
-/** A shortcut in ProseMirror's key-name syntax. */
-declare function comboOf(shortcut: WrEditorShortcut): string;
 /**
  * The field the link panel's URL input belongs to — provided as `WR_FORM_FIELD`
  * for the editor's whole subtree.

package/types/ngwr-i18n.d.ts

@@ -51,20 +51,7 @@ interface WrI18nConfigResolved {
  * `LOCALE_ID` in an injection context. @internal
  */
 export declare const DEFAULT_WR_I18N_CONFIG: Omit<WrI18nConfigResolved, 'defaultLocale' | 'availableLocales'>;
-/**
- * Resolve the locale half of the config. Callable only from an injection
- * context, because the seed is `LOCALE_ID`. @internal
- */
-declare function resolveWrI18nLocales(config: WrI18nConfig): Pick<WrI18nConfigResolved, 'defaultLocale' | 'availableLocales'>;
 export declare const WR_I18N_CONFIG: InjectionToken<WrI18nConfigResolved>;
-/**
- * `{{name}}` interpolation. Missing params resolve to `''`. Exported so
- * helpers in `util.ts` can interpolate the fallback template when no
- * `WrI18n` provider is wired up.
- *
- * @internal
- */
-declare function wrInterpolate(template: string, params: WrI18nParams | undefined): string;
 /**
  * Reactive i18n service. Holds:
  *
@@ -446,8 +433,6 @@ export declare function useI18nText(binding: Signal<string | null | undefined>,
  * button beside it "Open calendar", off the same key.
  */
 export declare function readI18nText(key: string, fallback: string): Signal<string>;
-/** Tiny shim — useful when the caller doesn't have an `input` to forward. */
-declare function nullSignal(): Signal<null>;
 /**
  * Build a per-call formatter for parametrized labels (e.g. ARIA labels
  * that interpolate a per-row value: `"Remove {{label}}"`). Returns a

package/types/ngwr-mention.d.ts

@@ -212,19 +212,6 @@ export declare class WrMention<T extends WrMentionItem = WrMentionItem> {
     "wrMentionSelected": "wrMentionSelected";
   }, never, never, true, never>;
 }
-/**
- * The id of the option at `index`, given the listbox's own id.
- *
- * Lives here, and is used from both sides, because this format is a contract
- * between two files: the panel stamps it onto each `<li>`, and the directive
- * names one of them in `aria-activedescendant`. Written out twice, the two would
- * drift and the reference would silently dangle — and a dangling
- * `aria-activedescendant` is not an error the browser reports, it just stops
- * announcing options.
- *
- * @internal
- */
-declare function wrMentionOptionId(listboxId: string, index: number): string;
 /**
  * Overlay panel rendered by {@link WrMention}. Not intended for
  * direct use — the directive instantiates it via a ComponentPortal.

package/types/ngwr-popconfirm.d.ts

@@ -2,39 +2,6 @@ import * as i0 from "@angular/core";
 import { WrClassInput } from "ngwr/utils";
 import { ConnectedPosition } from "@angular/cdk/overlay";
 type WrPopconfirmPosition = 'top' | 'bottom' | 'left' | 'right';
-/**
- * The CDK geometry for each placement — one position each. The 8px offset is
- * the gap between the trigger and the panel, the same one `wr-popover` keeps.
- *
- * @internal
- */
-declare const WR_POPCONFIRM_POSITIONS: Record<WrPopconfirmPosition, ConnectedPosition>;
-/**
- * What each placement may flip to when it does not fit, best first — the chains
- * `wr-popover` uses for the same four sides, for the same reasons. The requested
- * placement leads, so a panel that fits never moves; a side placement may also
- * fall below or above, because on a phone neither side of a mid-page trigger has
- * the room.
- *
- * Each list used to hold ONE position, with `withPush(true)` and nothing to fall
- * back to. A `top` panel opened 60px under the top of a 1440×900 viewport was
- * pushed back down over its own trigger, by 20px, and a `right` panel on a 390px
- * phone ran off the edge with its Confirm button clipped — the panel covering the
- * control it was asking about, while the docs said it flips.
- *
- * @internal
- */
-declare const WR_POPCONFIRM_FALLBACKS: Record<WrPopconfirmPosition, readonly WrPopconfirmPosition[]>;
-/**
- * The list `withPositions()` wants, every link tagged with the pane class of the
- * side it puts the panel on, so the arrow (`.wr-popconfirm-overlay--<side>`)
- * follows a flip. The CDK applies a position's own `panelClass` when it lands on
- * it and clears it on the next one; the gap is an offset rather than padding, so
- * taking the class off before it measures changes nothing.
- *
- * @internal
- */
-declare function wrPopconfirmPositions(position: WrPopconfirmPosition): ConnectedPosition[];
 export declare class WrPopconfirm {
   /** Confirmation message. */
   readonly message: import("@angular/core").InputSignal<string>;