@yamcs/opi 1.3.14 → 1.4.0

package/dist/types/Bevel.d.ts

@@ -0,0 +1,16 @@
+import { Color } from "./Color";
+import { Graphics } from "./Graphics";
+import { Bounds } from "./positioning";
+/**
+ * Draws a classic Win95-style 3D bevel border around a rect, as used by
+ * SWT/draw2d buttons and scrollbars. Ported from Scrollbar.ts, which
+ * originally implemented this for its own up/down/thumb buttons.
+ */
+export declare function drawBevelBorder(g: Graphics, bounds: Bounds, scale: number, c1: Color, c2: Color, c3: Color, c4: Color): void;
+export declare function drawRaisedBevelBorder(g: Graphics, bounds: Bounds, scale: number): void;
+export declare function drawPressedBevelBorder(g: Graphics, bounds: Bounds, scale: number): void;
+/**
+ * Draws a small filled triangle pointing up, down, left or right, centered
+ * within bounds, as used by scrollbar arrow buttons.
+ */
+export declare function drawArrowGlyph(g: Graphics, bounds: Bounds, scale: number, direction: "up" | "down" | "left" | "right", color?: Color): void;

package/dist/types/DecimalFormat.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Computes a default DecimalFormat pattern for a value range, mirroring
+ * Nebula's AbstractScale.createDefaultDecimalFormat (used by CSS/Yamcs
+ * Studio's round-scale widgets whenever no explicit value_label_format is
+ * set) - so opi.js shows the same decimal precision Yamcs Studio would
+ * derive from the same min/max, rather than an arbitrary fixed precision.
+ */
+export declare function createDefaultDecimalFormat(min: number, max: number): string;
 export declare class DecimalFormat {
     private prefix;
     private suffix;

package/dist/types/Display.d.ts

@@ -8,7 +8,7 @@ import { PathResolver } from "./PathResolver";
 import { ScriptLoader } from "./ScriptLoader";
 import { Widget } from "./Widget";
 import { OPIEvent, OPIEventMap } from "./events";
-import { Bounds } from "./positioning";
+import { Bounds, Point } from "./positioning";
 import { PVEngine } from "./pv/PVEngine";
 import { PVProvider } from "./pv/PVProvider";
 import { Sample } from "./pv/Sample";
@@ -19,10 +19,14 @@ import { CheckBox } from "./widgets/controls/CheckBox";
 import { ChoiceButton } from "./widgets/controls/ChoiceButton";
 import { Combo } from "./widgets/controls/Combo";
 import { ImageBooleanButton } from "./widgets/controls/ImageBooleanButton";
+import { Knob } from "./widgets/controls/Knob";
 import { MenuButton } from "./widgets/controls/MenuButton";
 import { RadioBox } from "./widgets/controls/RadioBox";
+import { ScaledSlider } from "./widgets/controls/ScaledSlider";
 import { Scrollbar } from "./widgets/controls/Scrollbar";
+import { Spinner } from "./widgets/controls/Spinner";
 import { TextInput } from "./widgets/controls/TextInput";
+import { ThumbWheel } from "./widgets/controls/ThumbWheel";
 import { Arc } from "./widgets/graphics/Arc";
 import { Ellipse } from "./widgets/graphics/Ellipse";
 import { ImageWidget } from "./widgets/graphics/ImageWidget";
@@ -43,12 +47,25 @@ import { TextUpdate } from "./widgets/monitors/TextUpdate";
 import { Thermometer } from "./widgets/monitors/Thermometer";
 import { XYGraph } from "./widgets/monitors/xygraph/XYGraph";
 import { AbstractContainerWidget } from "./widgets/others/AbstractContainerWidget";
+import { ArrayWidget } from "./widgets/others/ArrayWidget";
 import { DisplayWidget } from "./widgets/others/DisplayWidget";
+import { GridLayout } from "./widgets/others/GridLayout";
 import { GroupingContainer } from "./widgets/others/GroupingContainer";
 import { LinkingContainer } from "./widgets/others/LinkingContainer";
+import { SashContainer } from "./widgets/others/SashContainer";
 import { TabbedContainer } from "./widgets/others/TabbedContainer";
 import { Table } from "./widgets/others/Table";
 import { WebBrowser } from "./widgets/others/WebBrowser";
+/**
+ * Overrides a display's own `auto_scale_widgets` XML property:
+ * `ENABLED`/`DISABLED` force auto-scale on/off regardless of what's
+ * authored, `DEFAULT` respects the authored value.
+ */
+export declare enum AutoScaleOverride {
+    ENABLED = "ENABLED",
+    DISABLED = "DISABLED",
+    DEFAULT = "DEFAULT"
+}
 export declare class Display {
     private readonly targetElement;
     rootPanel: HTMLDivElement;
@@ -69,12 +86,20 @@ export declare class Display {
     private _showRuler;
     private _selection;
     private _scale;
+    private _pixelRatio;
+    private pixelRatioOverridden;
     private _transparent;
     private _disconnectedColor;
     private _invalidColor;
     private _majorColor;
     private _minorColor;
     private refreshCycle;
+    private originDesignSize?;
+    private wasAutoScaleActive;
+    private _autoScaleOverride;
+    private resizeObserver;
+    private eventHandler;
+    private stepTimer?;
     /**
      * Prefix for images sourced during draw.
      * (does not include workspace images)
@@ -112,7 +137,15 @@ export declare class Display {
      */
     requestRepaint(): void;
     setTooltip(tooltip: string | undefined): void;
-    createWidget(kind: string, parent: AbstractContainerWidget): Table | XYGraph | ActionButton | Arc | BooleanButton | BooleanSwitch | ByteMonitor | CheckBox | ChoiceButton | Combo | Ellipse | Gauge | GroupingContainer | ImageWidget | ImageBooleanButton | ImageBooleanIndicator | IntensityGraph | Label | LED | LinkingContainer | MenuButton | Meter | Polygon | Polyline | ProgressBar | RadioBox | Rectangle | RoundedRectangle | Scrollbar | TabbedContainer | Tank | TextInput | TextUpdate | Thermometer | WebBrowser | undefined;
+    createWidget(kind: string, parent: AbstractContainerWidget): ActionButton | Arc | ArrayWidget | BooleanButton | BooleanSwitch | ByteMonitor | CheckBox | ChoiceButton | Combo | Ellipse | Gauge | GridLayout | GroupingContainer | ImageBooleanButton | ImageBooleanIndicator | ImageWidget | IntensityGraph | Knob | LED | Label | LinkingContainer | MenuButton | Meter | Polygon | Polyline | ProgressBar | RadioBox | Rectangle | RoundedRectangle | SashContainer | ScaledSlider | Scrollbar | Spinner | TabbedContainer | Table | Tank | TextInput | TextUpdate | Thermometer | ThumbWheel | WebBrowser | XYGraph | undefined;
+    /**
+     * Releases everything this Display holds outside of its own instance:
+     * the repaint loop, the resize observer, canvas/document event
+     * listeners, and rootPanel itself (removed from targetElement, which is
+     * restored to how it was before construction). The instance is unusable
+     * afterwards - this is not the same as reset() between two setSource()
+     * calls on a Display that keeps running.
+     */
     destroy(): void;
     resolvePath(path: string, widget?: Widget): string;
     setSource(href: string, args?: {
@@ -128,6 +161,16 @@ export declare class Display {
      * Bounds of this widget relative to the root
      * of all of its parents.
      */
+    /**
+     * Sums the x/y offset contributed by every ancestor of a widget, up to
+     * the display root. A plain sum of ancestor.x/y is not enough:
+     * TabbedContainer positions its active tab's content at
+     * `this.y + labelHeight` (or an equivalent width offset for vertical
+     * tabs) without that ever being reflected in the tab-content widget's
+     * own x/y, so ancestors of that kind need their extra offset added in
+     * explicitly.
+     */
+    measureAbsoluteOffset(widget: Widget): Point;
     measureAbsoluteArea(widget: Widget): Bounds;
     addEventListener<K extends keyof OPIEventMap>(type: K, listener: (ev: OPIEventMap[K]) => void): void;
     removeEventListener<K extends keyof OPIEventMap>(type: K, listener: (ev: OPIEventMap[K]) => void): void;
@@ -144,6 +187,45 @@ export declare class Display {
     set editMode(editMode: boolean);
     get scale(): number;
     set scale(scale: number);
+    /**
+     * Overrides the loaded display's own `auto_scale_widgets` XML property.
+     * `DEFAULT` (the default) respects the authored value; `ENABLED`/
+     * `DISABLED` force auto-scale on/off regardless of what's authored.
+     * Intended for demo/dev tooling that wants to exercise auto-scale on
+     * displays that don't author it themselves - not part of the OPI file
+     * format.
+     */
+    get autoScaleOverride(): AutoScaleOverride;
+    set autoScaleOverride(value: AutoScaleOverride);
+    private isAutoScaleActive;
+    /**
+     * The size to fill when auto-scale is active, or undefined if there's
+     * nothing sensible to fill (targetElement has zero size of its own).
+     */
+    private measureContainerSize;
+    /**
+     * Applies display-wide widget scaling to fill containerSize, relative to
+     * the design-time size captured at load. Mirrors Java's DisplayEditpart
+     * resize listener / DisplayModel#scale().
+     */
+    private applyAutoScale;
+    /** Restores the design-time layout if auto-scale was previously applied. */
+    private revertAutoScale;
+    /**
+     * Backing store pixels per CSS pixel. Defaults to the screen's
+     * devicePixelRatio, which renders crisply on HiDPI screens, and follows it
+     * when the window moves to another screen.
+     *
+     * Set it to override, which also stops it tracking the screen: 1 renders at
+     * CSS resolution, and `Math.min(devicePixelRatio, 2)` caps the memory a
+     * large display costs (the canvas, and every offscreen container buffer,
+     * scale with the square of this).
+     *
+     * This does not change the size of anything: all coordinates, fonts and
+     * mouse handling stay in CSS pixels.
+     */
+    get pixelRatio(): number;
+    set pixelRatio(pixelRatio: number);
     get transparent(): boolean;
     set transparent(transparent: boolean);
     get utc(): boolean;

package/dist/types/EventHandler.d.ts

@@ -20,13 +20,23 @@ export declare class EventHandler {
     private documentMouseMoveListener;
     private documentMouseUpListener;
     private prevEnteredRegion?;
+    private pendingMouseMoveEvent?;
+    private mouseMoveRafHandle?;
+    private abortController;
     constructor(display: Display, canvas: HTMLCanvasElement, hitCanvas: HitCanvas);
+    /**
+     * Removes every listener this instance registered, including the
+     * document-level ones left behind by an in-progress grab.
+     */
+    destroy(): void;
     private toPoint;
     private onCanvasClick;
+    private onCanvasDblClick;
     private onCanvasMouseDown;
     private onCanvasMouseUp;
     private onCanvasMouseOut;
     private onCanvasMouseMove;
+    private processMouseMove;
     private initiateGrab;
     private onDocumentMouseUp;
     private onDocumentMouseMove;

package/dist/types/Font.d.ts

@@ -1,3 +1,5 @@
+export declare const FONT_SUBSTITUTES: Record<string, string>;
+export declare function markSubstituteLoaded(name: string): void;
 export declare class Font {
     name: string;
     style: number;

package/dist/types/Graphics.d.ts

@@ -111,14 +111,79 @@ interface PathGradientFill {
     opacity?: number;
 }
 type PathFill = PathColorFill | PathGradientFill;
+/**
+ * Splits a destination for drawImage into a whole-device-pixel position, and
+ * the sub-pixel remainder that was taken off it.
+ *
+ * drawImage resamples whenever the destination does not land on a whole
+ * device pixel, blurring everything already rasterized into the source
+ * canvas. Callers blit at the returned position, and fold the remainder into
+ * the source canvas instead (translate it, and grow the canvas to match), so
+ * that content keeps its exact sub-pixel position but gets rasterized there
+ * directly rather than being drawn on a whole pixel and then shifted.
+ *
+ * `dx`/`dy` and the returned values are all CSS pixels, but the snapping is
+ * done in device space: `ctx` carries the HiDPI scale, and may carry a
+ * remainder of its own from an enclosing buffer that did the same thing.
+ *
+ * The context transform is therefore a uniform scale plus a translation.
+ * Never a rotation: widget scaling is baked into coordinates rather than into
+ * the context, and the only ctx.rotate() calls are save()/restore()-scoped
+ * around leaf text.
+ */
+export declare function snapDestination(ctx: CanvasRenderingContext2D, dx: number, dy: number): {
+    x: number;
+    y: number;
+    subPixelX: number;
+    subPixelY: number;
+};
 export declare class Graphics {
     readonly canvas: HTMLCanvasElement;
+    /**
+     * Backing store pixels per CSS pixel (HiDPI). All drawing coordinates
+     * remain in CSS pixels; this Graphics is the only thing that knows about
+     * device pixels, and it applies the ratio as a context transform.
+     *
+     * The hit canvas is deliberately kept at 1x: it is probed with CSS
+     * coordinates straight from the mouse event, and 1 CSS pixel of hit-test
+     * precision is plenty.
+     *
+     * Mutable on the root Graphics (the ratio changes when the window moves
+     * to another monitor); it takes effect on the next resize(). Offscreen
+     * buffers inherit it at creation.
+     */
+    pixelRatio: number;
     readonly ctx: CanvasRenderingContext2D;
     readonly hitCanvas: HitCanvas;
     readonly hitCtx: CanvasRenderingContext2D;
-    constructor(canvas: HTMLCanvasElement, hitCanvas?: HitCanvas);
+    private parentOffset?;
+    constructor(canvas: HTMLCanvasElement, hitCanvas?: HitCanvas, 
+    /**
+     * Backing store pixels per CSS pixel (HiDPI). All drawing coordinates
+     * remain in CSS pixels; this Graphics is the only thing that knows about
+     * device pixels, and it applies the ratio as a context transform.
+     *
+     * The hit canvas is deliberately kept at 1x: it is probed with CSS
+     * coordinates straight from the mouse event, and 1 CSS pixel of hit-test
+     * precision is plenty.
+     *
+     * Mutable on the root Graphics (the ratio changes when the window moves
+     * to another monitor); it takes effect on the next resize(). Offscreen
+     * buffers inherit it at creation.
+     */
+    pixelRatio?: number);
+    /** Width in CSS pixels (the canvas attribute is in device pixels). */
+    get cssWidth(): number;
+    /** Height in CSS pixels (the canvas attribute is in device pixels). */
+    get cssHeight(): number;
     createChild(width: number, height: number): Graphics;
+    /**
+     * Offscreen buffer for content that is later copied to (dx, dy) of this
+     * Graphics, using copyChild(). See snapDestination().
+     */
+    createChildAt(dx: number, dy: number, width: number, height: number): Graphics;
     translate(x: number, y: number): void;
+    copyChild(g: Graphics): void;
     copy(g: Graphics, dx: number, dy: number): void;
     copyFitted(g: Graphics, dx: number, dy: number, dw: number, dh: number): void;
     copyScaled(g: Graphics, dx: number, dy: number, dw: number, dh: number): void;
@@ -126,12 +191,10 @@ export declare class Graphics {
     fillCanvas(color: Color): void;
     clearCanvas(): void;
     /**
-     * Perform a CSS-level rescale of the Canvas.
-     *
-     * This resamples the bitmapped canvas area to fit the area made available
-     * by CSS.
+     * Sizes the canvas to a CSS-pixel area. The backing store is allocated at
+     * pixelRatio, and the base transform re-applied so that all subsequent
+     * drawing remains in CSS pixels.
      */
-    scaleCanvas(width: number, height: number): void;
     resize(width: number, height: number): void;
     fillRect(fill: RectFill): void;
     fillText(fill: TextFill): void;

package/dist/types/HitRegionSpecification.d.ts

@@ -3,6 +3,7 @@ export type TooltipProvider = () => string | undefined;
 export interface HitRegionSpecification {
     id: string;
     click?: (mouseEvent: OpiMouseEvent) => void;
+    dblclick?: (mouseEvent: OpiMouseEvent) => void;
     mouseEnter?: () => void;
     mouseMove?: () => void;
     mouseOut?: () => void;

package/dist/types/Widget.d.ts

@@ -23,6 +23,7 @@ export declare abstract class Widget {
     protected customSize?: Dimension;
     private customHolderWidth?;
     private customHolderHeight?;
+    private originBounds?;
     private holderRegion?;
     properties: PropertySet;
     readonly vars: Map<string, any>;
@@ -96,6 +97,16 @@ export declare abstract class Widget {
     get scripts(): ScriptSet;
     get rules(): RuleSet;
     get scaleOptions(): ScaleOptions;
+    /**
+     * Repositions (always) and, per this widget's ScaleOptions, resizes this
+     * widget in response to a display-level auto-scale resize. Ratios are
+     * relative to the display's design-time (origin) size, not to the widget's
+     * current live size, so repeated resizes don't compound rounding drift.
+     *
+     * Named distinctly from the `scale` getter above (the manual zoom
+     * multiplier) -- unrelated, independent scaling axes.
+     */
+    autoScale(widthRatio: number, heightRatio: number): void;
     get widgetType(): string | undefined;
     get text(): string;
     /**

package/dist/types/XMLNode.d.ts

@@ -74,6 +74,7 @@ export declare class XMLNode {
         [key: string]: string;
     };
     getStringTable(name: string): string[][];
+    getMatrix(name: string): number[][];
     getScripts(name: string): ScriptSet;
     getScaleOptions(name: string): ScaleOptions;
     getAutoScaleWidgets(name: string): AutoScaleWidgets;
@@ -82,5 +83,16 @@ export declare class XMLNode {
     getMacros(name: string): MacroSet;
     getActions(name: string): ActionSet;
     private parseColorNode;
+    /**
+     * Deep-clones this node, optionally rewriting the text content of every
+     * descendant `<pv_name>` and/or `<wuid>` element (including nested
+     * `<widget>` subtrees). Used by the Array widget to turn a single
+     * authored child template into N independent, uniquely-identified and
+     * uniquely-PV-bound clones.
+     */
+    cloneWithOverrides(overrides: {
+        pvName?: string;
+        wuidSuffix?: string;
+    }): XMLNode;
     private findChild;
 }

package/dist/types/actions/Action.d.ts

@@ -7,4 +7,6 @@ export declare abstract class Action {
     parseNode(node: XMLNode): void;
     abstract execute(widget: Widget): void;
     get description(): string;
+    getDescription(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions/ExecuteCommandAction.d.ts

@@ -6,5 +6,5 @@ export declare class ExecuteCommandAction extends Action {
     get command(): string;
     get commandDirectory(): string;
     get waitTime(): number;
-    toString(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions/ExecuteJavaScriptAction.d.ts

@@ -6,5 +6,5 @@ export declare class ExecuteJavaScriptAction extends Action {
     get path(): string;
     get embedded(): boolean;
     get scriptText(): string;
-    toString(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions/OpenDisplayAction.d.ts

@@ -7,5 +7,5 @@ export declare class OpenDisplayAction extends Action {
     get macros(): MacroSet;
     get path(): string;
     get mode(): number;
-    toString(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions/OpenFileAction.d.ts

@@ -4,5 +4,5 @@ export declare class OpenFileAction extends Action {
     constructor();
     execute(widget: Widget): void;
     get path(): string;
-    toString(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions/OpenWebpageAction.d.ts

@@ -4,5 +4,5 @@ export declare class OpenWebpageAction extends Action {
     constructor();
     execute(widget: Widget): void;
     get hyperlink(): string;
-    toString(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions/PlaySoundAction.d.ts

@@ -4,5 +4,5 @@ export declare class PlaySoundAction extends Action {
     constructor();
     execute(widget: Widget): void;
     get path(): string;
-    toString(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions/RunCommandAction.d.ts

@@ -8,5 +8,5 @@ export declare class RunCommandAction extends Action {
         [key: string]: string;
     };
     get confirmMessage(): string;
-    toString(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions/RunProcedureAction.d.ts

@@ -8,5 +8,5 @@ export declare class RunProcedureAction extends Action {
         [key: string]: string;
     };
     get confirmMessage(): string;
-    toString(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions/RunStackAction.d.ts

@@ -5,5 +5,5 @@ export declare class RunStackAction extends Action {
     execute(widget: Widget): void;
     get path(): string;
     get confirmMessage(): string;
-    toString(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions/WritePVAction.d.ts

@@ -7,5 +7,5 @@ export declare class WritePVAction extends Action {
     get value(): string;
     get timeout(): number;
     get confirmMessage(): string;
-    toString(): string;
+    getDefaultDescription(): string;
 }

package/dist/types/actions.d.ts

@@ -4,7 +4,7 @@ export declare class ActionSet {
     hookFirstActionToClick: boolean;
     hookAllActionsToClick: boolean;
     add(action: Action | null): void;
-    isClickable(): boolean | 0;
+    isClickable(): 0 | boolean;
     getAction(index: number): Action | null | undefined;
     toString(): string;
 }

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 export { Color, colorFromCssColor } from "./Color";
 export { ConsoleHandler, DefaultConsoleHandler } from "./ConsoleHandler";
 export { DefaultDialogHandler, DialogHandler } from "./DialogHandler";
-export { Display } from "./Display";
+export { AutoScaleOverride, Display } from "./Display";
 export { Font } from "./Font";
 export { FontResolver } from "./FontResolver";
 export { DefaultImageLoader, ImageLoader } from "./ImageLoader";

package/dist/types/positioning.d.ts

@@ -66,4 +66,18 @@ export declare class PolarPoint {
     toPoint(): Point;
 }
 export declare function scalePoints(points: Point[], scale: number): Point[];
+/**
+ * Rotates a list of points around its own bounding-box center by `angle`
+ * degrees. Mirrors Yamcs Studio's PointsUtil#rotatePoints(PointList, double):
+ * because an axis-aligned bounding box does not itself rotate cleanly, the
+ * result is re-anchored so its bounding-box center matches the original.
+ */
+export declare function rotatePoints(points: Point[], angle: number): Point[];
 export declare function halfPixelPoints(points: Point[]): Point[];
+/**
+ * Ports org.csstudio.swt.widgets.figures.TextFigure#calculateTextLocation's
+ * rotated branch: computes the point (relative to textArea) that the text
+ * should be translated+rotated around so that the rotated text lines up
+ * against textArea per the given alignment.
+ */
+export declare function calculateRotatedTextLocation(textArea: Dimension, textSize: Dimension, degrees: number, horizAlignment: number, vertAlignment: number): Point;

package/dist/types/properties.d.ts

@@ -71,6 +71,8 @@ export declare class ColorMapProperty extends Property<ColorMap> {
 }
 export declare class PointsProperty extends Property<Point[]> {
 }
+export declare class MatrixProperty extends Property<number[][]> {
+}
 export declare class ActionsProperty extends Property<ActionSet> {
 }
 export declare class MacrosProperty extends Property<MacroSet> {

package/dist/types/pv/LocalPV.d.ts

@@ -4,7 +4,7 @@ import { Sample } from "./Sample";
 export type LocalPVType = "VDouble" | "VDoubleArray" | "VString" | "VStringArray";
 export declare class LocalPV extends PV {
     type?: LocalPVType | undefined;
-    readonly initializer?: any | undefined;
-    constructor(name: string, pvEngine: PVEngine, type?: LocalPVType | undefined, initializer?: any | undefined);
+    readonly initializer?: any;
+    constructor(name: string, pvEngine: PVEngine, type?: LocalPVType | undefined, initializer?: any);
     setSample(sample: Sample): void;
 }

package/dist/types/pv/PVEngine.d.ts

@@ -10,6 +10,7 @@ export declare class PVEngine {
     private display;
     private rules;
     private scripts;
+    private valueListeners;
     private pvs;
     private providers;
     readonly scriptLibraries: {
@@ -42,7 +43,24 @@ export declare class PVEngine {
     setValue(time: Date, pvName: string, value: any, severity?: AlarmSeverity, units?: string | undefined): void;
     setExternalValues(samples: Map<string, Sample>): void;
     createScript(widget: Widget, model: Script, scriptText: string, pvs: PV[]): ScriptInstance;
-    createRule(widget: Widget, model: Rule): void;
+    createRule(widget: Widget, model: Rule, pvs: PV[]): void;
+    /**
+     * Registers a PV listener on behalf of a widget, outside of the
+     * rule/script system (e.g. a widget's own intrinsic-value sync, or
+     * ArrayWidget's slot write-back). Tracked by owning widget so that
+     * removeWidget() can tear it down too, the same as it does for rules and
+     * scripts - without this, a widget discarded via LinkingContainer reload
+     * (or a TabbedContainer tab switch) leaves a zombie listener behind that
+     * keeps reacting to future PV updates.
+     */
+    trackListener(widget: Widget, pvName: string, listener: PVListener, mayTriggerNow?: boolean): void;
+    /**
+     * Tears down every rule, script and tracked PV listener belonging to the
+     * given widget or any of its descendants (for containers). Used when a
+     * subtree is discarded at runtime, e.g. when a LinkingContainer reloads
+     * its linked display.
+     */
+    removeWidget(widget: Widget): void;
     addProvider(provider: PVProvider): void;
     addScriptLibrary(name: string, library: any): void;
     addListener(pvName: string, listener: PVListener, mayTriggerNow?: boolean): void;
@@ -54,6 +72,10 @@ declare class ScriptInstance {
     readonly text: string;
     readonly pvs: PV[];
     scriptEngine: ScriptEngine;
+    readonly triggerListeners: {
+        pvName: string;
+        listener: PVListener;
+    }[];
     constructor(widget: Widget, script: Script, text: string, pvs: PV[]);
 }
 export {};

package/dist/types/pv/formulas/parser.d.ts

@@ -1,11 +1,11 @@
-declare const peg$allowedStartRules: string[];
 declare class peg$SyntaxError extends SyntaxError {
-    static buildMessage(expected: any, found: any): string;
-    constructor(message: any, expected: any, found: any, location: any);
     expected: any;
     found: any;
     location: any;
+    constructor(message: any, expected: any, found: any, location: any);
     format(sources: any): string;
+    static buildMessage(expected: any, found: any): string;
 }
 declare function peg$parse(input: any, options: any): any;
+declare const peg$allowedStartRules: string[];
 export { peg$allowedStartRules as StartRules, peg$SyntaxError as SyntaxError, peg$parse as parse };

package/dist/types/scale.d.ts

@@ -1,3 +1,4 @@
+import { Dimension } from "./positioning";
 export declare class AutoScaleWidgets {
     /**
      * If true, ScaleOptions from widgets are applied.
@@ -37,3 +38,24 @@ export declare class ScaleOptions {
     readonly keepWidthHeightRatio: boolean;
     constructor(widthScalable: boolean, heightScalable: boolean, keepWidthHeightRatio: boolean);
 }
+/**
+ * Computes a widget's new size given its original (design-time) size and a
+ * pair of width/height ratios, honouring its ScaleOptions the same way
+ * Java's AbstractWidgetModel#getScaledSize() does: a dimension only changes
+ * if its own *Scalable flag is set, and if keepWidthHeightRatio is set (with
+ * both dimensions scalable), the smaller of the two ratios is applied to
+ * both, deriving one dimension from the other rather than scaling them
+ * independently.
+ */
+export declare function getScaledSize(originSize: Dimension, widthRatio: number, heightRatio: number, scaleOptions: ScaleOptions): Dimension;
+/**
+ * Clamps a pair of auto-scale ratios against ScaleOptions, mirroring
+ * AbstractPolyModel#doScale()'s branch structure in the Java reference: if
+ * both dimensions are scalable and keepWidthHeightRatio is set, both ratios
+ * collapse to the smaller of the two; otherwise a non-scalable dimension's
+ * ratio is forced to 1.
+ */
+export declare function getScaledRatios(widthRatio: number, heightRatio: number, scaleOptions: ScaleOptions): {
+    widthRatio: number;
+    heightRatio: number;
+};

package/dist/types/scripting/ArrayWrapper.d.ts

@@ -0,0 +1,21 @@
+import { ArrayWidget } from "../widgets/others/ArrayWidget";
+import { WidgetWrapper } from "./WidgetWrapper";
+export declare class ArrayWrapper extends WidgetWrapper {
+    private array;
+    constructor(array: ArrayWidget);
+    getArrayFigure(): {
+        getIndex: () => number;
+        setIndex: (index: number) => void;
+        getArrayLength: () => number;
+    };
+    getIndex(child: WidgetWrapper): number;
+    getArrayLength(): number;
+    setArrayLength(length: number): void;
+    getDataType(): number;
+    setDataType(type: number): void;
+    isHorizontal(): boolean;
+    isShowSpinner(): boolean;
+    isShowScrollbar(): boolean;
+    getSpinnerWidth(): number;
+    getVisibleElementsCount(): number;
+}

package/dist/types/scripting/Java.d.ts

@@ -18,7 +18,7 @@ export declare function createJavaBridge(scriptEngine: ScriptEngine): {
             }) => void;
             Thread: {
                 (runnable: any): void;
-                sleep(delay: number): void;
+                sleep: (delay: number) => void;
             };
         };
         util: {

package/dist/types/scripting/PVUtil.d.ts

@@ -16,7 +16,7 @@ export declare class PVUtil {
     getStringArray(pv: PVWrapper): string[];
     getTimeInMilliseconds(pv: PVWrapper): number;
     getTimeString(pv: PVWrapper, format?: string): string | null;
-    getSeverity(pv: PVWrapper): 1 | 2 | 0 | -1;
+    getSeverity(pv: PVWrapper): -1 | 0 | 1 | 2;
     getSeverityString(pv: PVWrapper): string;
     getStatus(pv: PVWrapper): string;
     getUnits(pv: PVWrapper): string | null;