yoga-layout-python 0.1.0__py3-none-any.whl

yoga/algorithm/FlexDirection.py

@@ -0,0 +1,76 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from __future__ import annotations
+
+from ..debug.AssertFatal import fatalWithMessage
+from ..YGEnums import YGDimension, YGDirection, YGEdge, YGFlexDirection
+
+
+def isRow(flexDirection: YGFlexDirection) -> bool:
+    return flexDirection in (YGFlexDirection.YGFlexDirectionRow, YGFlexDirection.YGFlexDirectionRowReverse)
+
+
+def isColumn(flexDirection: YGFlexDirection) -> bool:
+    return flexDirection in (YGFlexDirection.YGFlexDirectionColumn, YGFlexDirection.YGFlexDirectionColumnReverse)
+
+
+def resolveDirection(flexDirection: YGFlexDirection, direction: YGDirection) -> YGFlexDirection:
+    if direction == YGDirection.YGDirectionRTL:
+        if flexDirection == YGFlexDirection.YGFlexDirectionRow:
+            return YGFlexDirection.YGFlexDirectionRowReverse
+        if flexDirection == YGFlexDirection.YGFlexDirectionRowReverse:
+            return YGFlexDirection.YGFlexDirectionRow
+    return flexDirection
+
+
+def resolveCrossDirection(flexDirection: YGFlexDirection, direction: YGDirection) -> YGFlexDirection:
+    return resolveDirection(YGFlexDirection.YGFlexDirectionRow, direction) if isColumn(flexDirection) else YGFlexDirection.YGFlexDirectionColumn
+
+
+def flexStartEdge(flexDirection: YGFlexDirection) -> YGEdge:
+    if flexDirection == YGFlexDirection.YGFlexDirectionColumn:
+        return YGEdge.YGEdgeTop
+    if flexDirection == YGFlexDirection.YGFlexDirectionColumnReverse:
+        return YGEdge.YGEdgeBottom
+    if flexDirection == YGFlexDirection.YGFlexDirectionRow:
+        return YGEdge.YGEdgeLeft
+    if flexDirection == YGFlexDirection.YGFlexDirectionRowReverse:
+        return YGEdge.YGEdgeRight
+    fatalWithMessage("Invalid FlexDirection")
+
+
+def flexEndEdge(flexDirection: YGFlexDirection) -> YGEdge:
+    if flexDirection == YGFlexDirection.YGFlexDirectionColumn:
+        return YGEdge.YGEdgeBottom
+    if flexDirection == YGFlexDirection.YGFlexDirectionColumnReverse:
+        return YGEdge.YGEdgeTop
+    if flexDirection == YGFlexDirection.YGFlexDirectionRow:
+        return YGEdge.YGEdgeRight
+    if flexDirection == YGFlexDirection.YGFlexDirectionRowReverse:
+        return YGEdge.YGEdgeLeft
+    fatalWithMessage("Invalid FlexDirection")
+
+
+def inlineStartEdge(flexDirection: YGFlexDirection, direction: YGDirection) -> YGEdge:
+    if isRow(flexDirection):
+        return YGEdge.YGEdgeRight if direction == YGDirection.YGDirectionRTL else YGEdge.YGEdgeLeft
+    return YGEdge.YGEdgeTop
+
+
+def inlineEndEdge(flexDirection: YGFlexDirection, direction: YGDirection) -> YGEdge:
+    if isRow(flexDirection):
+        return YGEdge.YGEdgeLeft if direction == YGDirection.YGDirectionRTL else YGEdge.YGEdgeRight
+    return YGEdge.YGEdgeBottom
+
+
+def dimension(flexDirection: YGFlexDirection) -> YGDimension:
+    if flexDirection in (YGFlexDirection.YGFlexDirectionColumn, YGFlexDirection.YGFlexDirectionColumnReverse):
+        return YGDimension.YGDimensionHeight
+    if flexDirection in (YGFlexDirection.YGFlexDirectionRow, YGFlexDirection.YGFlexDirectionRowReverse):
+        return YGDimension.YGDimensionWidth
+    fatalWithMessage("Invalid FlexDirection")

yoga/algorithm/FlexLine.py

@@ -0,0 +1,130 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from ..algorithm.BoundAxis import boundAxisWithinMinAndMax
+from ..algorithm.FlexDirection import resolveDirection
+from ..numeric.FloatMath import float32
+from ..YGEnums import YGDirection, YGDisplay, YGPositionType, YGWrap
+
+
+@dataclass
+class FlexLineRunningLayout:
+    totalFlexGrowFactors: float = 0.0
+    totalFlexShrinkScaledFactors: float = 0.0
+    remainingFreeSpace: float = 0.0
+    mainDim: float = 0.0
+    crossDim: float = 0.0
+
+
+@dataclass
+class FlexLine:
+    itemsInFlow: list = field(default_factory=list)
+    sizeConsumed: float = 0.0
+    numberOfAutoMargins: int = 0
+    layout: FlexLineRunningLayout = field(default_factory=FlexLineRunningLayout)
+
+
+def calculateFlexLine(
+    node,
+    ownerDirection: YGDirection,
+    ownerWidth: float,
+    mainAxisOwnerSize: float,
+    availableInnerWidth: float,
+    availableInnerMainDim: float,
+    children,
+    startIndex: int,
+    lineCount: int,
+) -> FlexLine:
+    itemsInFlow = []
+    sizeConsumed = float32(0.0)
+    totalFlexGrowFactors = 0.0
+    totalFlexShrinkScaledFactors = 0.0
+    numberOfAutoMargins = 0
+    firstElementInLine = None
+    sizeConsumedIncludingMinConstraint = float32(0.0)
+    direction = node.resolveDirection(ownerDirection)
+    mainAxis = resolveDirection(node.style().flexDirection(), direction)
+    isNodeFlexWrap = node.style().flexWrap() != YGWrap.YGWrapNoWrap
+    gap = node.style().computeGapForAxis(mainAxis, availableInnerMainDim)
+
+    for child in children[startIndex:]:
+        if child.style().display() == YGDisplay.YGDisplayNone or child.style().positionType() == YGPositionType.YGPositionTypeAbsolute:
+            continue
+        if firstElementInLine is None:
+            firstElementInLine = child
+        if child.style().flexStartMarginIsAuto(mainAxis, ownerDirection):
+            numberOfAutoMargins += 1
+        if child.style().flexEndMarginIsAuto(mainAxis, ownerDirection):
+            numberOfAutoMargins += 1
+        child.setLineIndex(lineCount)
+        childMarginMainAxis = child.style().computeMarginForAxis(mainAxis, availableInnerWidth)
+        childLeadingGapMainAxis = 0.0 if child == firstElementInLine else gap
+        flexBasisWithMinAndMaxConstraints = boundAxisWithinMinAndMax(
+            child,
+            direction,
+            mainAxis,
+            child.getLayout().computedFlexBasis,
+            mainAxisOwnerSize,
+            ownerWidth,
+        ).unwrap()
+        if (
+            sizeConsumedIncludingMinConstraint
+            + flexBasisWithMinAndMaxConstraints
+            + childMarginMainAxis
+            + childLeadingGapMainAxis
+            > availableInnerMainDim
+            and isNodeFlexWrap
+            and itemsInFlow
+        ):
+            break
+        sizeConsumedIncludingMinConstraint = float32(
+            sizeConsumedIncludingMinConstraint
+            + float32(
+                flexBasisWithMinAndMaxConstraints
+                + childMarginMainAxis
+                + childLeadingGapMainAxis
+            )
+        )
+        sizeConsumed = float32(
+            sizeConsumed
+            + float32(
+                flexBasisWithMinAndMaxConstraints
+                + childMarginMainAxis
+                + childLeadingGapMainAxis
+            )
+        )
+        if child.isNodeFlexible():
+            totalFlexGrowFactors = float32(
+                totalFlexGrowFactors + child.resolveFlexGrow()
+            )
+            totalFlexShrinkScaledFactors = float32(
+                totalFlexShrinkScaledFactors
+                + float32(
+                    -child.resolveFlexShrink()
+                    * child.getLayout().computedFlexBasis.unwrap()
+                )
+            )
+        itemsInFlow.append(child)
+
+    if 0 < totalFlexGrowFactors < 1:
+        totalFlexGrowFactors = 1
+    if 0 < totalFlexShrinkScaledFactors < 1:
+        totalFlexShrinkScaledFactors = 1
+
+    return FlexLine(
+        itemsInFlow=itemsInFlow,
+        sizeConsumed=sizeConsumed,
+        numberOfAutoMargins=numberOfAutoMargins,
+        layout=FlexLineRunningLayout(
+            totalFlexGrowFactors=totalFlexGrowFactors,
+            totalFlexShrinkScaledFactors=totalFlexShrinkScaledFactors,
+        ),
+    )

yoga/algorithm/PixelGrid.py

@@ -0,0 +1,56 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from __future__ import annotations
+
+import math
+
+from ..numeric.Comparison import inexactEquals, isUndefined
+from ..YGEnums import YGDimension, YGEdge, YGNodeType
+from ..YGPixelGrid import YGRoundValueToPixelGrid as roundValueToPixelGrid
+
+
+def roundLayoutResultsToPixelGrid(node, absoluteLeft: float, absoluteTop: float) -> None:
+    pointScaleFactor = float(node.getConfig().getPointScaleFactor())
+    nodeLeft = node.getLayout().position(YGEdge.YGEdgeLeft)
+    nodeTop = node.getLayout().position(YGEdge.YGEdgeTop)
+    nodeWidth = node.getLayout().dimension(YGDimension.YGDimensionWidth)
+    nodeHeight = node.getLayout().dimension(YGDimension.YGDimensionHeight)
+    absoluteNodeLeft = absoluteLeft + nodeLeft
+    absoluteNodeTop = absoluteTop + nodeTop
+    absoluteNodeRight = absoluteNodeLeft + nodeWidth
+    absoluteNodeBottom = absoluteNodeTop + nodeHeight
+    if pointScaleFactor != 0.0:
+        textRounding = node.getNodeType() == YGNodeType.YGNodeTypeText
+        node.setLayoutPosition(roundValueToPixelGrid(nodeLeft, pointScaleFactor, False, textRounding), YGEdge.YGEdgeLeft)
+        node.setLayoutPosition(roundValueToPixelGrid(nodeTop, pointScaleFactor, False, textRounding), YGEdge.YGEdgeTop)
+        if not isUndefined(nodeWidth):
+            scaledNodeWidth = nodeWidth * pointScaleFactor
+            hasFractionalWidth = (
+                not inexactEquals(round(scaledNodeWidth), scaledNodeWidth)
+                if math.isfinite(scaledNodeWidth)
+                else False
+            )
+            node.getLayout().setDimension(
+                YGDimension.YGDimensionWidth,
+                roundValueToPixelGrid(absoluteNodeRight, pointScaleFactor, textRounding and hasFractionalWidth, textRounding and not hasFractionalWidth)
+                - roundValueToPixelGrid(absoluteNodeLeft, pointScaleFactor, False, textRounding),
+            )
+        if not isUndefined(nodeHeight):
+            scaledNodeHeight = nodeHeight * pointScaleFactor
+            hasFractionalHeight = (
+                not inexactEquals(round(scaledNodeHeight), scaledNodeHeight)
+                if math.isfinite(scaledNodeHeight)
+                else False
+            )
+            node.getLayout().setDimension(
+                YGDimension.YGDimensionHeight,
+                roundValueToPixelGrid(absoluteNodeBottom, pointScaleFactor, textRounding and hasFractionalHeight, textRounding and not hasFractionalHeight)
+                - roundValueToPixelGrid(absoluteNodeTop, pointScaleFactor, False, textRounding),
+            )
+    for child in node.getChildren():
+        roundLayoutResultsToPixelGrid(child, absoluteNodeLeft, absoluteNodeTop)

yoga/algorithm/SizingMode.py

@@ -0,0 +1,39 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from ..debug.AssertFatal import fatalWithMessage
+from ..YGEnums import YGMeasureMode
+
+
+class SizingMode(Enum):
+    StretchFit = 0
+    MaxContent = 1
+    FitContent = 2
+
+
+def measureMode(mode: SizingMode) -> YGMeasureMode:
+    if mode == SizingMode.StretchFit:
+        return YGMeasureMode.YGMeasureModeExactly
+    if mode == SizingMode.MaxContent:
+        return YGMeasureMode.YGMeasureModeUndefined
+    if mode == SizingMode.FitContent:
+        return YGMeasureMode.YGMeasureModeAtMost
+    fatalWithMessage("Invalid SizingMode")
+
+
+def sizingMode(mode: YGMeasureMode) -> SizingMode:
+    if mode == YGMeasureMode.YGMeasureModeExactly:
+        return SizingMode.StretchFit
+    if mode == YGMeasureMode.YGMeasureModeUndefined:
+        return SizingMode.MaxContent
+    if mode == YGMeasureMode.YGMeasureModeAtMost:
+        return SizingMode.FitContent
+    fatalWithMessage("Invalid MeasureMode")

yoga/algorithm/TrailingPosition.py

@@ -0,0 +1,34 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from __future__ import annotations
+
+from ..algorithm.FlexDirection import dimension, flexEndEdge, flexStartEdge
+from ..numeric.FloatMath import float32
+from ..YGEnums import YGFlexDirection
+from ..node.Node import Node
+
+
+def getPositionOfOppositeEdge(position: float, axis: YGFlexDirection, containingNode: Node, node: Node) -> float:
+    return float32(
+        float32(
+            float32(containingNode.getLayout().measuredDimension(dimension(axis)))
+            - float32(node.getLayout().measuredDimension(dimension(axis)))
+        )
+        - float32(position)
+    )
+
+
+def setChildTrailingPosition(node: Node, child: Node, axis: YGFlexDirection) -> None:
+    child.setLayoutPosition(
+        getPositionOfOppositeEdge(child.getLayout().position(flexStartEdge(axis)), axis, node, child),
+        flexEndEdge(axis),
+    )
+
+
+def needsTrailingPosition(axis: YGFlexDirection) -> bool:
+    return axis in (YGFlexDirection.YGFlexDirectionRowReverse, YGFlexDirection.YGFlexDirectionColumnReverse)

yoga/algorithm/__init__.py

@@ -0,0 +1,18 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from .AbsoluteLayout import *
+from .Align import *
+from .Baseline import *
+from .BoundAxis import *
+from .Cache import *
+from .CalculateLayout import *
+from .FlexLine import *
+from .FlexDirection import *
+from .PixelGrid import *
+from .SizingMode import *
+from .TrailingPosition import *

yoga/config/Config.py

@@ -0,0 +1,137 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from ..YGEnums import YGErrata, YGExperimentalFeature, YGLogLevel
+
+
+YGLogger = Callable[..., int]
+YGCloneNodeFunc = Callable[..., Any]
+
+
+def _default_logger(*_args: object, **_kwargs: object) -> int:
+    return 0
+
+
+@dataclass
+class Config:
+    cloneNodeCallback_: YGCloneNodeFunc | None = None
+    logger_: YGLogger = _default_logger
+    useWebDefaults_: bool = False
+    version_: int = 0
+    experimentalFeatures_: dict[YGExperimentalFeature, bool] = field(
+        default_factory=dict
+    )
+    errata_: YGErrata = YGErrata.YGErrataNone
+    pointScaleFactor_: float = 1.0
+    context_: Any = None
+
+    def setUseWebDefaults(self, useWebDefaults: bool) -> None:
+        self.useWebDefaults_ = useWebDefaults
+
+    def useWebDefaults(self) -> bool:
+        return self.useWebDefaults_
+
+    def setExperimentalFeatureEnabled(
+        self, feature: YGExperimentalFeature, enabled: bool
+    ) -> None:
+        if self.isExperimentalFeatureEnabled(feature) != enabled:
+            self.experimentalFeatures_[feature] = enabled
+            self.version_ += 1
+
+    def isExperimentalFeatureEnabled(self, feature: YGExperimentalFeature) -> bool:
+        return self.experimentalFeatures_.get(feature, False)
+
+    def getEnabledExperiments(self) -> dict[YGExperimentalFeature, bool]:
+        return dict(self.experimentalFeatures_)
+
+    def setErrata(self, errata: YGErrata) -> None:
+        if self.errata_ != errata:
+            self.errata_ = errata
+            self.version_ += 1
+
+    def addErrata(self, errata: YGErrata) -> None:
+        if not self.hasErrata(errata):
+            self.errata_ |= errata
+            self.version_ += 1
+
+    def removeErrata(self, errata: YGErrata) -> None:
+        if self.hasErrata(errata):
+            self.errata_ &= ~errata
+            self.version_ += 1
+
+    def getErrata(self) -> YGErrata:
+        return self.errata_
+
+    def hasErrata(self, errata: YGErrata) -> bool:
+        return bool(self.errata_ & errata)
+
+    def setPointScaleFactor(self, pointScaleFactor: float) -> None:
+        if self.pointScaleFactor_ != pointScaleFactor:
+            self.pointScaleFactor_ = pointScaleFactor
+            self.version_ += 1
+
+    def getPointScaleFactor(self) -> float:
+        return self.pointScaleFactor_
+
+    def setContext(self, context: Any) -> None:
+        self.context_ = context
+
+    def getContext(self) -> Any:
+        return self.context_
+
+    def getVersion(self) -> int:
+        return self.version_
+
+    def setLogger(self, logger: YGLogger) -> None:
+        self.logger_ = logger
+
+    def log(
+        self,
+        node: object,
+        logLevel: YGLogLevel,
+        format_string: str,
+        args: tuple[object, ...] = (),
+    ) -> int:
+        return self.logger_(self, node, logLevel, format_string, args)
+
+    def setCloneNodeCallback(self, cloneNode: YGCloneNodeFunc | None) -> None:
+        self.cloneNodeCallback_ = cloneNode
+
+    def cloneNode(self, node: object, owner: object, childIndex: int) -> object:
+        clone = None
+        if self.cloneNodeCallback_ is not None:
+            clone = self.cloneNodeCallback_(node, owner, childIndex)
+        if clone is None:
+            from ..YGNode import YGNodeClone
+
+            clone = YGNodeClone(node)
+        return clone
+
+
+_DEFAULT_CONFIG = Config()
+
+
+def configUpdateInvalidatesLayout(oldConfig: Config, newConfig: Config) -> bool:
+    return (
+        oldConfig.getErrata() != newConfig.getErrata()
+        or oldConfig.getPointScaleFactor() != newConfig.getPointScaleFactor()
+        or oldConfig.useWebDefaults() != newConfig.useWebDefaults()
+        or oldConfig.getEnabledExperiments() != newConfig.getEnabledExperiments()
+    )
+
+
+def resolveRef(ref: Config | None) -> Config | None:
+    return ref
+
+
+def getDefaultConfig() -> Config:
+    return _DEFAULT_CONFIG

yoga/config/__init__.py

@@ -0,0 +1,9 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from .Config import *
+

yoga/debug/AssertFatal.py

@@ -0,0 +1,24 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+
+def assertFatal(condition: bool, message: str) -> None:
+    if not condition:
+        raise AssertionError(message)
+
+
+def assertFatalWithConfig(_config, condition: bool, message: str) -> None:
+    assertFatal(condition, message)
+
+
+def assertFatalWithNode(_node, condition: bool, message: str) -> None:
+    assertFatal(condition, message)
+
+
+def fatalWithMessage(message: str) -> None:
+    raise RuntimeError(message)
+

yoga/debug/Log.py

@@ -0,0 +1,49 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..YGEnums import YGLogLevel
+
+
+def getDefaultLogger():
+    """Get the default logger that does nothing."""
+    def _logger(*_args: object, **_kwargs: object) -> int:
+        return 0
+    return _logger
+
+
+def log(node: Any | None, level: YGLogLevel, format_string: str, *args: object) -> int:
+    """
+    Log a message at the given level.
+
+    Args:
+        node: The yoga node (can be None)
+        level: The log level
+        format_string: The format string
+        *args: Arguments to format into the string
+    """
+    if node is None:
+        # Log without node
+        logger = getDefaultLogger()
+        return logger(None, None, level, format_string, args)
+
+    config = node.getConfig() if node is not None else None
+    logger = config.logger_ if config is not None else getDefaultLogger()
+    return logger(config, node, level, format_string, args)
+
+
+def logWithConfig(config: Any | None, level: YGLogLevel, format_string: str, *args: object) -> int:
+    """Log a message with a config but no node."""
+    if config is None:
+        logger = getDefaultLogger()
+        return logger(None, None, level, format_string, args)
+    logger = config.logger_ if hasattr(config, 'logger_') else getDefaultLogger()
+    return logger(config, None, level, format_string, args)
+

yoga/debug/__init__.py

@@ -0,0 +1,10 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from .AssertFatal import *
+from .Log import *
+

yoga/event/__init__.py

@@ -0,0 +1,9 @@
+"""
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+from .event import *
+