@number10/phaserjsx 0.1.0

package/dist/layout/strategies/column-layout.d.ts

@@ -0,0 +1,38 @@
+import { LayoutChild, LayoutContext, LayoutLine, Position } from '../types';
+import { ContentMetrics } from '../utils/dimension-calculator';
+import { BaseLayoutStrategy } from './base-strategy';
+/**
+ * Column layout strategy - stacks children vertically
+ */
+export declare class ColumnLayoutStrategy extends BaseLayoutStrategy {
+    /**
+     * Calculate content dimensions for column layout
+     * For flex children, uses a minimum default size to avoid chicken-egg sizing issues
+     * @param children - Array of layout children
+     * @param context - Layout context
+     * @returns Content metrics
+     */
+    calculateMetrics(children: LayoutChild[], _context: LayoutContext): ContentMetrics;
+    /**
+     * Position a child in column layout
+     * @param child - Layout child
+     * @param _index - Child index (unused for column layout)
+     * @param context - Layout context
+     * @param currentMain - Current Y position
+     * @returns Position and next main axis value
+     */
+    positionChild(child: LayoutChild, _index: number, context: LayoutContext, currentMain: number): {
+        position: Position;
+        nextMain: number;
+    };
+    /**
+     * Wrap children into lines based on available height
+     * Used when flexWrap is 'wrap' or 'wrap-reverse'
+     * @param children - Layout children to wrap
+     * @param availableHeight - Available height for each line
+     * @param gap - Gap between children
+     * @returns Array of layout lines
+     */
+    wrapChildren(children: LayoutChild[], availableHeight: number, gap: number): LayoutLine[];
+}
+//# sourceMappingURL=column-layout.d.ts.map

package/dist/layout/strategies/column-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-layout.d.ts","sourceRoot":"","sources":["../../../src/layout/strategies/column-layout.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAEpD;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,kBAAkB;IAC1D;;;;;;OAMG;IACH,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,QAAQ,EAAE,aAAa,GAAG,cAAc;IA4BlF;;;;;;;OAOG;IACH,aAAa,CACX,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,MAAM,GAClB;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;IA2D3C;;;;;;;OAOG;IACH,YAAY,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,eAAe,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,EAAE;CAoE1F"}

package/dist/layout/strategies/row-layout.d.ts

@@ -0,0 +1,38 @@
+import { LayoutChild, LayoutContext, LayoutLine, Position } from '../types';
+import { ContentMetrics } from '../utils/dimension-calculator';
+import { BaseLayoutStrategy } from './base-strategy';
+/**
+ * Row layout strategy - stacks children horizontally
+ */
+export declare class RowLayoutStrategy extends BaseLayoutStrategy {
+    /**
+     * Calculate content dimensions for row layout
+     * For flex children, uses a minimum default size to avoid chicken-egg sizing issues
+     * @param children - Array of layout children
+     * @param context - Layout context
+     * @returns Content metrics
+     */
+    calculateMetrics(children: LayoutChild[], _context: LayoutContext): ContentMetrics;
+    /**
+     * Position a child in row layout
+     * @param child - Layout child
+     * @param _index - Child index (unused for row layout)
+     * @param context - Layout context
+     * @param currentMain - Current X position
+     * @returns Position and next main axis value
+     */
+    positionChild(child: LayoutChild, _index: number, context: LayoutContext, currentMain: number): {
+        position: Position;
+        nextMain: number;
+    };
+    /**
+     * Wrap children into lines based on available width
+     * Used when flexWrap is 'wrap' or 'wrap-reverse'
+     * @param children - Layout children to wrap
+     * @param availableWidth - Available width for each line
+     * @param gap - Gap between children
+     * @returns Array of layout lines
+     */
+    wrapChildren(children: LayoutChild[], availableWidth: number, gap: number): LayoutLine[];
+}
+//# sourceMappingURL=row-layout.d.ts.map

package/dist/layout/strategies/row-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-layout.d.ts","sourceRoot":"","sources":["../../../src/layout/strategies/row-layout.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAEpD;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,kBAAkB;IACvD;;;;;;OAMG;IACH,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,QAAQ,EAAE,aAAa,GAAG,cAAc;IA4BlF;;;;;;;OAOG;IACH,aAAa,CACX,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,MAAM,GAClB;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;IA0D3C;;;;;;;OAOG;IACH,YAAY,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,EAAE;CAoEzF"}

package/dist/layout/strategies/stack-layout.d.ts

@@ -0,0 +1,30 @@
+import { LayoutChild, LayoutContext, Position } from '../types';
+import { ContentMetrics } from '../utils/dimension-calculator';
+import { BaseLayoutStrategy } from './base-strategy';
+/**
+ * Stack layout strategy - overlays all children at the same position
+ */
+export declare class StackLayoutStrategy extends BaseLayoutStrategy {
+    /**
+     * Calculate content dimensions for stack layout
+     * For stack, we track max dimensions as children overlay
+     * @param children - Array of layout children
+     * @param context - Layout context
+     * @returns Content metrics
+     */
+    calculateMetrics(children: LayoutChild[], _context: LayoutContext): ContentMetrics;
+    /**
+     * Position a child in stack layout
+     * All children positioned at same location, aligned via alignItems
+     * @param child - Layout child
+     * @param _index - Child index (unused for stack layout)
+     * @param context - Layout context
+     * @param currentMain - Current position (unused for stack)
+     * @returns Position and unchanged currentMain
+     */
+    positionChild(child: LayoutChild, _index: number, context: LayoutContext, currentMain: number): {
+        position: Position;
+        nextMain: number;
+    };
+}
+//# sourceMappingURL=stack-layout.d.ts.map

package/dist/layout/strategies/stack-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-layout.d.ts","sourceRoot":"","sources":["../../../src/layout/strategies/stack-layout.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAEpD;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,kBAAkB;IACzD;;;;;;OAMG;IACH,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,QAAQ,EAAE,aAAa,GAAG,cAAc;IAiBlF;;;;;;;;OAQG;IACH,aAAa,CACX,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,MAAM,GAClB;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;CAgD5C"}

package/dist/layout/types.d.ts

@@ -0,0 +1,137 @@
+import { default as Phaser } from 'phaser';
+import { BackgroundProps, EdgeInsets, LayoutProps, TransformProps } from '../core-props';
+/**
+ * Size information for layout calculations
+ */
+export interface LayoutSize {
+    width: number;
+    height: number;
+}
+/**
+ * Interface for nodes that can provide their layout dimensions dynamically
+ */
+export interface LayoutSizeProvider {
+    /**
+     * Get the layout size of this node
+     * This can be computed dynamically (e.g., from text bounds, children, etc.)
+     * or return fixed dimensions
+     * @returns Width and height for layout calculations
+     */
+    __getLayoutSize: () => LayoutSize;
+}
+/**
+ * Extended GameObject with layout metadata
+ */
+export type GameObjectWithLayout = Phaser.GameObjects.GameObject & {
+    __layoutProps?: LayoutProps & BackgroundProps & TransformProps;
+    __isBackground?: boolean;
+    __background?: Phaser.GameObjects.Graphics;
+    __getLayoutSize?: () => LayoutSize;
+    __cachedLayoutSize?: LayoutSize;
+    __originalGetLayoutSize?: () => LayoutSize;
+    visible?: boolean;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    setPosition?: (x: number, y: number) => void;
+};
+/**
+ * Prepared child data for layout calculations
+ */
+export interface LayoutChild {
+    child: GameObjectWithLayout;
+    size: LayoutSize;
+    margin: EdgeInsets;
+}
+/**
+ * A line of children in a wrapped flex layout
+ */
+export interface LayoutLine {
+    children: LayoutChild[];
+    mainAxisSize: number;
+    crossAxisSize: number;
+}
+/**
+ * Computed padding values
+ */
+export interface PaddingValues {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * Position for a child element
+ */
+export interface Position {
+    x: number;
+    y: number;
+}
+/**
+ * Content area dimensions (container minus padding)
+ */
+export interface ContentArea {
+    width: number;
+    height: number;
+}
+/**
+ * Parsed size representation
+ */
+export interface ParsedSize {
+    /** Size type: fixed pixels, percentage of parent, viewport units (vw/vh), auto (content-based), calc expression, or fill (parent content-area) */
+    type: 'fixed' | 'percent' | 'vw' | 'vh' | 'auto' | 'calc' | 'fill';
+    /** Numeric value - pixels for fixed, 0-100 for percent, 0-100 for vw/vh, undefined for auto/calc/fill */
+    value?: number;
+    /** Calc expression data (only for type='calc') */
+    calc?: CalcExpression;
+}
+/**
+ * Calc expression representation
+ * Supports: calc(50% - 20px), calc(100vw - 40px), calc(100vh + 10px), calc((50% + 10px) * 2), etc.
+ */
+export interface CalcExpression {
+    /** Left operand or sub-expression */
+    left: CalcOperand | CalcExpression;
+    /** Operator: +, -, *, / */
+    operator: '+' | '-' | '*' | '/';
+    /** Right operand or sub-expression */
+    right: CalcOperand | CalcExpression;
+}
+/**
+ * Calc operand - can be fixed pixels, percentage, or viewport units
+ */
+export interface CalcOperand {
+    /** Operand type */
+    type: 'fixed' | 'percent' | 'vw' | 'vh';
+    /** Numeric value */
+    value: number;
+}
+/**
+ * Computed metrics from children analysis
+ * Note: maxWidth/maxHeight here are resolved pixel values, not SizeValue types
+ */
+export interface ContentMetrics {
+    maxWidth: number;
+    maxHeight: number;
+    totalMainSize: number;
+}
+/**
+ * Complete layout context passed to strategies
+ */
+export interface LayoutContext {
+    containerProps: LayoutProps;
+    padding: PaddingValues;
+    contentArea: ContentArea;
+    gap: {
+        horizontal: number;
+        vertical: number;
+    };
+    children: LayoutChild[];
+    /** Parent dimensions for percentage resolution */
+    parentSize?: {
+        width: number;
+        height: number;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/layout/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/layout/types.ts"],"names":[],"mappings":"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"}

package/dist/layout/utils/child-utils.d.ts

@@ -0,0 +1,74 @@
+import { default as Phaser } from 'phaser';
+import { EdgeInsets, LayoutProps } from '../../core-props';
+import { GameObjectWithLayout, LayoutChild, LayoutSize } from '../types';
+/**
+ * Check if a child should participate in layout calculations
+ * Headless objects participate in layout (for alignment) but report size 0
+ * @param child - Child game object
+ * @returns True if child should be included in layout
+ */
+export declare function isLayoutChild(child: GameObjectWithLayout): boolean;
+/**
+ * Get effective margin for a child
+ * Normalizes margin to EdgeInsets (supports number for all sides)
+ * Headless objects have no margin (positioned as point)
+ * @param child - Child game object
+ * @returns Edge insets
+ */
+export declare function getMargin(child: GameObjectWithLayout): EdgeInsets;
+/**
+ * Get effective size of a child
+ * Calls __getLayoutSize if available, otherwise falls back to layoutProps or default
+ * Note: String sizes (percentages) are resolved later with parent context
+ * @param child - Child game object
+ * @param parentSize - Optional parent dimensions for percentage resolution
+ * @param parentPadding - Optional parent padding for 'fill' resolution
+ * @returns Width and height in pixels
+ */
+export declare function getChildSize(child: GameObjectWithLayout, parentSize?: {
+    width: number;
+    height: number;
+}, parentPadding?: {
+    horizontal: number;
+    vertical: number;
+}): LayoutSize;
+/**
+ * Process a child container by recursively calculating its layout
+ * @param child - Child game object to process
+ * @param calculateLayoutFn - Layout calculation function (passed to avoid circular dependency)
+ * @param parentSize - Optional parent dimensions for percentage resolution
+ * @param parentPadding - Optional parent padding for 'fill' resolution
+ */
+export declare function processNestedContainer(child: GameObjectWithLayout, calculateLayoutFn: (container: Phaser.GameObjects.Container, props: LayoutProps, parentSize?: {
+    width: number;
+    height: number;
+}, parentPadding?: {
+    horizontal: number;
+    vertical: number;
+}) => void, parentSize?: {
+    width: number;
+    height: number;
+}, parentPadding?: {
+    horizontal: number;
+    vertical: number;
+}): void;
+/**
+ * Filter and prepare children for layout calculations
+ * Skips background elements and processes nested containers
+ * @param children - Raw children from container
+ * @param calculateLayoutFn - Layout calculation function for nested containers
+ * @returns Prepared layout children with size and margin data
+ */
+export declare function prepareLayoutChildren(children: GameObjectWithLayout[], calculateLayoutFn: (container: Phaser.GameObjects.Container, props: LayoutProps) => void): LayoutChild[];
+/**
+ * Extract margin values with defaults
+ * @param margin - Edge insets
+ * @returns Individual margin values
+ */
+export declare function extractMarginValues(margin: EdgeInsets): {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+//# sourceMappingURL=child-utils.d.ts.map

package/dist/layout/utils/child-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-utils.d.ts","sourceRoot":"","sources":["../../../src/layout/utils/child-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAChC,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAG7E;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAelE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,oBAAoB,GAAG,UAAU,CAMjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,oBAAoB,EAC3B,UAAU,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC9C,aAAa,CAAC,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACvD,UAAU,CA6GZ;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,oBAAoB,EAC3B,iBAAiB,EAAE,CACjB,SAAS,EAAE,MAAM,CAAC,WAAW,CAAC,SAAS,EACvC,KAAK,EAAE,WAAW,EAClB,UAAU,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC9C,aAAa,CAAC,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,KACrD,IAAI,EACT,UAAU,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC9C,aAAa,CAAC,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACvD,IAAI,CAWN;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,oBAAoB,EAAE,EAChC,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,GACvF,WAAW,EAAE,CAoBf;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU;;;;;EAOrD"}

package/dist/layout/utils/dimension-calculator.d.ts

@@ -0,0 +1,59 @@
+import { EdgeInsets, LayoutProps } from '../../core-props';
+import { LayoutChild } from '../types';
+/**
+ * Content dimension metrics
+ */
+export interface ContentMetrics {
+    maxWidth: number;
+    maxHeight: number;
+    totalMainSize: number;
+}
+/**
+ * Padding values (normalized)
+ */
+export interface PaddingValues {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+/**
+ * Calculate content dimensions based on children and layout direction
+ * For flex children, uses a minimum default size to avoid chicken-egg sizing issues
+ * @param children - Array of layout children with size and margin info
+ * @param direction - Layout direction ('row', 'column', or 'stack')
+ * @returns Content metrics including max dimensions and total main axis size
+ */
+export declare function calculateContentDimensions(children: LayoutChild[], direction: 'row' | 'column' | 'stack'): ContentMetrics;
+/**
+ * Calculate final container dimensions
+ * @param props - Layout properties
+ * @param metrics - Content metrics from calculateContentDimensions
+ * @param padding - Normalized padding values
+ * @param direction - Layout direction
+ * @param gap - Gap between children (horizontal and vertical)
+ * @param childCount - Number of children
+ * @param parentSize - Parent dimensions for percentage resolution
+ * @param parentPadding - Parent padding for 'fill' resolution
+ * @returns Container width and height in pixels
+ */
+export declare function calculateContainerSize(props: LayoutProps, metrics: ContentMetrics, padding: PaddingValues, direction: 'row' | 'column' | 'stack', gap: {
+    horizontal: number;
+    vertical: number;
+}, childCount: number, parentSize?: {
+    width: number;
+    height: number;
+}, parentPadding?: {
+    horizontal: number;
+    vertical: number;
+}): {
+    width: number;
+    height: number;
+};
+/**
+ * Normalize padding from EdgeInsets or number to PaddingValues
+ * @param padding - Edge insets (may be undefined, partial, or a single number for all sides)
+ * @returns Normalized padding with all values defined
+ */
+export declare function normalizePadding(padding?: number | EdgeInsets): PaddingValues;
+//# sourceMappingURL=dimension-calculator.d.ts.map

package/dist/layout/utils/dimension-calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimension-calculator.d.ts","sourceRoot":"","sources":["../../../src/layout/utils/dimension-calculator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAG3C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,WAAW,EAAE,EACvB,SAAS,EAAE,KAAK,GAAG,QAAQ,GAAG,OAAO,GACpC,cAAc,CAmChB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,KAAK,GAAG,QAAQ,GAAG,OAAO,EACrC,GAAG,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC7C,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC9C,aAAa,CAAC,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAgDnC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,aAAa,CAe7E"}

package/dist/layout/utils/flex-distributor.d.ts

@@ -0,0 +1,18 @@
+import { LayoutChild } from '../types';
+/**
+ * Calculate flex distribution for children
+ * Implements flexbox algorithm with grow, shrink, and basis support
+ * Respects min/max constraints during distribution
+ * @param children - Layout children
+ * @param availableSpace - Total available space on main axis
+ * @param direction - Layout direction ('row' or 'column')
+ * @returns Updated children with flex sizes resolved
+ */
+export declare function distributeFlexSpace(children: LayoutChild[], availableSpace: number, direction: 'row' | 'column' | 'stack'): LayoutChild[];
+/**
+ * Check if any children have flex properties (flex, flexShrink, or flexBasis)
+ * @param children - Layout children
+ * @returns True if at least one child participates in flexbox
+ */
+export declare function hasFlexChildren(children: LayoutChild[]): boolean;
+//# sourceMappingURL=flex-distributor.d.ts.map

package/dist/layout/utils/flex-distributor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flex-distributor.d.ts","sourceRoot":"","sources":["../../../src/layout/utils/flex-distributor.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAkB3C;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,WAAW,EAAE,EACvB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,KAAK,GAAG,QAAQ,GAAG,OAAO,GACpC,WAAW,EAAE,CAiIf;AAiID;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAShE"}

package/dist/layout/utils/size-resolver.d.ts

@@ -0,0 +1,84 @@
+import { ParsedSize } from '../types';
+export type { ParsedSize } from '../types';
+/**
+ * Parse a size value into its components
+ * Results are cached to avoid repeated string parsing during layout calculations
+ * @param size - Size value (number, string, or undefined)
+ * @returns Parsed size information
+ * @throws Error if string format is invalid
+ *
+ * @example
+ * parseSize(100)                    // { type: 'fixed', value: 100 }
+ * parseSize('50%')                  // { type: 'percent', value: 50 }
+ * parseSize('calc(100% - 40px)')    // { type: 'calc', calc: {...} }
+ * parseSize(undefined)              // { type: 'auto' }
+ * parseSize('auto')                 // { type: 'auto' }
+ */
+export declare function parseSize(size: number | string | undefined): ParsedSize;
+/**
+ * Resolve a parsed size to actual pixel value
+ * @param parsed - Parsed size information
+ * @param parentSize - Parent dimension in pixels (required for percentage and calc)
+ * @param contentSize - Content dimension in pixels (fallback for auto)
+ * @param parentPadding - Parent padding in the relevant direction (for fill)
+ * @param viewportSize - Viewport dimensions for vw/vh resolution
+ * @returns Resolved size in pixels
+ *
+ * @example
+ * resolveSize({ type: 'fixed', value: 100 }, 200)                    // 100
+ * resolveSize({ type: 'percent', value: 50 }, 200)                   // 100 (50% of 200)
+ * resolveSize({ type: 'vw', value: 100 }, undefined, undefined, undefined, viewport) // viewport.width
+ * resolveSize({ type: 'vh', value: 50 }, undefined, undefined, undefined, viewport)  // viewport.height * 0.5
+ * resolveSize({ type: 'calc', calc: {...} }, 200)                    // calc result
+ * resolveSize({ type: 'auto' }, 200, 150)                            // 150 (content size)
+ * resolveSize({ type: 'fill' }, 200, undefined, 40)                  // 160 (200 - 40)
+ */
+export declare function resolveSize(parsed: ParsedSize, parentSize?: number, contentSize?: number, parentPadding?: number, viewportSize?: {
+    width: number;
+    height: number;
+}): number;
+/**
+ * Clear the parseSize cache and warning deduplication set
+ * Useful for testing or memory management in long-running applications
+ *
+ * @example
+ * ```typescript
+ * // Clear caches after major UI rebuild
+ * clearSizeCaches()
+ * ```
+ */
+export declare function clearSizeCaches(): void;
+/**
+ * Check if a size needs parent context to resolve
+ * @param parsed - Parsed size information
+ * @returns True if size requires parent dimension
+ */
+export declare function requiresParent(parsed: ParsedSize): boolean;
+/**
+ * Check if a size can be determined without content measurement
+ * @param parsed - Parsed size information
+ * @returns True if size is explicitly defined (not auto)
+ */
+export declare function isExplicit(parsed: ParsedSize): boolean;
+/**
+ * Clamp a size value to min/max constraints
+ * Min/max constraints can be SizeValue (pixels, percentage, viewport units, calc)
+ * They are resolved relative to the same parent/viewport context as the size itself
+ *
+ * @param size - Resolved size in pixels
+ * @param minSize - Minimum size constraint (SizeValue or undefined = no constraint)
+ * @param maxSize - Maximum size constraint (SizeValue or undefined = no constraint)
+ * @param parentSize - Parent dimension for percentage resolution in constraints
+ * @param fallbackSize - Fallback size for auto constraints (not typically used for min/max)
+ * @param parentPadding - Parent padding for fill constraints (not typically used for min/max)
+ * @returns Clamped size in pixels
+ *
+ * @example
+ * clampSize(150, 100, 200)  // 150 (within bounds)
+ * clampSize(50, 100, 200)   // 100 (clamped to min)
+ * clampSize(300, 100, 200)  // 200 (clamped to max)
+ * clampSize(150, undefined, "80%", 1000)  // 150 (max = 800px)
+ * clampSize(1000, undefined, "80%", 1000) // 800 (clamped to 80% of parent)
+ */
+export declare function clampSize(size: number, minSize?: number | string, maxSize?: number | string, parentSize?: number, fallbackSize?: number, parentPadding?: number): number;
+//# sourceMappingURL=size-resolver.d.ts.map

package/dist/layout/utils/size-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"size-resolver.d.ts","sourceRoot":"","sources":["../../../src/layout/utils/size-resolver.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAA+B,UAAU,EAAE,MAAM,UAAU,CAAA;AAGvE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAmH1C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,CAiBvE;AA8JD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,UAAU,EAClB,UAAU,CAAC,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,MAAM,EACtB,YAAY,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC/C,MAAM,CAuER;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAGtC;AAkBD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAW1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAStD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EACzB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EACzB,UAAU,CAAC,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,CAsBR"}

package/dist/layout/utils/spacing-calculator.d.ts

@@ -0,0 +1,27 @@
+import { LayoutProps } from '../../core-props';
+/**
+ * Justify content calculation result
+ */
+export interface JustifyResult {
+    mainStart: number;
+    spaceBetween: number;
+}
+/**
+ * Calculate main axis starting position and spacing between children
+ * @param justifyContent - Justify content value
+ * @param remainingSpace - Space remaining after children are placed
+ * @param childCount - Number of children
+ * @returns Main axis starting offset and spacing between children
+ */
+export declare function calculateJustifyContent(justifyContent: LayoutProps['justifyContent'], remainingSpace: number, childCount: number): JustifyResult;
+/**
+ * Calculate cross axis position for a child
+ * @param alignItems - Align items value
+ * @param contentArea - Available space on cross axis
+ * @param childSize - Size of child on cross axis
+ * @param marginStart - Margin at start of cross axis (top for row, left for column)
+ * @param marginEnd - Margin at end of cross axis (bottom for row, right for column)
+ * @returns Cross axis position
+ */
+export declare function calculateAlignItems(alignItems: LayoutProps['alignItems'], contentArea: number, childSize: number, marginStart: number, marginEnd: number): number;
+//# sourceMappingURL=spacing-calculator.d.ts.map

package/dist/layout/utils/spacing-calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spacing-calculator.d.ts","sourceRoot":"","sources":["../../../src/layout/utils/spacing-calculator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,WAAW,CAAC,gBAAgB,CAAC,EAC7C,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,GACjB,aAAa,CAiCf;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,WAAW,CAAC,YAAY,CAAC,EACrC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,MAAM,CAcR"}

package/dist/memo.d.ts

@@ -0,0 +1,29 @@
+import { VNode } from './hooks';
+/**
+ * Marks a component to skip memoization (always re-render on prop changes)
+ * Use when component has side effects or needs to re-render every time
+ *
+ * @example
+ * ```tsx
+ * function AlwaysUpdate({ value }) {
+ *   console.log('Rendering with:', value)
+ *   return <Text text={value} />
+ * }
+ *
+ * // Disable memoization
+ * <AlwaysUpdate value={counter} __memo={false} />
+ * ```
+ *
+ * @param vnode - VNode to mark
+ * @returns Same VNode with memoization disabled (may be a copy if frozen)
+ */
+export declare function noMemo<T extends VNode>(vnode: T): T;
+/**
+ * Explicitly enable memoization for a component (default behavior)
+ * This is the default - you don't need to call this unless you want to be explicit
+ *
+ * @param vnode - VNode to mark
+ * @returns Same VNode with memoization enabled (may be a copy if frozen)
+ */
+export declare function memo<T extends VNode>(vnode: T): T;
+//# sourceMappingURL=memo.d.ts.map

package/dist/memo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memo.d.ts","sourceRoot":"","sources":["../src/memo.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAiBpC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEjD"}

package/dist/portal/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Portal exports
+ */
+export { portalRegistry } from './portal-registry';
+export type { PortalTree } from './portal-types';
+//# sourceMappingURL=index.d.ts.map

package/dist/portal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/portal/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA"}