@pixi-ui-editor/runtime-pixi 0.14.0 → 0.16.0

package/dist/transformSpace.d.ts

@@ -0,0 +1,119 @@
+import { type LayoutProfileId, type UINode } from "@pixi-ui-editor/schema";
+import { type LayoutSize } from "./layout.js";
+export type AffineTransform = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    tx: number;
+    ty: number;
+};
+/** Viewport pair a scene carries; a prefab being edited on its own has none. */
+export type NodeHierarchyLayout = {
+    readonly referenceViewports: Record<LayoutProfileId, LayoutSize>;
+    readonly preferredViewports: Record<LayoutProfileId, LayoutSize>;
+};
+/**
+ * Любая иерархия авторинга, по которой резолвятся родители. Владелец обязан отдавать индекс, а не
+ * список: линейный поиск родителя делал обход всей иерархии квадратичным.
+ */
+export type NodeHierarchy = {
+    readonly nodesById: ReadonlyMap<string, UINode>;
+    readonly layout?: NodeHierarchyLayout;
+};
+/** Подстановка для иерархии без собственного viewport: якорные слагаемые обнуляются. */
+export declare const NO_PARENT_LAYOUT_SIZE: LayoutSize;
+export declare const IDENTITY_TRANSFORM: AffineTransform;
+/** Единственный индекс id → узел. */
+export declare function indexNodesById(nodes: readonly UINode[]): ReadonlyMap<string, UINode>;
+/** Оборачивает сырого владельца узлов (сцену, пресет) в форму, которую принимают helpers иерархии. */
+export declare function indexNodes(owner: {
+    readonly nodes: readonly UINode[];
+    readonly layout?: NodeHierarchyLayout;
+}): NodeHierarchy;
+export declare function multiplyAffine(left: AffineTransform, right: AffineTransform): AffineTransform;
+export declare function invertAffine(matrix: AffineTransform): AffineTransform | undefined;
+/** Матрица одного узла в системе координат его родителя — ровно то, что строит Pixi из transform. */
+export declare function localTransformMatrix(transform: UINode["transform"]): AffineTransform;
+/** Converts a point in scene coordinates into coordinates local to a parent's world matrix. */
+export declare function worldPointToLocal(parentWorldMatrix: AffineTransform | undefined, point: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+} | undefined;
+/**
+ * Converts a world matrix to a schema transform relative to a new parent.
+ * Undefined means the result needs skew (or an inverse of a zero-scale parent), neither of which
+ * the current document format can represent without changing the rendered object.
+ */
+export declare function transformRelativeToParent(worldMatrix: AffineTransform, parentWorldMatrix: AffineTransform | undefined, source: UINode["transform"]): UINode["transform"] | undefined;
+/**
+ * Resolves the rectangle that Yoga gives a direct GridLayout child. The authored x/y, anchors and
+ * size do not participate while the child is in the grid, so hierarchy reparenting must preserve
+ * this managed rectangle rather than the dormant authored transform.
+ */
+export declare function resolveGridManagedTransform(node: UINode, parent: Extract<UINode, {
+    type: "grid-layout";
+}>, profile: LayoutProfileId, parentSize: LayoutSize): UINode["transform"];
+/**
+ * Снимок системы координат одной иерархии в одном layout-профиле: мировые матрицы, отрисованные
+ * прямоугольники и перенос узла к другому родителю без визуального сдвига.
+ *
+ * Экземпляр кэширует всё, что посчитал, поэтому он действителен ровно до следующей мутации узлов —
+ * после правки документа создавайте новый. Это единственная реализация: и редактор, и рантайм
+ * обязаны считать репарент здесь, иначе картинки разъедутся.
+ */
+export declare class NodeTransformSpace {
+    #private;
+    constructor(hierarchy: NodeHierarchy, profile: LayoutProfileId);
+    /** Snapshot for the same hierarchy in another profile; каждый профиль кэшируется отдельно. */
+    static forOwner(owner: {
+        readonly nodes: readonly UINode[];
+        readonly layout?: NodeHierarchyLayout;
+    }, profile: LayoutProfileId): NodeTransformSpace;
+    get profile(): LayoutProfileId;
+    /** Логический RectTransform-размер Canvas; `undefined` у иерархии без собственного viewport. */
+    get canvasSize(): LayoutSize | undefined;
+    /** Matrix of the Unity-like scaled Canvas that owns top-level nodes. */
+    getOwnerWorldMatrix(): AffineTransform | undefined;
+    /** Returns the node rectangle that is actually rendered, including a layout parent's managed cell. */
+    getRenderedTransform(nodeId: string): UINode["transform"] | undefined;
+    /** Returns the same world matrix Pixi builds from the serialized parent chain. */
+    getWorldMatrix(nodeId: string): AffineTransform | undefined;
+    /** Scene-space point converted into the coordinates of `parentId`'s children. */
+    worldPointToLocal(parentId: string | null, point: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    } | undefined;
+    /**
+     * Логический размер, относительно которого разрешается anchoredPosition узла.
+     *
+     * Узел может быть черновиком мутации (его ещё нет в иерархии) — тогда берётся его собственный
+     * parentId. `undefined` означает «у иерархии нет своего viewport» (редактируемый пресет): это не
+     * то же самое, что нулевой размер, `resolveAnchoredTransform` в этом случае не трогает transform.
+     */
+    getParentLayoutSize(node: UINode): LayoutSize | undefined;
+    /**
+     * Размер, который получает ЛЮБОЙ прямой ребёнок узла `parentId` (null — корень иерархии).
+     * Именно его требует перенос: якорные слагаемые ребёнка должны сниматься с размера будущего
+     * родителя, а не текущего.
+     */
+    getChildLayoutSize(parentId: string | null): LayoutSize | undefined;
+    /**
+     * Transform, который сохраняет узел на экране после переноса под `newParentId` — то, что нужно
+     * записать в документ. `undefined`, если сохранить картинку нельзя: перенос потребовал бы skew
+     * либо родитель невырожденно не обращается (нулевой масштаб).
+     */
+    getReparentedTransform(nodeId: string, newParentId: string | null): UINode["transform"] | undefined;
+}
+/**
+ * Разовый запрос размера родителя без явного снимка: удобен на единичных вызовах.
+ * В цикле по узлам создавайте один `NodeTransformSpace` — он переиспользует кэши.
+ */
+export declare function getParentLayoutSize(hierarchy: NodeHierarchy, node: UINode, profile: LayoutProfileId): LayoutSize | undefined;
+//# sourceMappingURL=transformSpace.d.ts.map

package/dist/transformSpace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformSpace.d.ts","sourceRoot":"","sources":["../src/transformSpace.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EAEpB,KAAK,MAAM,EACZ,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAA2F,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAGvI,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,gFAAgF;AAChF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;IACjE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;CAClE,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC;CACvC,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,qBAAqB,EAAE,UAAoC,CAAC;AAEzE,eAAO,MAAM,kBAAkB,EAAE,eAA0D,CAAC;AAI5F,qCAAqC;AACrC,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAEpF;AAED,sGAAsG;AACtG,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAA;CAAE,GAAG,aAAa,CAI7H;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,GAAG,eAAe,CAS7F;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,GAAG,SAAS,CAYjF;AAED,qGAAqG;AACrG,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,CAAC,WAAW,CAAC,GAAG,eAAe,CAWpF;AAED,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAC/B,iBAAiB,EAAE,eAAe,GAAG,SAAS,EAC9C,KAAK,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAOtC;AAMD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,eAAe,EAC5B,iBAAiB,EAAE,eAAe,GAAG,SAAS,EAC9C,MAAM,EAAE,MAAM,CAAC,WAAW,CAAC,GAC1B,MAAM,CAAC,WAAW,CAAC,GAAG,SAAS,CA6BjC;AAoDD;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,EAChD,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,UAAU,GACrB,MAAM,CAAC,WAAW,CAAC,CAmDrB;AAiGD;;;;;;;GAOG;AACH,qBAAa,kBAAkB;;IAU7B,YAAY,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,EAO7D;IAED,8FAA8F;IAC9F,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAA;KAAE,EAAE,OAAO,EAAE,eAAe,GAAG,kBAAkB,CAEjJ;IAED,IAAI,OAAO,IAAI,eAAe,CAE7B;IAED,gGAAgG;IAChG,IAAI,UAAU,IAAI,UAAU,GAAG,SAAS,CAEvC;IAED,wEAAwE;IACxE,mBAAmB,IAAI,eAAe,GAAG,SAAS,CAEjD;IAED,sGAAsG;IACtG,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,SAAS,CAEpE;IAED,kFAAkF;IAClF,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAE1D;IAED,iFAAiF;IACjF,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAEhH;IAED;;;;;;OAMG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAExD;IAED;;;;OAIG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,UAAU,GAAG,SAAS,CAMlE;IAED;;;;OAIG;IACH,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,SAAS,CA6BlG;CA2EF;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,UAAU,GAAG,SAAS,CAE5H"}

package/dist/transformSpace.js

@@ -0,0 +1,487 @@
+import { resolveLayoutGroupSettings, } from "@pixi-ui-editor/schema";
+import { getCanvasLogicalSize, getCanvasScale, resolveAnchoredTransform, resolveProfileTransform } from "./layout.js";
+import { resolveGridFlow } from "./layoutGroups.js";
+/** Подстановка для иерархии без собственного viewport: якорные слагаемые обнуляются. */
+export const NO_PARENT_LAYOUT_SIZE = { width: 0, height: 0 };
+export const IDENTITY_TRANSFORM = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+const EPSILON = 1e-8;
+/** Единственный индекс id → узел. */
+export function indexNodesById(nodes) {
+    return new Map(nodes.map((node) => [node.id, node]));
+}
+/** Оборачивает сырого владельца узлов (сцену, пресет) в форму, которую принимают helpers иерархии. */
+export function indexNodes(owner) {
+    return owner.layout === undefined
+        ? { nodesById: indexNodesById(owner.nodes) }
+        : { nodesById: indexNodesById(owner.nodes), layout: owner.layout };
+}
+export function multiplyAffine(left, right) {
+    return {
+        a: left.a * right.a + left.c * right.b,
+        b: left.b * right.a + left.d * right.b,
+        c: left.a * right.c + left.c * right.d,
+        d: left.b * right.c + left.d * right.d,
+        tx: left.a * right.tx + left.c * right.ty + left.tx,
+        ty: left.b * right.tx + left.d * right.ty + left.ty,
+    };
+}
+export function invertAffine(matrix) {
+    const determinant = matrix.a * matrix.d - matrix.b * matrix.c;
+    if (Math.abs(determinant) < EPSILON)
+        return undefined;
+    return {
+        a: matrix.d / determinant,
+        b: -matrix.b / determinant,
+        c: -matrix.c / determinant,
+        d: matrix.a / determinant,
+        tx: (matrix.c * matrix.ty - matrix.d * matrix.tx) / determinant,
+        ty: (matrix.b * matrix.tx - matrix.a * matrix.ty) / determinant,
+    };
+}
+/** Матрица одного узла в системе координат его родителя — ровно то, что строит Pixi из transform. */
+export function localTransformMatrix(transform) {
+    const cosine = Math.cos(transform.rotation);
+    const sine = Math.sin(transform.rotation);
+    const a = cosine * transform.scaleX;
+    const b = sine * transform.scaleX;
+    const c = -sine * transform.scaleY;
+    const d = cosine * transform.scaleY;
+    const pivotX = (transform.pivotX ?? 0) * transform.width;
+    const pivotY = (transform.pivotY ?? 0) * transform.height;
+    return { a, b, c, d, tx: transform.x - a * pivotX - c * pivotY, ty: transform.y - b * pivotX - d * pivotY };
+}
+/** Converts a point in scene coordinates into coordinates local to a parent's world matrix. */
+export function worldPointToLocal(parentWorldMatrix, point) {
+    const inverseParent = parentWorldMatrix === undefined ? IDENTITY_TRANSFORM : invertAffine(parentWorldMatrix);
+    if (inverseParent === undefined)
+        return undefined;
+    return {
+        x: inverseParent.a * point.x + inverseParent.c * point.y + inverseParent.tx,
+        y: inverseParent.b * point.x + inverseParent.d * point.y + inverseParent.ty,
+    };
+}
+function nearlyEqual(left, right) {
+    return Math.abs(left - right) <= 1e-6 * Math.max(1, Math.abs(left), Math.abs(right));
+}
+/**
+ * Converts a world matrix to a schema transform relative to a new parent.
+ * Undefined means the result needs skew (or an inverse of a zero-scale parent), neither of which
+ * the current document format can represent without changing the rendered object.
+ */
+export function transformRelativeToParent(worldMatrix, parentWorldMatrix, source) {
+    const inverseParent = parentWorldMatrix === undefined ? IDENTITY_TRANSFORM : invertAffine(parentWorldMatrix);
+    if (inverseParent === undefined)
+        return undefined;
+    const local = multiplyAffine(inverseParent, worldMatrix);
+    const scaleX = Math.hypot(local.a, local.b);
+    if (scaleX < EPSILON)
+        return undefined;
+    const rotation = Math.atan2(local.b, local.a);
+    const scaleY = (local.a * local.d - local.b * local.c) / scaleX;
+    const cosine = Math.cos(rotation);
+    const sine = Math.sin(rotation);
+    const reconstructed = {
+        a: cosine * scaleX,
+        b: sine * scaleX,
+        c: -sine * scaleY,
+        d: cosine * scaleY,
+    };
+    if (!nearlyEqual(local.a, reconstructed.a) || !nearlyEqual(local.b, reconstructed.b)
+        || !nearlyEqual(local.c, reconstructed.c) || !nearlyEqual(local.d, reconstructed.d))
+        return undefined;
+    const pivotX = (source.pivotX ?? 0) * source.width;
+    const pivotY = (source.pivotY ?? 0) * source.height;
+    return {
+        ...source,
+        x: local.tx + local.a * pivotX + local.c * pivotY,
+        y: local.ty + local.b * pivotX + local.d * pivotY,
+        scaleX,
+        scaleY,
+        rotation,
+    };
+}
+/** Доля свободного места до начала блока: 0 для start, 0.5 для center, 1 для end. */
+function alignmentFraction(alignment, axis) {
+    if (axis === "horizontal")
+        return alignment.endsWith("right") ? 1 : alignment.endsWith("center") ? 0.5 : 0;
+    return alignment.startsWith("lower") ? 1 : alignment.startsWith("middle") ? 0.5 : 0;
+}
+function alignmentOffset(alignment, freeSpace, axis) {
+    return Math.max(0, freeSpace) * alignmentFraction(alignment, axis);
+}
+/**
+ * Смещение линии по одной оси. Свободное место считается по фактическому числу ячеек в линии,
+ * поэтому неполная последняя строка выравнивается сама по себе — ровно как justify-content
+ * во flex-wrap. Реверс оси меняет физический смысл выравнивания на противоположный, а
+ * отрицательное свободное место не зажимается: при переполнении Yoga уводит блок за край.
+ */
+function lineOffset(alignment, axis, reversed, inner, count, cell, spacing) {
+    const free = inner - (count * cell + Math.max(0, count - 1) * spacing);
+    const offset = free * alignmentFraction(alignment, axis);
+    return reversed ? free - offset : offset;
+}
+/**
+ * Раскладывает детей сетки по линиям переноса ровно так, как это делает Yoga: линия закрывается
+ * либо когда ячейки в неё больше не влезают, либо на границе, кратной constraint, где стоит
+ * элемент-разрыв. Поперечный зазор приходит только от разрыва, поэтому линии, закрытые ранним
+ * переносом, стоят вплотную — см. applyLayoutGroup.
+ */
+function gridLines(childCount, options) {
+    const lines = [];
+    let start = 0;
+    let crossOffset = 0;
+    while (start < childCount) {
+        let count = 0;
+        while (count < options.capacity && start + count < childCount) {
+            count += 1;
+            if (options.usesLineBreaks && (start + count) % options.constraintCount === 0)
+                break;
+        }
+        lines.push({ start, count, crossOffset });
+        start += count;
+        crossOffset += options.crossCell;
+        const spaced = options.usesLineBreaks ? start % options.constraintCount === 0 : true;
+        if (start < childCount && spaced)
+            crossOffset += options.crossSpacing;
+    }
+    if (lines.length === 0)
+        lines.push({ start: 0, count: 1, crossOffset: 0 });
+    return lines;
+}
+/**
+ * Resolves the rectangle that Yoga gives a direct GridLayout child. The authored x/y, anchors and
+ * size do not participate while the child is in the grid, so hierarchy reparenting must preserve
+ * this managed rectangle rather than the dormant authored transform.
+ */
+export function resolveGridManagedTransform(node, parent, profile, parentSize) {
+    const settings = resolveLayoutGroupSettings(parent, profile);
+    const flow = resolveGridFlow(settings);
+    const childIndex = Math.max(0, parent.children.indexOf(node.id));
+    const childCount = Math.max(1, parent.children.length);
+    const innerWidth = Math.max(0, parentSize.width - settings.padding.left - settings.padding.right);
+    const innerHeight = Math.max(0, parentSize.height - settings.padding.top - settings.padding.bottom);
+    const fittingColumns = Math.max(1, Math.floor((innerWidth + settings.spacingX) / (settings.cellWidth + settings.spacingX)));
+    const fittingRows = Math.max(1, Math.floor((innerHeight + settings.spacingY) / (settings.cellHeight + settings.spacingY)));
+    const mainCell = flow.fillsByRow ? settings.cellWidth : settings.cellHeight;
+    const mainSpacing = flow.fillsByRow ? settings.spacingX : settings.spacingY;
+    const crossCell = flow.fillsByRow ? settings.cellHeight : settings.cellWidth;
+    const crossSpacing = flow.fillsByRow ? settings.spacingY : settings.spacingX;
+    const lines = gridLines(childCount, {
+        capacity: Math.max(1, flow.fillsByRow ? fittingColumns : fittingRows),
+        constraintCount: flow.usesLineBreaks ? Math.max(1, settings.constraintCount ?? 1) : Number.POSITIVE_INFINITY,
+        usesLineBreaks: flow.usesLineBreaks,
+        crossCell,
+        crossSpacing,
+    });
+    const line = lines.find((candidate) => childIndex < candidate.start + candidate.count) ?? lines[lines.length - 1];
+    const itemsInLine = line.count;
+    const indexInLine = Math.min(itemsInLine - 1, childIndex - line.start);
+    const slotInLine = flow.mainReversed ? itemsInLine - 1 - indexInLine : indexInLine;
+    const crossAxis = flow.fillsByRow ? "vertical" : "horizontal";
+    const crossTotal = flow.fillsByRow ? parentSize.height : parentSize.width;
+    const crossLead = flow.fillsByRow ? settings.padding.top : settings.padding.left;
+    const crossFree = (flow.fillsByRow ? innerHeight : innerWidth) - (lines[lines.length - 1].crossOffset + crossCell);
+    const crossAlign = crossFree * alignmentFraction(settings.childAlignment, crossAxis);
+    const mainPosition = (flow.fillsByRow ? settings.padding.left : settings.padding.top)
+        + lineOffset(settings.childAlignment, flow.fillsByRow ? "horizontal" : "vertical", flow.mainReversed, flow.fillsByRow ? innerWidth : innerHeight, itemsInLine, mainCell, mainSpacing)
+        + slotInLine * (mainCell + mainSpacing);
+    // wrap-reverse у Yoga отсчитывает линии от дальнего края, отступая ведущим padding, а не
+    // замыкающим; выравнивание при этом меряется от той же дальней кромки. Зеркало обязано повторять
+    // именно это поведение, иначе рамки выделения разъедутся с картинкой.
+    const crossPosition = flow.crossReversed
+        ? crossTotal - crossLead - crossCell - crossAlign - line.crossOffset
+        : crossLead + crossAlign + line.crossOffset;
+    const cellX = flow.fillsByRow ? mainPosition : crossPosition;
+    const cellY = flow.fillsByRow ? crossPosition : mainPosition;
+    // Yoga кладёт результат на пиксельную сетку (pointScaleFactor = 1), округляя обе кромки ячейки.
+    // Зеркало округляет так же, иначе на дробных выравниваниях рамка уезжает на полпикселя.
+    const x = Math.round(cellX);
+    const y = Math.round(cellY);
+    const width = Math.round(cellX + settings.cellWidth) - x;
+    const height = Math.round(cellY + settings.cellHeight) - y;
+    const authored = resolveProfileTransform(node, profile).transform;
+    const pivotX = authored.pivotX ?? 0;
+    const pivotY = authored.pivotY ?? 0;
+    return { ...authored, x: x + pivotX * width, y: y + pivotY * height, width, height };
+}
+/**
+ * Раскладка ВСЕЙ линейной группы за один проход: Yoga решает линию целиком (grow/shrink делят одно
+ * общее свободное место), поэтому пересчитывать её на каждого ребёнка отдельно — квадратичная
+ * работа. `NodeTransformSpace` кэширует результат по родителю и берёт из него нужную ячейку.
+ */
+function resolveLinearManagedTransforms(parent, profile, parentSize, nodesById) {
+    const settings = resolveLayoutGroupSettings(parent, profile);
+    const horizontal = parent.type === "horizontal-layout";
+    const children = parent.children.map((id) => nodesById.get(id)).filter((child) => child !== undefined);
+    const innerMain = Math.max(0, (horizontal ? parentSize.width : parentSize.height)
+        - (horizontal ? settings.padding.left + settings.padding.right : settings.padding.top + settings.padding.bottom));
+    const innerCross = Math.max(0, (horizontal ? parentSize.height : parentSize.width)
+        - (horizontal ? settings.padding.top + settings.padding.bottom : settings.padding.left + settings.padding.right));
+    const items = children.map((child) => {
+        const authored = resolveProfileTransform(child, profile).transform;
+        const ownMain = horizontal ? authored.width : authored.height;
+        const ownCross = horizontal ? authored.height : authored.width;
+        const expandsMain = horizontal
+            ? settings.controlChildWidth && settings.forceExpandWidth
+            : settings.controlChildHeight && settings.forceExpandHeight;
+        const expandsCross = horizontal
+            ? settings.controlChildHeight && settings.forceExpandHeight
+            : settings.controlChildWidth && settings.forceExpandWidth;
+        const alignSelf = child.layoutItem?.alignSelf;
+        return {
+            child,
+            authored,
+            main: child.layoutItem?.flexBasis ?? ownMain,
+            cross: expandsCross && (alignSelf === undefined || alignSelf === "auto" || alignSelf === "stretch") ? innerCross : ownCross,
+            grow: expandsMain ? Math.max(1, child.layoutItem?.flexGrow ?? 0) : child.layoutItem?.flexGrow ?? 0,
+            shrink: child.layoutItem?.flexShrink ?? 0,
+            alignSelf,
+        };
+    });
+    const totalGap = Math.max(0, items.length - 1) * settings.spacing;
+    const initialMain = items.reduce((sum, item) => sum + item.main, 0);
+    const freeMain = innerMain - totalGap - initialMain;
+    if (freeMain > 0) {
+        const totalGrow = items.reduce((sum, item) => sum + item.grow, 0);
+        if (totalGrow > 0)
+            for (const item of items)
+                item.main += freeMain * item.grow / totalGrow;
+    }
+    else if (freeMain < 0) {
+        const totalShrinkWeight = items.reduce((sum, item) => sum + item.shrink * item.main, 0);
+        if (totalShrinkWeight > 0) {
+            for (const item of items)
+                item.main = Math.max(0, item.main + freeMain * item.shrink * item.main / totalShrinkWeight);
+        }
+    }
+    const occupiedMain = items.reduce((sum, item) => sum + item.main, 0) + totalGap;
+    const remainingMain = Math.max(0, innerMain - occupiedMain);
+    const physicalMainOffset = alignmentOffset(settings.childAlignment, remainingMain, horizontal ? "horizontal" : "vertical");
+    const blockOffset = settings.reverseOrder ? remainingMain - physicalMainOffset : physicalMainOffset;
+    const orderedItems = settings.reverseOrder ? [...items].reverse() : items;
+    const positions = new Map();
+    let cursor = (horizontal ? settings.padding.left : settings.padding.top) + blockOffset;
+    for (const item of orderedItems) {
+        positions.set(item.child.id, cursor);
+        cursor += item.main + settings.spacing;
+    }
+    const crossLead = horizontal ? settings.padding.top : settings.padding.left;
+    const transforms = new Map();
+    for (const item of items) {
+        const groupCrossOffset = alignmentOffset(settings.childAlignment, innerCross - item.cross, horizontal ? "vertical" : "horizontal");
+        const selfCrossOffset = item.alignSelf === "center"
+            ? Math.max(0, innerCross - item.cross) / 2
+            : item.alignSelf === "flex-end"
+                ? Math.max(0, innerCross - item.cross)
+                : item.alignSelf === "flex-start" || item.alignSelf === "stretch" ? 0 : groupCrossOffset;
+        const mainPosition = positions.get(item.child.id) ?? 0;
+        const crossPosition = crossLead + selfCrossOffset;
+        const width = horizontal ? item.main : item.cross;
+        const height = horizontal ? item.cross : item.main;
+        const x = horizontal ? mainPosition : crossPosition;
+        const y = horizontal ? crossPosition : mainPosition;
+        const pivotX = item.authored.pivotX ?? 0;
+        const pivotY = item.authored.pivotY ?? 0;
+        transforms.set(item.child.id, { ...item.authored, x: x + pivotX * width, y: y + pivotY * height, width, height });
+    }
+    return transforms;
+}
+/**
+ * Снимок системы координат одной иерархии в одном layout-профиле: мировые матрицы, отрисованные
+ * прямоугольники и перенос узла к другому родителю без визуального сдвига.
+ *
+ * Экземпляр кэширует всё, что посчитал, поэтому он действителен ровно до следующей мутации узлов —
+ * после правки документа создавайте новый. Это единственная реализация: и редактор, и рантайм
+ * обязаны считать репарент здесь, иначе картинки разъедутся.
+ */
+export class NodeTransformSpace {
+    #hierarchy;
+    #profile;
+    #canvasSize;
+    #canvasMatrix;
+    #resolved = new Map();
+    #parentSizes = new Map();
+    #linearLayouts = new Map();
+    #visiting = new Set();
+    constructor(hierarchy, profile) {
+        this.#hierarchy = hierarchy;
+        this.#profile = profile;
+        const layout = hierarchy.layout;
+        const scale = layout === undefined ? 1 : getCanvasScale(layout.referenceViewports[profile], layout.preferredViewports[profile]);
+        this.#canvasSize = layout === undefined ? undefined : getCanvasLogicalSize(layout.referenceViewports[profile], layout.preferredViewports[profile]);
+        this.#canvasMatrix = { a: scale, b: 0, c: 0, d: scale, tx: 0, ty: 0 };
+    }
+    /** Snapshot for the same hierarchy in another profile; каждый профиль кэшируется отдельно. */
+    static forOwner(owner, profile) {
+        return new NodeTransformSpace(indexNodes(owner), profile);
+    }
+    get profile() {
+        return this.#profile;
+    }
+    /** Логический RectTransform-размер Canvas; `undefined` у иерархии без собственного viewport. */
+    get canvasSize() {
+        return this.#canvasSize;
+    }
+    /** Matrix of the Unity-like scaled Canvas that owns top-level nodes. */
+    getOwnerWorldMatrix() {
+        return this.#hierarchy.layout === undefined ? undefined : this.#canvasMatrix;
+    }
+    /** Returns the node rectangle that is actually rendered, including a layout parent's managed cell. */
+    getRenderedTransform(nodeId) {
+        return this.#resolve(nodeId)?.transform;
+    }
+    /** Returns the same world matrix Pixi builds from the serialized parent chain. */
+    getWorldMatrix(nodeId) {
+        return this.#resolve(nodeId)?.matrix;
+    }
+    /** Scene-space point converted into the coordinates of `parentId`'s children. */
+    worldPointToLocal(parentId, point) {
+        return worldPointToLocal(parentId === null ? this.getOwnerWorldMatrix() : this.getWorldMatrix(parentId), point);
+    }
+    /**
+     * Логический размер, относительно которого разрешается anchoredPosition узла.
+     *
+     * Узел может быть черновиком мутации (его ещё нет в иерархии) — тогда берётся его собственный
+     * parentId. `undefined` означает «у иерархии нет своего viewport» (редактируемый пресет): это не
+     * то же самое, что нулевой размер, `resolveAnchoredTransform` в этом случае не трогает transform.
+     */
+    getParentLayoutSize(node) {
+        return this.getChildLayoutSize(this.#hierarchy.nodesById.get(node.id)?.parentId ?? node.parentId);
+    }
+    /**
+     * Размер, который получает ЛЮБОЙ прямой ребёнок узла `parentId` (null — корень иерархии).
+     * Именно его требует перенос: якорные слагаемые ребёнка должны сниматься с размера будущего
+     * родителя, а не текущего.
+     */
+    getChildLayoutSize(parentId) {
+        const cached = this.#parentSizes.get(parentId);
+        if (cached !== undefined || this.#parentSizes.has(parentId))
+            return cached;
+        const size = this.#computeChildLayoutSize(parentId);
+        this.#parentSizes.set(parentId, size);
+        return size;
+    }
+    /**
+     * Transform, который сохраняет узел на экране после переноса под `newParentId` — то, что нужно
+     * записать в документ. `undefined`, если сохранить картинку нельзя: перенос потребовал бы skew
+     * либо родитель невырожденно не обращается (нулевой масштаб).
+     */
+    getReparentedTransform(nodeId, newParentId) {
+        const node = this.#hierarchy.nodesById.get(nodeId);
+        if (node === undefined)
+            return undefined;
+        const resolved = this.#resolve(nodeId);
+        if (resolved === undefined)
+            return undefined;
+        const parentWorldMatrix = newParentId === null ? this.getOwnerWorldMatrix() : this.getWorldMatrix(newParentId);
+        const preserved = transformRelativeToParent(resolved.matrix, parentWorldMatrix, resolved.transform);
+        if (preserved === undefined)
+            return undefined;
+        // Anchors живут в схеме как доли размера родителя, поэтому мировой transform, разложенный в
+        // локальный, ещё содержит вклад НОВОГО родителя: его нужно вычесть, чтобы authored-поля дали
+        // на экране ту же рамку.
+        const destinationSize = this.getChildLayoutSize(newParentId) ?? NO_PARENT_LAYOUT_SIZE;
+        const authored = resolveProfileTransform(node, this.#profile).transform;
+        const anchorMinX = authored.anchorMinX ?? 0;
+        const anchorMinY = authored.anchorMinY ?? 0;
+        const anchorMaxX = authored.anchorMaxX ?? anchorMinX;
+        const anchorMaxY = authored.anchorMaxY ?? anchorMinY;
+        const pivotX = authored.pivotX ?? 0;
+        const pivotY = authored.pivotY ?? 0;
+        const spanX = anchorMaxX - anchorMinX;
+        const spanY = anchorMaxY - anchorMinY;
+        return {
+            ...preserved,
+            x: preserved.x - (anchorMinX + spanX * pivotX) * destinationSize.width,
+            y: preserved.y - (anchorMinY + spanY * pivotY) * destinationSize.height,
+            width: preserved.width - spanX * destinationSize.width,
+            height: preserved.height - spanY * destinationSize.height,
+        };
+    }
+    #computeChildLayoutSize(parentId) {
+        if (parentId === null)
+            return this.#canvasSize;
+        const parent = this.#hierarchy.nodesById.get(parentId);
+        if (parent === undefined)
+            return this.#canvasSize;
+        if (this.#hierarchy.layout !== undefined && parent.parentId === null)
+            return this.#canvasSize;
+        // Прямой ребёнок grid-layout не владеет своим отрисованным размером: фиксированная ячейка Unity
+        // GridLayoutGroup полностью переопределяет authored transform (см. applyLayoutItem). Без этой
+        // ветки внуки грида (например текст внутри button-ячейки) якорились бы относительно устаревшего
+        // authored-размера родителя и не реагировали бы на изменение Cell width/height.
+        const grandparent = parent.parentId === null ? undefined : this.#hierarchy.nodesById.get(parent.parentId);
+        if (grandparent !== undefined && grandparent.type === "grid-layout") {
+            const grid = resolveLayoutGroupSettings(grandparent, this.#profile);
+            return { width: grid.cellWidth, height: grid.cellHeight };
+        }
+        // Тот же принцип для прямого ребёнка page-group (страницы): она не владеет собственным
+        // отрисованным размером — растягивается на весь resolved rectangle группы независимо от своих
+        // anchors (`PageItemContainer`/`NodeView.applyResolvedTransform`, managedByLayout). Её собственным
+        // детям нужен именно этот forced rectangle, а не anchor-resolved authored-размер страницы —
+        // иначе они якорятся относительно значения, которое страница на экране никогда не получит.
+        if (grandparent !== undefined && grandparent.type === "page-group")
+            return this.getChildLayoutSize(parent.parentId);
+        // Родитель может быть сам растянут anchors, поэтому его логический размер разрешается рекурсивно.
+        const transform = resolveAnchoredTransform(resolveProfileTransform(parent, this.#profile).transform, this.getChildLayoutSize(parent.parentId));
+        return { width: transform.width, height: transform.height };
+    }
+    /**
+     * Один обход вверх по цепочке родителей на узел: и отрисованный прямоугольник, и мировая матрица
+     * берутся из него. Результат кэшируется, поэтому у ветки с общим предком предки считаются один раз.
+     */
+    #resolve(nodeId) {
+        const cached = this.#resolved.get(nodeId);
+        if (cached !== undefined || this.#resolved.has(nodeId))
+            return cached;
+        if (this.#visiting.has(nodeId))
+            return undefined;
+        const node = this.#hierarchy.nodesById.get(nodeId);
+        if (node === undefined)
+            return undefined;
+        this.#visiting.add(nodeId);
+        const parentNode = node.parentId === null ? undefined : this.#hierarchy.nodesById.get(node.parentId);
+        const parent = node.parentId === null ? undefined : this.#resolve(node.parentId);
+        this.#visiting.delete(nodeId);
+        let result;
+        if (node.parentId === null || parent !== undefined) {
+            const parentSize = this.#hierarchy.layout !== undefined && parentNode?.parentId === null
+                ? this.#canvasSize
+                : parent?.size ?? this.#canvasSize;
+            const managed = parentNode !== undefined && parent !== undefined
+                ? this.#resolveManagedTransform(node, parentNode, parent.size)
+                : undefined;
+            const transform = managed ?? resolveAnchoredTransform(resolveProfileTransform(node, this.#profile).transform, parentSize);
+            result = {
+                transform,
+                matrix: multiplyAffine(parent?.matrix ?? this.#canvasMatrix, localTransformMatrix(transform)),
+                size: node.parentId === null && this.#hierarchy.layout !== undefined
+                    ? this.#canvasSize
+                    : { width: transform.width, height: transform.height },
+            };
+        }
+        this.#resolved.set(nodeId, result);
+        return result;
+    }
+    /** Прямоугольник, который назначает ребёнку родитель-раскладка; `undefined` — позицией владеет сам узел. */
+    #resolveManagedTransform(node, parent, parentSize) {
+        if (parent.type === "grid-layout")
+            return resolveGridManagedTransform(node, parent, this.#profile, parentSize);
+        if (parent.type !== "horizontal-layout" && parent.type !== "vertical-layout")
+            return undefined;
+        let layout = this.#linearLayouts.get(parent.id);
+        if (layout === undefined) {
+            layout = resolveLinearManagedTransforms(parent, this.#profile, parentSize, this.#hierarchy.nodesById);
+            this.#linearLayouts.set(parent.id, layout);
+        }
+        return layout.get(node.id) ?? resolveProfileTransform(node, this.#profile).transform;
+    }
+}
+/**
+ * Разовый запрос размера родителя без явного снимка: удобен на единичных вызовах.
+ * В цикле по узлам создавайте один `NodeTransformSpace` — он переиспользует кэши.
+ */
+export function getParentLayoutSize(hierarchy, node, profile) {
+    return new NodeTransformSpace(hierarchy, profile).getParentLayoutSize(node);
+}
+//# sourceMappingURL=transformSpace.js.map