Remove usage of non-const enum LayoutDirection from internal code for…

… build size optimization

src/elements/controls/groupbox.ts

@@ -1,4 +1,5 @@
 import { Bindable } from "@src/bindings/bindable";
+import { Axis } from "@src/positional/axis";
 import { Padding } from "@src/positional/padding";
 import { Scale } from "@src/positional/scale";
 import { isUndefined } from "@src/utilities/type";
@@ -8,7 +9,6 @@ import { ElementParams } from "../elementParams";
 import { AbsolutePosition } from "../layouts/absolute/absolutePosition";
 import { FlexibleDirectionalLayoutParams, FlexibleLayoutControl } from "../layouts/flexible/flexible";
 import { FlexiblePosition } from "../layouts/flexible/flexiblePosition";
-import { LayoutDirection } from "../layouts/flexible/layoutDirection";
 import { BoxContainer, BoxControl, BoxParams } from "./box";
 
 
@@ -51,7 +51,7 @@ export function groupbox<I extends SizeParams, P extends ParsedSize>(params: (Gr
 	let content: BoxContainer[],
 		gap: Padding | undefined,
 		spacing: Scale | undefined,
-		direction: LayoutDirection = LayoutDirection.Vertical;
+		direction: number = Axis.Vertical;
 
 	if ("content" in params)
 	{
@@ -75,4 +75,4 @@ export function groupbox<I extends SizeParams, P extends ParsedSize>(params: (Gr
 	boxParams.content = <WidgetCreator<FlexiblePosition>>((parent, output) => new FlexibleLayoutControl(parent, output, flexParams));
 
 	return (parent, output) => new BoxControl<I, P>(parent, output, boxParams);
-}
+}

src/elements/controls/listview.ts

@@ -1,5 +1,5 @@
 import { Bindable } from "@src/bindings/bindable";
-import { LayoutDirection } from "@src/elements/layouts/flexible/layoutDirection";
+import { Axis } from "@src/positional/axis";
 import { parseScaleOrFallback } from "@src/positional/parsing/parseScale";
 import { Parsed } from "@src/positional/parsing/parsed";
 import { ParsedScale } from "@src/positional/parsing/parsedScale";
@@ -229,7 +229,7 @@ class ListViewControl<I, P> extends Control<ListViewDesc, I, P> implements ListV
 		const columnWidths = this._columnWidths;
 		if (columnWidths && widget.width !== area.width)
 		{
-			flexibleLayout(widths, area, LayoutDirection.Horizontal, zeroScale, (idx, subarea) =>
+			flexibleLayout(widths, area, Axis.Horizontal, zeroScale, (idx, subarea) =>
 			{
 				this.columns[idx].width = round(subarea.width);
 			});

src/elements/layouts/flexible/desiredSpacing.ts

@@ -1,4 +1,4 @@
-import { LayoutDirection } from "@src/elements/layouts/flexible/layoutDirection";
+import { Axis } from "@src/positional/axis";
 import { Parsed } from "@src/positional/parsing/parsed";
 import { isAbsolute, ParsedScale } from "@src/positional/parsing/parsedScale";
 import { ScaleType } from "@src/positional/parsing/scaleType";
@@ -54,7 +54,7 @@ export function recalculateInheritedSpaceFromChild(position: ParsedSize, flags:
 /**
  * Recalculates `position` based on the size of the specified children, if the required inheritance flags are set.
  */
-export function recalculateInheritedSpaceFromChildren(position: ParsedSize, flags: InheritFlags, children: Layoutable<Parsed<FlexiblePosition>>[], spacing: ParsedScale, layoutDirection: LayoutDirection): boolean
+export function recalculateInheritedSpaceFromChildren(position: ParsedSize, flags: InheritFlags, children: Layoutable<Parsed<FlexiblePosition>>[], spacing: ParsedScale, layoutDirection: Axis): boolean
 {
 	return recalculateInheritedSpace(position, flags, (direction) => getDesiredSpaceFromChildrenForDirection(children, spacing, layoutDirection, direction));
 }
@@ -63,11 +63,11 @@ export function recalculateInheritedSpaceFromChildren(position: ParsedSize, flag
 /**
  * Recalculates `position` based on the size of the specified children, if the required inheritance flags are set.
  */
-function recalculateInheritedSpace(position: ParsedSize, flags: InheritFlags, getChildrenSpace: (direction: LayoutDirection) => number | null): boolean
+function recalculateInheritedSpace(position: ParsedSize, flags: InheritFlags, getChildrenSpace: (direction: Axis) => number | null): boolean
 {
 	if ((flags & InheritFlags.All)
-		&& (tryInheritSize(position, flags & InheritFlags.Width, LayoutDirection.Horizontal, getChildrenSpace)
-			| tryInheritSize(position, flags & InheritFlags.Height, LayoutDirection.Vertical, getChildrenSpace)))
+		&& (tryInheritSize(position, flags & InheritFlags.Width, Axis.Horizontal, getChildrenSpace)
+			| tryInheritSize(position, flags & InheritFlags.Height, Axis.Vertical, getChildrenSpace)))
 	{
 		return true;
 	}
@@ -78,7 +78,7 @@ function recalculateInheritedSpace(position: ParsedSize, flags: InheritFlags, ge
 /**
  * Try to inherit the size from the child, if the inherit flag is set.
  */
-function tryInheritSize(position: ParsedSize, inheritFlag: number, direction: LayoutDirection, getChildrenSpace: (direction: LayoutDirection) => number | null): number
+function tryInheritSize(position: ParsedSize, inheritFlag: number, direction: Axis, getChildrenSpace: (direction: Axis) => number | null): number
 {
 	let value: number | null;
 	if (inheritFlag && !isNull(value = getChildrenSpace(direction)))
@@ -98,7 +98,7 @@ function tryInheritSize(position: ParsedSize, inheritFlag: number, direction: La
  * Gets the desired space on the parent for a single child if the child asks for
  * absolute positioning, for a single direction.
  */
-function getDesiredSpaceFromChildForDirection(item: Parsed<FlexiblePosition>, direction: LayoutDirection): number | null
+function getDesiredSpaceFromChildForDirection(item: Parsed<FlexiblePosition>, direction: Axis): number | null
 {
 	const
 		sizeKey = sizeKeys[direction],
@@ -118,7 +118,7 @@ function getDesiredSpaceFromChildForDirection(item: Parsed<FlexiblePosition>, di
 /**
  * Gets the total desired space for all children, if they are absolutely positioned.
  */
-function getDesiredSpaceFromChildrenForDirection(items: Layoutable<Parsed<FlexiblePosition>>[], spacing: ParsedScale, layoutDirection: LayoutDirection, axisDirection: LayoutDirection): number | null
+function getDesiredSpaceFromChildrenForDirection(items: Layoutable<Parsed<FlexiblePosition>>[], spacing: ParsedScale, layoutDirection: Axis, axisDirection: Axis): number | null
 {
 	const axisIsLayoutDirection = (layoutDirection === axisDirection);
 
@@ -184,4 +184,4 @@ function addOrMax(oldValue: number, newValue: number, add: boolean): number
 		return (oldValue + newValue);
 	}
 	return (oldValue < newValue) ? newValue : oldValue;
-}
+}

src/elements/layouts/flexible/flexible.ts

@@ -1,6 +1,7 @@
 import { defaultSpacing, redrawEvent } from "@src/elements/constants";
 import { VisualElement } from "@src/elements/controls/visualElement";
 import { LayoutDirection } from "@src/elements/layouts/flexible/layoutDirection";
+import { Axis } from "@src/positional/axis";
 import { parseScale } from "@src/positional/parsing/parseScale";
 import { Parsed } from "@src/positional/parsing/parsed";
 import { ParsedScale } from "@src/positional/parsing/parsedScale";
@@ -67,7 +68,7 @@ export function horizontal(params: FlexibleLayoutParams & FlexiblePosition): Wid
 export function horizontal(params: FlexibleLayoutParams & AbsolutePosition): WidgetCreator<AbsolutePosition>;
 export function horizontal<I extends SizeParams, P extends ParsedSize>(params: (FlexibleLayoutParams | FlexibleLayoutContainer) & I): WidgetCreator<I, P>
 {
-	(<FlexibleDirectionalLayoutParams>params).direction = LayoutDirection.Horizontal;
+	(<FlexibleDirectionalLayoutParams>params).direction = <number>Axis.Horizontal;
 	return <never>flexible(<never>params);
 }
 
@@ -81,7 +82,7 @@ export function vertical(params: FlexibleLayoutParams & FlexiblePosition): Widge
 export function vertical(params: FlexibleLayoutParams & AbsolutePosition): WidgetCreator<AbsolutePosition>;
 export function vertical<I extends SizeParams, P extends ParsedSize>(params: (FlexibleLayoutParams | FlexibleLayoutContainer) & I): WidgetCreator<I, P>
 {
-	(<FlexibleDirectionalLayoutParams>params).direction = LayoutDirection.Vertical;
+	(<FlexibleDirectionalLayoutParams>params).direction = <number>Axis.Vertical;
 	return <never>flexible(<never>params);
 }
 
@@ -113,14 +114,14 @@ export class FlexibleLayoutControl<I extends SizeParams, P extends ParsedSize> e
 	_renderableChildren!: FlexChild[];
 	_renderableChildrenPositions!: Parsed<FlexiblePosition>[];
 
-	_direction: LayoutDirection;
+	_direction: Axis;
 	_spacing: ParsedScale;
 	_flags: number;
 
 	constructor(parent: ParentControl<I, P>, output: BuildOutput, params: (FlexibleDirectionalLayoutParams | FlexibleLayoutContainer) & I)
 	{
 		super(parent, params);
-		this._direction = (<{ direction?: LayoutDirection }>params).direction || LayoutDirection.Vertical;
+		this._direction = (<{ direction?: Axis }>params).direction || Axis.Vertical;
 		this._spacing = (parseScale((<{ spacing?: Scale }>params).spacing) || defaultSpacing);
 
 		const inheritFlags = getInheritanceFlags(params);
@@ -179,4 +180,4 @@ export class FlexibleLayoutControl<I extends SizeParams, P extends ParsedSize> e
 			this._renderableChildren[idx].layout(widgets, subarea);
 		});
 	}
-}
+}

src/elements/layouts/flexible/flexibleLayout.ts

@@ -1,5 +1,5 @@
 import { FlexiblePosition } from "@src/elements/layouts/flexible/flexiblePosition";
-import { LayoutDirection } from "@src/elements/layouts/flexible/layoutDirection";
+import { Axis } from "@src/positional/axis";
 import { Parsed } from "@src/positional/parsing/parsed";
 import { ParsedPadding } from "@src/positional/parsing/parsedPadding";
 import { isAbsolute, isPercentile, isWeighted, ParsedScale } from "@src/positional/parsing/parsedScale";
@@ -11,14 +11,14 @@ import { applyPaddingToDirection, axisKeys, endKeys, setSizeWithPaddingForDirect
 /**
  * Lay out all elements over the specified area and direction, then calls apply for each element.
  */
-export function flexibleLayout(elements: Parsed<FlexiblePosition>[], parentArea: Rectangle, layoutDirection: LayoutDirection, spacing: ParsedScale, apply: (index: number, childArea: Rectangle) => void): void
+export function flexibleLayout(elements: Parsed<FlexiblePosition>[], parentArea: Rectangle, layoutDirection: Axis, spacing: ParsedScale, apply: (index: number, childArea: Rectangle) => void): void
 {
 	const elementCount = elements.length;
 	if (!elementCount)
 		return;
 
-	const otherDirection = (layoutDirection == LayoutDirection.Horizontal)
-		? LayoutDirection.Vertical : LayoutDirection.Horizontal;
+	const otherDirection = (layoutDirection == Axis.Horizontal)
+		? Axis.Vertical : Axis.Horizontal;
 
 	// First pass: calculate available and used space.
 	const stack = parseFlexibleElements(elements, spacing, layoutDirection, otherDirection);
@@ -72,7 +72,7 @@ interface ParsedStackElement
 /**
  * Parses all specified child positions
  */
-function parseFlexibleElements(elements: Parsed<FlexiblePosition>[], spacing: ParsedScale, mainDirection: LayoutDirection, otherDirection: LayoutDirection): ParsedStack
+function parseFlexibleElements(elements: Parsed<FlexiblePosition>[], spacing: ParsedScale, mainDirection: Axis, otherDirection: Axis): ParsedStack
 {
 	const elementCount = elements.length;
 	const stack: ParsedStack = {

src/elements/layouts/paddingHelpers.ts

@@ -1,4 +1,4 @@
-import { LayoutDirection } from "@src/elements/layouts/flexible/layoutDirection";
+import { Axis } from "@src/positional/axis";
 import { ParsedPadding } from "@src/positional/parsing/parsedPadding";
 import { isAbsolute, isPercentile, isWeighted, ParsedScale } from "@src/positional/parsing/parsedScale";
 import { convertToPixels } from "@src/positional/parsing/parseScale";
@@ -30,7 +30,7 @@ export function hasPadding(padding: ParsedPadding | undefined): boolean
  * Returns the total amount of absolute padding for the specified direction. Throws an error
  * if one of the padding values is not absolute. Returns the total amount of padding applied.
  */
-export function setAbsolutePaddingForDirection(area: FrameRectangle, padding: ParsedPadding, direction: LayoutDirection): number
+export function setAbsolutePaddingForDirection(area: FrameRectangle, padding: ParsedPadding, direction: Axis): number
 {
 	const startPad = padding[startKeys[direction]];
 	const endPad = padding[endKeys[direction]];
@@ -50,16 +50,16 @@ export function setAbsolutePaddingForDirection(area: FrameRectangle, padding: Pa
  */
 export function setSizeWithPadding(area: Rectangle, width: ParsedScale, height: ParsedScale, padding: ParsedPadding): void
 {
-	setSizeWithPaddingForDirection(area, LayoutDirection.Horizontal, width, padding);
-	setSizeWithPaddingForDirection(area, LayoutDirection.Vertical, height, padding);
+	setSizeWithPaddingForDirection(area, Axis.Horizontal, width, padding);
+	setSizeWithPaddingForDirection(area, Axis.Vertical, height, padding);
 }
 
 
 /**
  * Sets the size and padding to a specific area as a whole on the specified direction. Area is
  * interpreted as the available space and updated accordingly. Returns total space used.
  */
-export function setSizeWithPaddingForDirection(area: Rectangle, direction: LayoutDirection, size: ParsedScale, padding: ParsedPadding): number
+export function setSizeWithPaddingForDirection(area: Rectangle, direction: Axis, size: ParsedScale, padding: ParsedPadding): number
 {
 	const
 		sizeKey = sizeKeys[direction],
@@ -79,7 +79,7 @@ export function setSizeWithPaddingForDirection(area: Rectangle, direction: Layou
 /**
  * Applies padding to a specific area as a whole on the specified direction. Returns total space used.
  */
-export function applyPaddingToDirection(area: Rectangle, direction: LayoutDirection, padding: ParsedPadding, leftoverSpace: number, weightedTotal: number, percentileTotal: number): number
+export function applyPaddingToDirection(area: Rectangle, direction: Axis, padding: ParsedPadding, leftoverSpace: number, weightedTotal: number, percentileTotal: number): number
 {
 	return applyPaddingToAxis(area, padding, leftoverSpace, weightedTotal, percentileTotal, axisKeys[direction], sizeKeys[direction], startKeys[direction], endKeys[direction]);
 }
@@ -115,4 +115,4 @@ function calculateTotal(size: ParsedScale, paddingStart: ParsedScale, paddingEnd
 		total += paddingEnd[0];
 
 	return total;
-}
+}

src/positional/axis.ts

@@ -0,0 +1,8 @@
+/**
+ * Similar to LayoutDirection, but const. Used for internal directional checking.
+ */
+export const enum Axis
+{
+	Vertical = 0,
+	Horizontal = 1
+}

src/windows/baseWindowControl.ts

@@ -1,6 +1,6 @@
 import { Bindable } from "@src/bindings/bindable";
 import { zeroPadding } from "@src/elements/constants";
-import { LayoutDirection } from "@src/elements/layouts/flexible/layoutDirection";
+import { Axis } from "@src/positional/axis";
 import { Paddable } from "@src/positional/paddable";
 import { Size } from "@src/positional/size";
 import { identifier } from "@src/utilities/identifier";
@@ -119,8 +119,8 @@ export abstract class BaseWindowControl implements WindowTemplate, ParentWindow
 				this.close();
 			}
 		};
-		const windowWidth = setAxisSizeIfNumber(windowDesc, LayoutDirection.Horizontal, width);
-		const windowHeight = setAxisSizeIfNumber(windowDesc, LayoutDirection.Vertical, height);
+		const windowWidth = setAxisSizeIfNumber(windowDesc, Axis.Horizontal, width);
+		const windowHeight = setAxisSizeIfNumber(windowDesc, Axis.Vertical, height);
 		this._setWindowSizeAndFlags(windowWidth, windowHeight);
 
 		windowBinder.add(windowDesc, "title", params.title);
@@ -190,11 +190,11 @@ export abstract class BaseWindowControl implements WindowTemplate, ParentWindow
 		const flags = this._flags;
 		if (flags & WindowFlags.AutoWidth)
 		{
-			this._width = setAxisSizeIfAuto(window, LayoutDirection.Horizontal, frameSize, padding, 0);
+			this._width = setAxisSizeIfAuto(window, Axis.Horizontal, frameSize, padding, 0);
 		}
 		if (flags & WindowFlags.AutoHeight)
 		{
-			this._height = setAxisSizeIfAuto(window, LayoutDirection.Vertical, frameSize, padding, topBarSize);
+			this._height = setAxisSizeIfAuto(window, Axis.Vertical, frameSize, padding, topBarSize);
 		}
 		Log.debug("BaseWindow.setAutoWindowSize() to", this._width, "x", this._height, ", from size:", Log.stringify(frameSize), ", padding:", Log.stringify(padding), ", flags:", flags);
 	}
@@ -303,4 +303,4 @@ function setWindowPosition(window: WindowDesc, position: WindowPosition): void
 
 	window.x = position.x;
 	window.y = position.y;
-}
+}

src/windows/frames/frameControl.ts

@@ -1,7 +1,7 @@
 import { defaultScale } from "@src/elements/constants";
 import { FlexibleLayoutControl } from "@src/elements/layouts/flexible/flexible";
-import { LayoutDirection } from "@src/elements/layouts/flexible/layoutDirection";
 import { setAbsolutePaddingForDirection, setSizeWithPaddingForDirection, sizeKeys } from "@src/elements/layouts/paddingHelpers";
+import { Axis } from "@src/positional/axis";
 import { parsePadding } from "@src/positional/parsing/parsePadding";
 import { isAbsolute } from "@src/positional/parsing/parsedScale";
 import { Rectangle } from "@src/positional/rectangle";
@@ -51,8 +51,8 @@ export class FrameControl implements FrameContext, ParentControl<FramePosition,
 		const body = this._body;
 		const position = body.position;
 
-		const width = applyFrameScaleOption(area, this.width, position, LayoutDirection.Horizontal);
-		const height = applyFrameScaleOption(area, this.height, position, LayoutDirection.Vertical);
+		const width = applyFrameScaleOption(area, this.width, position, Axis.Horizontal);
+		const height = applyFrameScaleOption(area, this.height, position, Axis.Vertical);
 
 		body.layout(widgets, <Rectangle>area);
 
@@ -99,8 +99,8 @@ export class FrameControl implements FrameContext, ParentControl<FramePosition,
 
 	open(window: Window, widgets: WidgetMap): void
 	{
-		setAxisSizeIfNumber(window, LayoutDirection.Horizontal, this.width);
-		setAxisSizeIfNumber(window, LayoutDirection.Vertical, this.height);
+		setAxisSizeIfNumber(window, Axis.Horizontal, this.width);
+		setAxisSizeIfNumber(window, Axis.Vertical, this.height);
 
 		this._activeWidgets = widgets;
 
@@ -134,7 +134,7 @@ export class FrameControl implements FrameContext, ParentControl<FramePosition,
 /**
  * Applies the frame scale option to the specified area and returns the total occupied space by the frame.
  */
-function applyFrameScaleOption(area: FrameRectangle, option: TabScaleOptions, bodyPosition: ParsedFramePosition, direction: LayoutDirection): number
+function applyFrameScaleOption(area: FrameRectangle, option: TabScaleOptions, bodyPosition: ParsedFramePosition, direction: Axis): number
 {
 	const sizeKey = sizeKeys[direction];
 	const parentSize = area[sizeKey];
@@ -156,4 +156,4 @@ function applyFrameScaleOption(area: FrameRectangle, option: TabScaleOptions, bo
 	// Apply regular padding to area and return original size.
 	setSizeWithPaddingForDirection(<Rectangle>area, direction, bodySize, bodyPadding);
 	return (inheritParent) ? <number>parentSize : bodySize[0];
-}
+}