@yamcs/opi 1.3.13 → 1.4.0

package/dist/types/widgets/graphics/Polyline.d.ts

@@ -4,16 +4,52 @@ import { Point } from "../../positioning";
 import { Widget } from "../../Widget";
 import { AbstractContainerWidget } from "../others/AbstractContainerWidget";
 export declare class Polyline extends Widget {
+    private zeroDegreePoints;
+    private originPoints?;
     constructor(display: Display, parent: AbstractContainerWidget);
+    init(): void;
+    private updateZeroDegreePoints;
+    /**
+     * Mirrors AbstractPolyModel#doScale() in the Java reference, which is a
+     * two-step process, not a single uniform scale of each point:
+     *
+     * 1. The shape's bounding-box anchor (its own top-left corner) moves by
+     *    the FULL, unclamped widthRatio/heightRatio - same as any other
+     *    widget's x/y always does, regardless of its own ScaleOptions - so
+     *    the shape's position keeps up with the rest of the layout even when
+     *    the display auto-scales non-uniformly.
+     * 2. Only the points' offsets *relative to that already-repositioned
+     *    anchor* are then scaled by the ratio clamped against ScaleOptions
+     *    (e.g. keep_wh_ratio, which defaults to true for polylines) - so
+     *    it's just the shape's own internal proportions that stay locked,
+     *    not its position. Collapsing both steps into one clamped scale of
+     *    the absolute points (as an earlier version of this method did)
+     *    makes a keep_wh_ratio polyline barely move at all under
+     *    non-uniform scaling, clustering near its design position instead
+     *    of tracking the layout.
+     */
+    autoScale(widthRatio: number, heightRatio: number): void;
     draw(g: Graphics): void;
     private drawFill;
+    /**
+     * Bounds of the shaft points plus any arrowhead wings, expanded by half
+     * the line width. Arrowheads can extend past the raw points' bounding
+     * box, so the fill-level clip needs to account for them too, or an
+     * arrowhead sitting outside the shaft's bounds never gets painted with
+     * the foreground (fill) color and is stuck showing the background color.
+     * Mirrors PolylineFigure#getBounds()/getPointsBoundsWithArrows() in
+     * Yamcs Studio.
+     */
+    private getFillBounds;
     private drawShape;
+    private drawArrowhead;
     private calculateArrowPoints;
     get alpha(): number;
     get lineWidth(): number;
     get fillLevel(): number;
     get horizontalFill(): boolean;
     get points(): Point[];
+    get rotationAngle(): number;
     get arrows(): number;
     get fillArrow(): boolean;
     get arrowLength(): number;

package/dist/types/widgets/monitors/Gauge.d.ts

@@ -9,6 +9,7 @@ export declare class Gauge extends Widget {
     draw(g: Graphics): void;
     private drawBackground;
     private drawRamp;
+    private drawScale;
     private drawLabel;
     private drawNeedle;
     private drawNeedleCenter;
@@ -31,10 +32,15 @@ export declare class Gauge extends Widget {
     get levelHiHi(): number;
     get limitsFromPv(): boolean;
     get logScale(): boolean;
+    get majorTickStepHint(): number;
     get minimum(): number;
     get maximum(): number;
     get needleColor(): Color;
     get rampGradient(): boolean;
+    get scaleFont(): Font;
+    get scaleFormat(): string;
+    get showMinorTicks(): boolean;
     get showRamp(): boolean;
+    get showScale(): boolean;
     get valueLabelFormat(): string;
 }

package/dist/types/widgets/monitors/ImageBooleanIndicator.d.ts

@@ -13,7 +13,25 @@ export declare class ImageBooleanIndicator extends Widget {
     get booleanValue(): boolean;
     get image(): string;
     get label(): string;
+    /**
+     * Mirrors ImageBoolIndicatorEditPart#autoSizeWidget(): once the
+     * currently-shown (on/off) image has loaded, snap the widget's own
+     * width/height to that image's natural size - unless stretch_to_fit is
+     * set, in which case the image follows the widget's declared bounds
+     * instead, so there's nothing to auto-size to.
+     */
+    private applyAutoSize;
+    /**
+     * Position always follows the auto-scale ratio (set unconditionally by
+     * the base autoScale). Size only follows the ratio when stretch_to_fit
+     * is set; otherwise it's snapped back to the shown image's natural size,
+     * mirroring ImageBoolIndicatorEditPart's PROP_WIDTH/PROP_HEIGHT change
+     * handlers re-invoking autoSizeWidget() on every resize.
+     */
+    autoScale(widthRatio: number, heightRatio: number): void;
     draw(g: Graphics): void;
+    get autoSize(): boolean;
+    get stretchToFit(): boolean;
     get bit(): number;
     get dataType(): number;
     get showBooleanLabel(): boolean;

package/dist/types/widgets/monitors/IntensityGraph.d.ts

@@ -3,12 +3,53 @@ import { ColorMap } from "../../ColorMap";
 import { Display } from "../../Display";
 import { Font } from "../../Font";
 import { Graphics } from "../../Graphics";
+import { Bounds } from "../../positioning";
 import { Widget } from "../../Widget";
 import { AbstractContainerWidget } from "../others/AbstractContainerWidget";
 export declare class IntensityGraph extends Widget {
+    private region?;
+    private xScale?;
+    private yScale?;
+    private graphAreaX;
+    private graphAreaY;
+    private renderedGraphAreaWidth;
+    private renderedGraphAreaHeight;
+    private _effectiveCropLeft?;
+    private _effectiveCropRight?;
+    private _effectiveCropTop?;
+    private _effectiveCropBottom?;
+    private _effectiveXAxisMinimum?;
+    private _effectiveXAxisMaximum?;
+    private _effectiveYAxisMinimum?;
+    private _effectiveYAxisMaximum?;
+    private originalState?;
     constructor(display: Display, parent: AbstractContainerWidget);
+    init(): void;
     draw(g: Graphics): void;
+    applyRubberBandZoom(selection: Bounds): void;
+    /** Ports IntensityGraphFigure.java's mouseDoubleClicked() zoom reset. */
+    resetZoom(): void;
+    private pushProfilePV;
+    private applyColorDepth;
+    private pixelValueAt;
+    get effectiveCropLeft(): number;
+    set effectiveCropLeft(v: number);
+    get effectiveCropRight(): number;
+    set effectiveCropRight(v: number);
+    get effectiveCropTop(): number;
+    set effectiveCropTop(v: number);
+    get effectiveCropBottom(): number;
+    set effectiveCropBottom(v: number);
+    get effectiveXAxisMinimum(): number;
+    set effectiveXAxisMinimum(v: number);
+    get effectiveXAxisMaximum(): number;
+    set effectiveXAxisMaximum(v: number);
+    get effectiveYAxisMinimum(): number;
+    set effectiveYAxisMinimum(v: number);
+    get effectiveYAxisMaximum(): number;
+    set effectiveYAxisMaximum(v: number);
     get gap(): number;
+    get colorDepth(): number;
     get colorMap(): ColorMap;
     get cropBottom(): number;
     get cropLeft(): number;
@@ -19,8 +60,13 @@ export declare class IntensityGraph extends Widget {
     get font(): Font;
     get graphAreaHeight(): number;
     get graphAreaWidth(): number;
+    get horizonProfileXPvName(): string;
+    get horizonProfileYPvName(): string;
+    get verticalProfileXPvName(): string;
+    get verticalProfileYPvName(): string;
     get maximum(): number;
     get minimum(): number;
+    get rgbMode(): boolean;
     get showRamp(): boolean;
     get xAxisAxisColor(): Color;
     get xAxisAxisTitle(): string;

package/dist/types/widgets/monitors/IntensityGraphRegion.d.ts

@@ -0,0 +1,15 @@
+import { OpiGrabEvent, OpiMouseEvent } from "../../EventHandler";
+import { HitRegionSpecification } from "../../HitRegionSpecification";
+import { Bounds } from "../../positioning";
+import { IntensityGraph } from "./IntensityGraph";
+export declare class IntensityGraphRegion implements HitRegionSpecification {
+    private widget;
+    id: string;
+    selection?: Bounds;
+    private grabStart?;
+    constructor(id: string, widget: IntensityGraph);
+    mouseDown(evt: OpiMouseEvent): void;
+    grab(evt: OpiGrabEvent): void;
+    grabEnd(): void;
+    dblclick(): void;
+}

package/dist/types/widgets/monitors/Meter.d.ts

@@ -9,6 +9,7 @@ export declare class Meter extends Widget {
     constructor(display: Display, parent: AbstractContainerWidget);
     init(): void;
     draw(g: Graphics): void;
+    private computeLimits;
     private drawRamp;
     private drawNeedle;
     get needleWidth(): number;
@@ -24,16 +25,24 @@ export declare class Meter extends Widget {
     get levelLoLo(): number;
     get levelHi(): number;
     get levelHiHi(): number;
+    get limitsFromPv(): boolean;
     get logScale(): boolean;
+    get majorTickStepHint(): number;
+    get majorTickLength(): number;
+    get minorTickLength(): number;
     get minimum(): number;
     get maximum(): number;
     get needleColor(): Color;
     get rampGradient(): boolean;
     get scaleFont(): Font;
+    get scaleFormat(): string;
     get showLo(): boolean;
     get showLoLo(): boolean;
     get showHi(): boolean;
     get showHiHi(): boolean;
+    get showMinorTicks(): boolean;
     get showRamp(): boolean;
+    get showScale(): boolean;
+    get showValueLabel(): boolean;
     get valueLabelFormat(): string;
 }

package/dist/types/widgets/monitors/TextUpdate.d.ts

@@ -8,13 +8,23 @@ export declare class TextUpdate extends Widget {
     private tooltipRegion?;
     constructor(display: Display, parent: AbstractContainerWidget);
     init(): void;
+    drawHolder(g: Graphics): void;
+    private computeDisplayText;
     draw(g: Graphics): void;
+    private drawSingleLine;
+    private drawRotated;
+    private drawWrapped;
+    private wrapText;
+    private wrapLine;
+    get autoSize(): boolean;
     get font(): Font;
     get formatType(): number;
     get horizAlignment(): number;
     get precision(): number;
     get precisionFromPV(): boolean;
+    get rotationAngle(): number;
     get showLohi(): boolean;
     get showUnits(): boolean;
     get vertAlignment(): number;
+    get wrapWords(): boolean;
 }

package/dist/types/widgets/monitors/xygraph/Axis.d.ts

@@ -22,7 +22,7 @@ export declare class Axis {
     performAutoScale(): void;
     applyZoom(center: number, ratio: number): void;
     get autoScale(): boolean;
-    get autoScaleTreshold(): number;
+    get autoScaleThreshold(): number;
     get axisColor(): Color;
     get axisTitle(): string;
     get dashGridLine(): boolean;

package/dist/types/widgets/others/AbstractContainerWidget.d.ts

@@ -14,6 +14,14 @@ export declare abstract class AbstractContainerWidget extends Widget {
     findWidget(wuid: string): Widget | undefined;
     findWidgetByName(name: string): Widget | undefined;
     hide(): void;
+    /**
+     * Repositions/resizes this container itself, then recurses into its
+     * direct children. Containers whose children are laid out by their own
+     * bespoke mechanism (SashContainer panels, ArrayWidget slots, a
+     * LinkingContainer's embedded display) override this to scale only
+     * themselves, not their children.
+     */
+    autoScale(widthRatio: number, heightRatio: number): void;
     destroy(): void;
     get widgets(): Widget[];
     get connections(): Connection[];

package/dist/types/widgets/others/ArrayWidget.d.ts

@@ -0,0 +1,97 @@
+import { Display } from "../../Display";
+import { Graphics } from "../../Graphics";
+import { XMLNode } from "../../XMLNode";
+import { AbstractContainerWidget } from "./AbstractContainerWidget";
+/**
+ * Container that clones a single authored child widget (or child subtree)
+ * `vec` times and lays the clones out edge-to-edge, binding each clone to
+ * one element of an array-valued PV. An index spinner and scrollbar allow
+ * scrolling a window of `vec` visible clones over a possibly-larger array.
+ *
+ * Ported from org.csstudio.opibuilder.widgets.array (ArrayModel/ArrayFigure/
+ * ArrayEditPart). Unlike the Java original, clones are not literal sibling
+ * widgets sharing the array's own PV - each clone (and, for a grouped
+ * template, every PV-bound descendant of a clone) is given its own unique
+ * synthetic loc:// PV. This lets ordinary control widgets (TextInput,
+ * ScaledSlider, ...) work as writable per-element controls with zero
+ * Array-specific code in those widgets.
+ */
+export declare class ArrayWidget extends AbstractContainerWidget {
+    private templateNode?;
+    private templateWidgetType;
+    private elementWidth;
+    private elementHeight;
+    private originalEnabled;
+    private scrollIndex;
+    private fullValue;
+    private redistributing;
+    private spinnerUpRegion?;
+    private spinnerUpPressed;
+    private spinnerDownRegion?;
+    private spinnerDownPressed;
+    private spinnerRepeatTimeout?;
+    private spinnerLabelRegion?;
+    private spinnerLabelBounds?;
+    private editingIndex;
+    private indexInputEl?;
+    private scrollDecreaseRegion?;
+    private scrollDecreasePressed;
+    private scrollIncreaseRegion?;
+    private scrollIncreasePressed;
+    private scrollPageDecreaseRegion?;
+    private scrollPageIncreaseRegion?;
+    private scrollThumbRegion?;
+    private scrollGrabStartIndex;
+    private scrollDragRange;
+    private scrollRepeatTimeout?;
+    constructor(display: Display, parent: AbstractContainerWidget);
+    parseNode(node: XMLNode): Promise<void>;
+    init(): void;
+    destroy(): void;
+    private forEachDescendant;
+    private startEditingIndex;
+    private commitEditingIndex;
+    private cancelEditingIndex;
+    private slotPvName;
+    private hookSlotWriteBack;
+    private coerceElement;
+    private defaultElementValue;
+    get value(): any;
+    set value(value: any);
+    get effectiveArrayLength(): number;
+    private redistribute;
+    private clampSpinnerIndex;
+    private clampScrollbarIndex;
+    private setSpinnerIndex;
+    private setScrollbarIndex;
+    /**
+     * Scripting entry point (ArrayWrapper#getArrayFigure().setIndex()).
+     * Matches ArrayFigure.setIndex()'s [0, arrayLength-1] range.
+     */
+    setScrollIndex(index: number): void;
+    getScrollIndex(): number;
+    private stopSpinnerRepeating;
+    private stepSpinnerRepeatedly;
+    private stopScrollbarRepeating;
+    private stepScrollbarRepeatedly;
+    private computeRegions;
+    autoScale(widthRatio: number, heightRatio: number): void;
+    private layoutSlots;
+    beforeDrawBorder(g: Graphics): void;
+    draw(g: Graphics): void;
+    private drawGrayOverlay;
+    private drawSpinner;
+    private drawSpinnerLabel;
+    private drawScrollbar;
+    private registerPageRegion;
+    private drawThumb;
+    private drawBevelBorder;
+    private drawArrowButton;
+    get arrayLength(): number;
+    get spinnerWidth(): number;
+    get horizontal(): boolean;
+    get showSpinner(): boolean;
+    get showScrollbar(): boolean;
+    get vec(): number;
+    get dataType(): number;
+}

package/dist/types/widgets/others/Connection.d.ts

@@ -12,7 +12,62 @@ export declare class Connection extends Widget {
     draw(g: Graphics): void;
     private drawPath;
     private drawManhattanConnection;
+    /**
+     * When an arrowhead is filled, its endpoint is pulled back to the
+     * arrowhead's base so the (butt-capped) shaft stroke doesn't poke out
+     * past the narrower triangle tip. Mirrors Polyline's shaftPoints
+     * handling, and Yamcs Studio's PolylineFigure#drawPolyLineWithArrow(),
+     * which only performs this pullback for the filled (PolygonDecoration)
+     * case, not the unfilled line-arrow case.
+     */
+    private getShaftEnd;
     private getDashArray;
+    /**
+     * Ordered vertex list of this connection's own line, in whichever mode
+     * (manual points / Manhattan / direct) is currently active. Used both for
+     * this connection's own rendering, and so that other Connection widgets
+     * can query this connection's line when checking for crossings (see
+     * `strokeJumpAwarePath`). Deliberately excludes arrow shaft trimming and
+     * the drawPath half-pixel nudge, since those only affect the polyline's
+     * own first/last point and are irrelevant to mid-line crossings.
+     */
+    private getVertices;
+    /**
+     * Strokes a connection's polyline, inserting a "jump" indicator
+     * (arc/gap/square/2-slides) wherever it crosses another connection's line,
+     * per `line_jump_add`/`line_jump_style`/`line_jump_size`. Falls back to a
+     * single continuous stroke (today's behavior, pixel-identical) when
+     * `line_jump_add` is NONE, which is the common case.
+     *
+     * Every non-gap style is folded into the SAME continuous `Path` as the
+     * surrounding plain line (extra `lineTo`s for the arc/square/slides
+     * shape, rather than a separate stroke call per shape) and stroked with
+     * one `strokePath` call per run. Two adjoining strokes of the same line
+     * never agree on anti-aliased sub-pixel coverage at their shared
+     * endpoint, which shows up as a hairline seam right at the jump — a
+     * single path has no such seam, since the canvas joins its interior
+     * vertices itself. A run only ends where the line should genuinely be
+     * interrupted (a GAP-style jump).
+     */
+    private strokeJumpAwarePath;
+    /**
+     * Splits `vertices` into one or more runs of points to stroke as
+     * continuous paths, substituting the arc/square/2-slides jump shape's own
+     * vertices in-line wherever this connection's line crosses another
+     * connection's line, or (for the gap style) ending one run and starting
+     * the next past the crossing. Ported from Yamcs Studio's
+     * WidgetConnectionEditPart#getIntersectionPoints.
+     */
+    private buildJumpAwareRuns;
+    /**
+     * Finds where the (axis-aligned) segment `x1y1`-`x2y2` of this
+     * connection's own line crosses any segment of any other connection,
+     * returning the intersection plus the two "notch" points on THIS segment
+     * offset `lineJumpSize` either side of it, sorted by distance from
+     * `x1y1`. Segments whose orientation doesn't match `line_jump_add` (or
+     * that are diagonal) are left alone, matching Yamcs Studio.
+     */
+    private findCrossings;
     private drawDirectConnection;
     private getManhattanAnchor;
     private getPosition;
@@ -28,6 +83,9 @@ export declare class Connection extends Widget {
     get fillArrow(): boolean;
     get arrowLength(): number;
     get lineColor(): Color;
+    get lineJumpAdd(): number;
+    get lineJumpSize(): number;
+    get lineJumpStyle(): number;
     get lineStyle(): number;
     get lineWidth(): number;
     get router(): number;

package/dist/types/widgets/others/DisplayWidget.d.ts

@@ -1,6 +1,6 @@
 import { Display } from "../../Display";
 import { Graphics } from "../../Graphics";
-import { Bounds } from "../../positioning";
+import { Bounds, Dimension } from "../../positioning";
 import { AutoScaleWidgets } from "../../scale";
 import { XMLNode } from "../../XMLNode";
 import { AbstractContainerWidget } from "./AbstractContainerWidget";
@@ -13,4 +13,6 @@ export declare class DisplayWidget extends AbstractContainerWidget {
     draw(g: Graphics): void;
     measureContentBounds(scaled: boolean): Bounds;
     get autoScaleWidgets(): AutoScaleWidgets;
+    /** The display's authored (design-time) size, unaffected by later autoScale() calls. */
+    get designSize(): Dimension;
 }

package/dist/types/widgets/others/GridLayout.d.ts

@@ -0,0 +1,25 @@
+import { Display } from "../../Display";
+import { Graphics } from "../../Graphics";
+import { Widget } from "../../Widget";
+import { AbstractContainerWidget } from "./AbstractContainerWidget";
+/**
+ * A "virtual" widget that never renders itself. When present among a
+ * container's children, it repositions (and optionally resizes) its
+ * siblings into a grid, once, at parse time. See applyGridLayout().
+ */
+export declare class GridLayout extends Widget {
+    constructor(display: Display, parent: AbstractContainerWidget);
+    get numberOfColumns(): number;
+    get fillGrids(): boolean;
+    get gridGap(): number;
+    draw(g: Graphics): void;
+}
+/**
+ * If `widgets` contains a GridLayout, repositions (and, if fill_grids is
+ * set, resizes) all of its siblings into a grid, in place. Mirrors
+ * GridLayoutEditpart#getNewBounds from the Java reference: row-major
+ * placement, column/row size driven by the widest/tallest sibling in that
+ * column/row, computed once from each sibling's own declared width/height
+ * (not the container's size, which is never consulted).
+ */
+export declare function applyGridLayout(widgets: Widget[]): void;

package/dist/types/widgets/others/GroupingContainer.d.ts

@@ -1,8 +1,68 @@
+import { Display } from "../../Display";
 import { Graphics } from "../../Graphics";
 import { XMLNode } from "../../XMLNode";
 import { AbstractContainerWidget } from "./AbstractContainerWidget";
 export declare class GroupingContainer extends AbstractContainerWidget {
+    private scrollX;
+    private scrollY;
+    private maxScrollX;
+    private maxScrollY;
+    private contentWidth;
+    private contentHeight;
+    private dragRangeX?;
+    private dragRangeY?;
+    private grabStartX?;
+    private grabStartY?;
+    private actionTimeout?;
+    private xDecPressed;
+    private xIncPressed;
+    private yDecPressed;
+    private yIncPressed;
+    private thumbXRegion?;
+    private thumbYRegion?;
+    private xDecRegion?;
+    private xIncRegion?;
+    private yDecRegion?;
+    private yIncRegion?;
+    private trackXBeforeRegion?;
+    private trackXAfterRegion?;
+    private trackYBeforeRegion?;
+    private trackYAfterRegion?;
+    constructor(display: Display, parent: AbstractContainerWidget);
     parseNode(node: XMLNode): Promise<void>;
+    init(): void;
+    destroy(): void;
+    private makeThumbRegion;
+    private makeStepRegion;
+    private makePageRegion;
+    private setScrollOffset;
+    private stepScrollRepeatedly;
+    private pageScrollRepeatedly;
+    private endScrollAction;
+    get forwardColors(): boolean;
+    get showScrollbar(): boolean;
     beforeDrawBorder(g: Graphics): void;
+    /**
+     * Union of all visible children's bounds, unioned with this container's
+     * own viewport (never smaller than the visible area), matching draw2d's
+     * FreeformViewport#readjustScrollBars.
+     */
+    private measureContentExtent;
+    /**
+     * Resolves scrollbar visibility one level deep, matching draw2d's
+     * ScrollPaneSolver: check overflow against the full (unreserved) viewport
+     * first, then check whether reserving one axis's thickness pushes the
+     * other axis into overflow too. Not a true iterative fixed-point solve -
+     * draw2d doesn't do that either.
+     */
+    private resolveScrollbars;
     draw(g: Graphics): void;
+    /**
+     * One drawing routine for both axes, matching draw2d's stock ScrollBar
+     * look: up/down (or left/right) bevel buttons plus a draggable thumb.
+     * Unlike Yamcs Studio, does not support mouse wheel, since neither does
+     * GroupingContainerFigure/ScrollPane there.
+     */
+    private drawScrollbar;
+    private drawScrollButton;
 }

package/dist/types/widgets/others/LinkingContainer.d.ts

@@ -1,18 +1,40 @@
 import { Display } from "../../Display";
 import { Graphics } from "../../Graphics";
+import { Widget } from "../../Widget";
 import { XMLNode } from "../../XMLNode";
 import { AbstractContainerWidget } from "./AbstractContainerWidget";
 export declare class LinkingContainer extends AbstractContainerWidget {
     private linkedDisplay?;
     resolvedOpiFile?: string;
+    private reloadGeneration;
     constructor(display: Display, parent: AbstractContainerWidget);
     parseNode(node: XMLNode): Promise<void>;
     init(): Promise<void>;
+    /**
+     * (Re)loads the linked display from the current `opi_file` property.
+     * Called once during init(), and again whenever a Rule or script changes
+     * `opi_file` at runtime (mirrors Java's
+     * LinkingContainerEditpart#configureDisplayModel).
+     */
+    private reload;
     draw(g: Graphics): void;
-    getLinkedWidget(): import("../..").Widget | undefined;
-    get widgets(): import("../..").Widget[];
+    /**
+     * Content bounds to use for fitting/cropping. When `group_name` resolves to
+     * a specific named sub-widget (e.g. one "frame" of a dynamic symbol), use
+     * that widget's own bounds instead of the union of the whole linked
+     * display, so that sibling frames don't affect sizing/scaling.
+     */
+    private measureFrameBounds;
+    /**
+     * Draws either the single named sub-widget matching `group_name`, or (when
+     * no group is selected) the entire linked display.
+     */
+    private drawLinkedContent;
+    getLinkedWidget(): Widget | undefined;
+    get widgets(): Widget[];
     get connections(): import("./Connection").Connection[];
-    findWidget(wuid: string): import("../..").Widget | undefined;
+    autoScale(widthRatio: number, heightRatio: number): void;
+    findWidget(wuid: string): Widget | undefined;
     get opiFile(): string;
     get groupName(): string;
     get resizeBehavior(): number;

package/dist/types/widgets/others/SashContainer.d.ts

@@ -0,0 +1,29 @@
+import { Display } from "../../Display";
+import { Graphics } from "../../Graphics";
+import { XMLNode } from "../../XMLNode";
+import { AbstractContainerWidget } from "./AbstractContainerWidget";
+export declare class SashContainer extends AbstractContainerWidget {
+    private sashRegion?;
+    private grabStartPosition?;
+    private grabClientSize?;
+    private panelOriginSizes;
+    private childOriginBounds;
+    constructor(display: Display, parent: AbstractContainerWidget);
+    parseNode(node: XMLNode): Promise<void>;
+    init(): void;
+    beforeDrawBorder(g: Graphics): void;
+    draw(g: Graphics): void;
+    private measureLayout;
+    private applyPanelBounds;
+    private scalePanelChildren;
+    autoScale(widthRatio: number, heightRatio: number): void;
+    private drawSash;
+    private drawSashEdge;
+    get horizontal(): boolean;
+    get minPaneSize(): number;
+    get panel1AutoScaleChildren(): boolean;
+    get panel2AutoScaleChildren(): boolean;
+    get sashPosition(): number;
+    get sashStyle(): number;
+    get sashWidth(): number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yamcs/opi",
-  "version": "1.3.13",
+  "version": "1.4.0",
   "description": "OPI Display Renderer",
   "author": "Yamcs Team <yamcs@spaceapplications.com>",
   "repository": {
@@ -35,6 +35,10 @@
     "peggy": "5.1.0",
     "prettier": "^3.5.3",
     "tslib": "^2.6.3",
-    "typescript": "^6.0.3"
+    "typescript": "^7.0.2"
+  },
+  "allowScripts": {
+    "esbuild": true,
+    "fsevents": true
   }
 }

package/dist/types/widgets/graphics/ImageHelper.d.ts

@@ -1,3 +0,0 @@
-export declare class ImageHelper {
-    private element?;
-}