@unrulysystems/native-motion-core 0.1.0-alpha.0

package/dist/layout/compose.d.cts

@@ -0,0 +1,30 @@
+import type { Rect, Transform } from "./types.cjs";
+/**
+ * The viewport rect of a child at progress `p`, positioned parent-relative (REQ-LAYOUT-012). `childLocal` is
+ * the child's rect in the parent's LOCAL space (relative to the parent's top-left, in the after frame). The
+ * child rides the parent's projection: its origin and size scale with the parent's current visual frame, so
+ * its fractional position within the parent is invariant across progress and it is never stranded at its
+ * host-absolute origin while the parent is displaced.
+ */
+export declare function composeParentRelative(parentBefore: Rect, parentAfter: Rect, childLocal: Rect, progress: number): Rect;
+/**
+ * The counter-scale a child carrying layout identity applies to cancel its parent's scale, so it keeps its
+ * intrinsic size under a scaled layout (REQ-LAYOUT-013). `parent.scaleX × counterScale.scaleX == 1`.
+ */
+export declare function counterScale(parent: Transform): Transform;
+/** A border-radius corrected per axis under a (possibly anisotropic) scale: `scale × corrected == radius`. */
+export interface CorrectedRadius {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * Correct a border-radius under a non-unit scale (REQ-LAYOUT-013): dividing by the axis scale so the applied
+ * scale reproduces the intended visual radius. Anisotropic scale yields distinct x/y radii.
+ */
+export declare function correctRadius(radius: number, scaleX: number, scaleY: number): CorrectedRadius;
+/**
+ * Assert a property can be corrected under a scaled layout, else fail loud (REQ-LAYOUT-013 → REQ-API-005/006)
+ * rather than rendering a distorted result. Consults the frozen registry only to sharpen the message
+ * (known style prop vs typo); the correctable set is LAYOUT's own contribution, pending ratification.
+ */
+export declare function assertCorrectable(property: string): void;

package/dist/layout/compose.d.ts

@@ -0,0 +1,30 @@
+import type { Rect, Transform } from "./types.js";
+/**
+ * The viewport rect of a child at progress `p`, positioned parent-relative (REQ-LAYOUT-012). `childLocal` is
+ * the child's rect in the parent's LOCAL space (relative to the parent's top-left, in the after frame). The
+ * child rides the parent's projection: its origin and size scale with the parent's current visual frame, so
+ * its fractional position within the parent is invariant across progress and it is never stranded at its
+ * host-absolute origin while the parent is displaced.
+ */
+export declare function composeParentRelative(parentBefore: Rect, parentAfter: Rect, childLocal: Rect, progress: number): Rect;
+/**
+ * The counter-scale a child carrying layout identity applies to cancel its parent's scale, so it keeps its
+ * intrinsic size under a scaled layout (REQ-LAYOUT-013). `parent.scaleX × counterScale.scaleX == 1`.
+ */
+export declare function counterScale(parent: Transform): Transform;
+/** A border-radius corrected per axis under a (possibly anisotropic) scale: `scale × corrected == radius`. */
+export interface CorrectedRadius {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * Correct a border-radius under a non-unit scale (REQ-LAYOUT-013): dividing by the axis scale so the applied
+ * scale reproduces the intended visual radius. Anisotropic scale yields distinct x/y radii.
+ */
+export declare function correctRadius(radius: number, scaleX: number, scaleY: number): CorrectedRadius;
+/**
+ * Assert a property can be corrected under a scaled layout, else fail loud (REQ-LAYOUT-013 → REQ-API-005/006)
+ * rather than rendering a distorted result. Consults the frozen registry only to sharpen the message
+ * (known style prop vs typo); the correctable set is LAYOUT's own contribution, pending ratification.
+ */
+export declare function assertCorrectable(property: string): void;

package/dist/layout/compose.js

@@ -0,0 +1,65 @@
+// SPEC-LAYOUT §2/§4a — parent-relative composition + distortion correction (REQ-LAYOUT-012/013). A nested
+// child is positioned relative to the animating ancestor's projection frame, so it composes coherently and
+// is never left behind at its pre-animation viewport origin. A child carrying layout identity under a scaled
+// parent gets a counter-scale to keep its intrinsic size, and border-radius is corrected under non-unit
+// scale. A property that cannot be corrected under a scaled layout fails loud (REQ-LAYOUT-013 → REQ-API-005/
+// 006). Pure; consumes the frozen SUBSET registry (existence check) but owns no second property registry.
+import { UNIVERSAL_SUBSET } from "../subset/index.js";
+import { applyTransformToRect, projectAtProgress } from "./projection.js";
+/**
+ * The viewport rect of a child at progress `p`, positioned parent-relative (REQ-LAYOUT-012). `childLocal` is
+ * the child's rect in the parent's LOCAL space (relative to the parent's top-left, in the after frame). The
+ * child rides the parent's projection: its origin and size scale with the parent's current visual frame, so
+ * its fractional position within the parent is invariant across progress and it is never stranded at its
+ * host-absolute origin while the parent is displaced.
+ */
+export function composeParentRelative(parentBefore, parentAfter, childLocal, progress) {
+  'worklet';
+    const tp = projectAtProgress(parentBefore, parentAfter, progress);
+    const parentVisual = applyTransformToRect(tp, parentAfter);
+    return {
+        x: parentVisual.x + childLocal.x * tp.scaleX,
+        y: parentVisual.y + childLocal.y * tp.scaleY,
+        width: childLocal.width * tp.scaleX,
+        height: childLocal.height * tp.scaleY,
+    };
+}
+function assertNonZeroScale(scaleX, scaleY) {
+  'worklet';
+    if (!Number.isFinite(scaleX) || !Number.isFinite(scaleY) || scaleX === 0 || scaleY === 0) {
+        throw new Error(`layout: cannot counter-correct under a zero/non-finite scale (scaleX=${scaleX}, scaleY=${scaleY}) — divide-by-zero guard (REQ-LAYOUT-011)`);
+    }
+}
+/**
+ * The counter-scale a child carrying layout identity applies to cancel its parent's scale, so it keeps its
+ * intrinsic size under a scaled layout (REQ-LAYOUT-013). `parent.scaleX × counterScale.scaleX == 1`.
+ */
+export function counterScale(parent) {
+  'worklet';
+    assertNonZeroScale(parent.scaleX, parent.scaleY);
+    return { translateX: 0, translateY: 0, scaleX: 1 / parent.scaleX, scaleY: 1 / parent.scaleY };
+}
+/**
+ * Correct a border-radius under a non-unit scale (REQ-LAYOUT-013): dividing by the axis scale so the applied
+ * scale reproduces the intended visual radius. Anisotropic scale yields distinct x/y radii.
+ */
+export function correctRadius(radius, scaleX, scaleY) {
+  'worklet';
+    assertNonZeroScale(scaleX, scaleY);
+    return { x: radius / scaleX, y: radius / scaleY };
+}
+// LAYOUT's proposed set of properties that are corrected under a scaled layout. This is the subsystem's
+// CONTRIBUTION to the universal subset (REQ-LAYOUT-013), pending SUBSET ratification (§7) — NOT a second
+// registry. Size is handled structurally by counterScale; borderRadius by correctRadius.
+const LAYOUT_CORRECTABLE = new Set(['borderRadius']);
+/**
+ * Assert a property can be corrected under a scaled layout, else fail loud (REQ-LAYOUT-013 → REQ-API-005/006)
+ * rather than rendering a distorted result. Consults the frozen registry only to sharpen the message
+ * (known style prop vs typo); the correctable set is LAYOUT's own contribution, pending ratification.
+ */
+export function assertCorrectable(property) {
+    if (LAYOUT_CORRECTABLE.has(property))
+        return;
+    const known = UNIVERSAL_SUBSET.has(property);
+    throw new Error(`layout: '${property}' is ${known ? 'a known style property but is not' : 'not a known style property and is not'} correctable under a scaled layout at M1 — the correctable set is {borderRadius} (size via counter-scale), LAYOUT's proposed contribution to the universal subset (§7, pending SUBSET ratification). Fails loud rather than rendering distorted (REQ-LAYOUT-013).`);
+}

package/dist/layout/constants.cjs

@@ -0,0 +1,13 @@
+"use strict";
+// @frame-path — executes inside the UI-runtime frame step; allocation-gated (REQ-DRIVER-021).
+// SPEC-LAYOUT §4a pinned tolerances. Stated once, shared across the projection math, composition, and the
+// session. Position/scale epsilons gate identity-at-settle + counter-scale; the velocity epsilon gates
+// retarget C1 continuity (M4). These are invariant tolerances, not feel parameters — they do not widen.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EPSILON_VEL = exports.EPSILON_SCALE = exports.EPSILON_POS = void 0;
+/** Position/edge coincidence tolerance (px): ends-at-host-layout, parent-relative coherence, C0 seam. */
+exports.EPSILON_POS = 0.5;
+/** Child-size tolerance (fraction): a counter-scaled child stays within 1% of its intrinsic size. */
+exports.EPSILON_SCALE = 0.01;
+/** Retarget velocity-continuity tolerance (px/s): the C1 seam when a layout change arrives mid-projection. */
+exports.EPSILON_VEL = 1;

package/dist/layout/constants.d.cts

@@ -0,0 +1,6 @@
+/** Position/edge coincidence tolerance (px): ends-at-host-layout, parent-relative coherence, C0 seam. */
+export declare const EPSILON_POS = 0.5;
+/** Child-size tolerance (fraction): a counter-scaled child stays within 1% of its intrinsic size. */
+export declare const EPSILON_SCALE = 0.01;
+/** Retarget velocity-continuity tolerance (px/s): the C1 seam when a layout change arrives mid-projection. */
+export declare const EPSILON_VEL = 1;

package/dist/layout/constants.d.ts

@@ -0,0 +1,6 @@
+/** Position/edge coincidence tolerance (px): ends-at-host-layout, parent-relative coherence, C0 seam. */
+export declare const EPSILON_POS = 0.5;
+/** Child-size tolerance (fraction): a counter-scaled child stays within 1% of its intrinsic size. */
+export declare const EPSILON_SCALE = 0.01;
+/** Retarget velocity-continuity tolerance (px/s): the C1 seam when a layout change arrives mid-projection. */
+export declare const EPSILON_VEL = 1;

package/dist/layout/constants.js

@@ -0,0 +1,10 @@
+// @frame-path — executes inside the UI-runtime frame step; allocation-gated (REQ-DRIVER-021).
+// SPEC-LAYOUT §4a pinned tolerances. Stated once, shared across the projection math, composition, and the
+// session. Position/scale epsilons gate identity-at-settle + counter-scale; the velocity epsilon gates
+// retarget C1 continuity (M4). These are invariant tolerances, not feel parameters — they do not widen.
+/** Position/edge coincidence tolerance (px): ends-at-host-layout, parent-relative coherence, C0 seam. */
+export const EPSILON_POS = 0.5;
+/** Child-size tolerance (fraction): a counter-scaled child stays within 1% of its intrinsic size. */
+export const EPSILON_SCALE = 0.01;
+/** Retarget velocity-continuity tolerance (px/s): the C1 seam when a layout change arrives mid-projection. */
+export const EPSILON_VEL = 1;