diff --git a/src/__tests__/compiler/compiler.test.tsx b/src/__tests__/compiler/compiler.test.tsx
index 01854195..a1a6906b 100644
--- a/src/__tests__/compiler/compiler.test.tsx
+++ b/src/__tests__/compiler/compiler.test.tsx
@@ -382,6 +382,48 @@ test("warnings", () => {
});
});
+test("a transform value the compiler cannot convert is ignored, with a warning", () => {
+ const compiled = compile(`
+.my-class {
+ transform: translate(10px, 1cap);
+ rotate: 1grad;
+ scale: 2;
+}
+.alone {
+ translate: calc(1em + 5px) 5px;
+}`);
+
+ expect(compiled.stylesheet()).toStrictEqual({
+ s: [
+ [
+ "my-class",
+ [
+ {
+ d: [
+ [
+ [
+ [{}, "scaleX", 2],
+ [{}, "scaleY", 2],
+ ],
+ "scale",
+ ],
+ ],
+ s: [1, 1],
+ },
+ ],
+ ],
+ ],
+ });
+
+ expect(compiled.warnings()).toStrictEqual({
+ values: {
+ transform: ["1cap"],
+ translate: ["calc()"],
+ rotate: ["1 grad"],
+ },
+ });
+});
+
test("simplifies rem", () => {
const compiled = compile(`.test {
border-width: calc(10rem + 2px);
diff --git a/src/__tests__/compiler/declarations.test.tsx b/src/__tests__/compiler/declarations.test.tsx
index c2e18378..4dbd378f 100644
--- a/src/__tests__/compiler/declarations.test.tsx
+++ b/src/__tests__/compiler/declarations.test.tsx
@@ -8,8 +8,8 @@ const tests = [
["-rn-ripple-layer: foreground;", [{ d: [[true, ["android_ripple", "foreground"]]], s: [1, 1] }]],
["caret-color: black", [{ d: [["#000", ["cursorColor"]]], s: [1, 1] }]],
["fill: black;", [{ d: [["#000", ["fill"]]], s: [1, 1] }]],
- ["rotate: 3deg;", [{ d: [[[{}, "rotateZ", "3deg"], "rotateZ"]], s: [1, 1] }]],
- ["rotate: x 3deg;", [{ d: [[[{}, "rotateX", "3deg"], "rotateX"]], s: [1, 1] }]],
+ ["rotate: 3deg;", [{ d: [[[{}, "rotateZ", "3deg"], "rotate"]], s: [1, 1] }]],
+ ["rotate: x 3deg;", [{ d: [[[{}, "rotateX", "3deg"], "rotate"]], s: [1, 1] }]],
["stroke-width: 1px;", [{ d: [[1, ["strokeWidth"]]], s: [1, 1] }]],
["stroke: black;", [{ d: [["#000", ["stroke"]]], s: [1, 1] }]],
] as const;
diff --git a/src/__tests__/native/transform.test.tsx b/src/__tests__/native/transform.test.tsx
index 7a59b816..6cfeeda7 100644
--- a/src/__tests__/native/transform.test.tsx
+++ b/src/__tests__/native/transform.test.tsx
@@ -154,3 +154,340 @@ describe("transform", () => {
});
});
});
+
+function renderStyle(css: string): unknown {
+ registerCSS(css);
+
+ return render(
+ ,
+ ).getByTestId(testID).props.style;
+}
+
+// A second definition keeps each variable from being inlined, so it resolves at runtime
+const decoy = `.decoy { --sx: 9; --sy: 9; --t: 9px; --offset: 1px; --s: 1; --x: 9px; --y: 9px; --r: 9deg; }`;
+
+// React Native requires exactly one property per transform object, and its validator throws otherwise
+describe("one property per entry", () => {
+ // Chromium 153, Firefox 155 and WebKit 26.6 scale each axis by its own operand
+ test.each([
+ ["75%", "50%", [{ scaleX: 0.75 }, { scaleY: 0.5 }]],
+ ["2", "3", [{ scaleX: 2 }, { scaleY: 3 }]],
+ ])(
+ "transform: scale(var(--sx), var(--sy)) with %s and %s renders an entry per axis",
+ (sx, sy, transform) => {
+ expect(
+ renderStyle(
+ `${decoy} .my-class { --sx: ${sx}; --sy: ${sy}; transform: scale(var(--sx), var(--sy)); }`,
+ ),
+ ).toStrictEqual({ transform });
+ },
+ );
+
+ test("transform: scale(var(--sx)) scales both axes by its one operand", () => {
+ expect(
+ renderStyle(
+ `${decoy} .my-class { --sx: 75%; transform: scale(var(--sx)); }`,
+ ),
+ ).toStrictEqual({ transform: [{ scaleX: 0.75 }, { scaleY: 0.75 }] });
+ });
+
+ test("scale: var(--sx) scales both axes by its one value", () => {
+ expect(
+ renderStyle(`${decoy} .my-class { --sx: 75%; scale: var(--sx); }`),
+ ).toStrictEqual({ transform: [{ scaleX: 0.75 }, { scaleY: 0.75 }] });
+ });
+
+ // Chromium 153, Firefox 155 and WebKit 26.6 translate a one-operand translate() along x only
+ test.each([
+ "transform: translate(10px);",
+ "--t: 10px; transform: translate(var(--t));",
+ "--t: 10px; translate: var(--t);",
+ ])("%s translates along x only", (declarations) => {
+ expect(renderStyle(`${decoy} .my-class { ${declarations} }`)).toStrictEqual(
+ { transform: [{ translateX: 10 }, { translateY: 0 }] },
+ );
+ });
+
+ // Chromium 153, Firefox 155 and WebKit 26.6 read an operand list a var() supplies whole
+ test.each([
+ [
+ "--offset: 10px 20px; translate: var(--offset);",
+ [{ translateX: 10 }, { translateY: 20 }],
+ ],
+ [
+ "--offset: 10px, 20px; transform: translate(var(--offset));",
+ [{ translateX: 10 }, { translateY: 20 }],
+ ],
+ ["--s: 2 3; scale: var(--s);", [{ scaleX: 2 }, { scaleY: 3 }]],
+ ] as const)("%s reads both operands", (declarations, transform) => {
+ expect(renderStyle(`${decoy} .my-class { ${declarations} }`)).toStrictEqual(
+ { transform },
+ );
+ });
+
+ test("a two-operand translate() renders an entry per axis, beside a sibling", () => {
+ expect(
+ renderStyle(
+ `${decoy} .my-class { --t: 10px; transform: translate(var(--t), var(--t)) rotate(45deg); }`,
+ ),
+ ).toStrictEqual({
+ transform: [{ translateX: 10 }, { translateY: 10 }, { rotate: "45deg" }],
+ });
+ });
+
+ // React Native refuses a transform entry without a property, so a function the compiler does not convert contributes none
+ test.each([
+ "transform: scale3d(1, 2, 3);",
+ "transform: scaleZ(2);",
+ "transform: matrix(1, 0, 0, 1, 0, 0);",
+ "transform: translateZ(10px);",
+ ])("%s renders no entry", (declaration) => {
+ expect(renderStyle(`.my-class { ${declaration} }`)).toStrictEqual({
+ transform: [],
+ });
+ });
+
+ test.each([
+ ["translate(10px, 20px)", [{ translateX: 10 }, { translateY: 20 }]],
+ ["translate(-50%, -50%)", [{ translateX: "-50%" }, { translateY: "-50%" }]],
+ ] as const)("transform: %s renders an entry per axis", (value, transform) => {
+ expect(renderStyle(`.my-class { transform: ${value}; }`)).toStrictEqual({
+ transform,
+ });
+ });
+
+ test("a translate() pair in a var() fallback renders an entry per axis", () => {
+ expect(
+ renderStyle(
+ `.my-class { transform: var(--missing, translate(10px, 20px)); }`,
+ ),
+ ).toStrictEqual({ transform: [{ translateX: 10 }, { translateY: 20 }] });
+ });
+
+ test("a function React Native has no form for leaves its neighbour", () => {
+ expect(
+ renderStyle(
+ `.my-class { transform: translateX(10px) scale3d(1, 2, 3); }`,
+ ),
+ ).toStrictEqual({ transform: [{ translateX: 10 }] });
+ });
+
+ test("translateZ() leaves its neighbour", () => {
+ expect(
+ renderStyle(`.my-class { transform: translateZ(10px) rotate(45deg); }`),
+ ).toStrictEqual({ transform: [{ rotate: "45deg" }] });
+ });
+});
+
+// Chromium 153, Firefox 155 and WebKit 26.6: a function left without a valid argument makes the declaration invalid at computed-value time, so the transform is none (css-variables-1 §3.1)
+test.each(
+ (
+ [
+ ["", "scaleX(var(--missing))"],
+ ["", "translate(10px, var(--missing))"],
+ ["", "rotate(var(--missing))"],
+ ["", "scale(2, var(--missing))"],
+ ["--offset: 10px 20px; ", "var(--offset)"],
+ ["--sx: none; ", "scaleX(var(--sx))"],
+ ["--sx: none; ", "scale(var(--sx))"],
+ ["--t: 1px, 2px, 3px; ", "translate(var(--t))"],
+ ["--s: 1, 2, 3; ", "scale(var(--s))"],
+ ["--r: 10deg, 20deg; ", "rotate(var(--r))"],
+ ] as const
+ ).flatMap(([customProperties, transform]) => [
+ `${customProperties}transform: ${transform};`,
+ `${customProperties}transform: translateX(5px) ${transform};`,
+ ]),
+)("%s leaves no transform", (declarations) => {
+ expect(
+ renderStyle(
+ `${decoy} .earlier { transform: rotate(10deg); } .my-class { ${declarations} }`,
+ ),
+ ).toStrictEqual({ transform: [] });
+});
+
+// Chromium 153, Firefox 155 and WebKit 26.6: a scale or translate longhand left without a value is none, and the transform property beside it stands
+test.each([
+ "scale: var(--missing);",
+ "scale: var(--missing) var(--missing);",
+ "translate: var(--missing) var(--missing);",
+ "--sx: none; --sy: 2; scale: var(--sx) var(--sy);",
+ "scale: unset;",
+ "scale: initial;",
+ "translate: initial;",
+])("%s leaves the transform property's entries", (declarations) => {
+ expect(
+ renderStyle(
+ `${decoy} .earlier { transform: rotate(10deg); } .my-class { ${declarations} }`,
+ ),
+ ).toStrictEqual({ transform: [{ rotate: "10deg" }] });
+});
+
+// Chromium 153, Firefox 155 and WebKit 26.6 cascade each transform property on its own, and compose translate, rotate, scale, then the transform list (css-transforms-2 §6)
+test.each([
+ [
+ ".earlier { translate: 10px 20px; } .my-class { --x: 1px; --y: 2px; translate: var(--x) var(--y); }",
+ [{ translateX: 1 }, { translateY: 2 }],
+ ],
+ [
+ ".earlier { --x: 1px; --y: 2px; translate: var(--x) var(--y); } .my-class { translate: 10px 20px; }",
+ [{ translateX: 10 }, { translateY: 20 }],
+ ],
+ [
+ ".earlier { scale: 2; } .my-class { scale: 3; }",
+ [{ scaleX: 3 }, { scaleY: 3 }],
+ ],
+ [
+ ".earlier { transform: rotate(10deg); } .my-class { rotate: 20deg; }",
+ [{ rotateZ: "20deg" }, { rotate: "10deg" }],
+ ],
+ [
+ ".earlier { translate: 10px 20px; } .my-class { --t: 5px; transform: translateX(var(--t)); }",
+ [{ translateX: 10 }, { translateY: 20 }, { translateX: 5 }],
+ ],
+ [
+ ".earlier { --t: 5px; transform: translateX(var(--t)); } .my-class { translate: 10px 20px; }",
+ [{ translateX: 10 }, { translateY: 20 }, { translateX: 5 }],
+ ],
+ [
+ ".my-class { translate: 10px 20px; rotate: 30deg; scale: 2; transform: translateX(5px); }",
+ [
+ { translateX: 10 },
+ { translateY: 20 },
+ { rotateZ: "30deg" },
+ { scaleX: 2 },
+ { scaleY: 2 },
+ { translateX: 5 },
+ ],
+ ],
+ [
+ ".earlier { translate: 10px 20px !important; } .my-class { translate: 1px 2px; }",
+ [{ translateX: 10 }, { translateY: 20 }],
+ ],
+ [
+ ".earlier { transform: rotate(10deg) !important; } .my-class { translate: 1px 2px; }",
+ [{ translateX: 1 }, { translateY: 2 }, { rotate: "10deg" }],
+ ],
+] as const)("%s composes in CSS order", (css, transform) => {
+ expect(renderStyle(`${decoy} ${css}`)).toStrictEqual({ transform });
+});
+
+// A unit React Native has no equivalent for leaves the declaration invalid there, and an invalid declaration is ignored (CSS 2.2 §4.2)
+test.each([
+ [
+ ".earlier { translate: 5px 6px; } .my-class { translate: 10px 1cap; }",
+ [{ translateX: 5 }, { translateY: 6 }],
+ ],
+ [
+ ".earlier { transform: rotate(5deg); } .my-class { translate: 10px 1cap; }",
+ [{ rotate: "5deg" }],
+ ],
+ [
+ ".earlier { transform: rotate(5deg); } .my-class { transform: translate(10px, 1cap); }",
+ [{ rotate: "5deg" }],
+ ],
+] as const)(
+ "%s ignores the declaration it cannot convert",
+ (css, transform) => {
+ expect(renderStyle(css)).toStrictEqual({ transform });
+ },
+);
+
+// Chromium 153, Firefox 155 and WebKit 26.6 resolve an em length against the element's font size, whichever rule sets it (css-values-4 §6.1.1)
+test.each([
+ [
+ ".earlier { translate: 1em 5px; } .my-class { font-size: 20px; }",
+ [{ translateX: 20 }, { translateY: 5 }],
+ ],
+ [
+ ".earlier { transform: translateX(1em); } .my-class { font-size: 20px; }",
+ [{ translateX: 20 }],
+ ],
+] as const)(
+ "%s resolves em against the element's font size",
+ (css, transform) => {
+ expect(renderStyle(css)).toStrictEqual({ fontSize: 20, transform });
+ },
+);
+
+// Chromium 153, Firefox 155 and WebKit 26.6 rotate about the axis a keyword or a vector along one axis names
+test.each([
+ ["rotate: 0 0 2 45deg;", [{ rotateZ: "45deg" }]],
+ ["rotate: x 45deg;", [{ rotateX: "45deg" }]],
+ ["rotate: 45deg y;", [{ rotateY: "45deg" }]],
+ ["--r: 20deg; rotate: var(--r);", [{ rotate: "20deg" }]],
+] as const)("%s rotates about the axis it names", (declarations, transform) => {
+ expect(
+ renderStyle(
+ `${decoy} .earlier { rotate: 10deg; } .my-class { ${declarations} }`,
+ ),
+ ).toStrictEqual({ transform });
+});
+
+// Chromium 153, Firefox 155 and WebKit 26.6 read the third value of translate and scale as its z, which React Native has no axis for
+test.each([
+ ["translate: 10px 20px 30px;", [{ translateX: 10 }, { translateY: 20 }]],
+ [
+ "--t: 10px 20px 30px; translate: var(--t);",
+ [{ translateX: 10 }, { translateY: 20 }],
+ ],
+ [
+ "--t: 20px 30px; translate: 10px var(--t);",
+ [{ translateX: 10 }, { translateY: 20 }],
+ ],
+ ["scale: 2 3 4;", [{ scaleX: 2 }, { scaleY: 3 }]],
+ ["--s: 2 3 4; scale: var(--s);", [{ scaleX: 2 }, { scaleY: 3 }]],
+ ["--s: 3 4; scale: 2 var(--s);", [{ scaleX: 2 }, { scaleY: 3 }]],
+] as const)("%s renders its x and y", (declarations, transform) => {
+ expect(
+ renderStyle(
+ `${decoy} .earlier { translate: 1px 2px; scale: 5; } .my-class { translate: none; scale: none; ${declarations} }`,
+ ),
+ ).toStrictEqual({
+ transform: [
+ ...(declarations.includes("translate")
+ ? transform
+ : [{ translateX: 0 }, { translateY: 0 }]),
+ ...(declarations.includes("scale")
+ ? transform
+ : [{ scaleX: 1 }, { scaleY: 1 }]),
+ ],
+ });
+});
+
+// Chromium 153, Firefox 155 and WebKit 26.6: a value the property's grammar does not take is invalid at computed-value time, so the property is none (css-variables-1 §3.1)
+test.each([
+ "--r: x y 45deg; rotate: var(--r);",
+ "--r: 0 45deg 0 1; rotate: var(--r);",
+ "--t: 10px 20px 30%; translate: var(--t);",
+ "--t: 1px 2px 3px 4px; translate: var(--t);",
+ "--s: 2 3 4 5; scale: var(--s);",
+ "--s: 2 3 red; scale: var(--s);",
+ "--s: none 2; scale: var(--s);",
+])("%s leaves the property none", (declarations) => {
+ expect(
+ renderStyle(
+ `${decoy} .earlier { translate: 1px 2px; rotate: 10deg; scale: 5; transform: translateX(5px); } .my-class { ${declarations} }`,
+ ),
+ ).toStrictEqual({
+ transform: [
+ ...(declarations.includes("translate:")
+ ? []
+ : [{ translateX: 1 }, { translateY: 2 }]),
+ ...(declarations.includes("rotate:") ? [] : [{ rotateZ: "10deg" }]),
+ ...(declarations.includes("scale:")
+ ? []
+ : [{ scaleX: 5 }, { scaleY: 5 }]),
+ { translateX: 5 },
+ ],
+ });
+});
+
+// React Native's rotate keys turn only about an axis, so a substituted rotate about a vector off every axis is none
+test("--r: 1 1 0 45deg; rotate: var(--r); rotates by none", () => {
+ expect(
+ renderStyle(
+ `${decoy} .earlier { rotate: 10deg; } .my-class { --r: 1 1 0 45deg; rotate: var(--r); }`,
+ ),
+ ).toStrictEqual({});
+});
diff --git a/src/__tests__/native/variable-lists.test.tsx b/src/__tests__/native/variable-lists.test.tsx
index 3088e33c..f8cfbdb1 100644
--- a/src/__tests__/native/variable-lists.test.tsx
+++ b/src/__tests__/native/variable-lists.test.tsx
@@ -397,9 +397,9 @@ test.each<[string, readonly unknown[], readonly unknown[]]>([
test.each<[string, StyleDescriptor, unknown]>([
[
- "rotate() over three comma-separated arguments",
- [{}, "rotate", [["10deg"], ["20deg"], ["30deg"]]],
- [{ rotateX: "10deg" }, { rotateY: "20deg" }, { rotateZ: "30deg" }],
+ "translate() over two comma-separated arguments",
+ [{}, "translate", [[10], [20]]],
+ [{ translateX: 10 }, { translateY: 20 }],
],
["join() over one value", [{}, "join", "#123"], "#123"],
])("%s reads each argument", (_, descriptor, expected) => {
diff --git a/src/__tests__/vendor/tailwind/transform.test.ts b/src/__tests__/vendor/tailwind/transform.test.ts
index 2a7cf239..7d859046 100644
--- a/src/__tests__/vendor/tailwind/transform.test.ts
+++ b/src/__tests__/vendor/tailwind/transform.test.ts
@@ -26,7 +26,7 @@ describe("Transforms - Scale", () => {
expect(await renderCurrentTest()).toStrictEqual({
props: {
style: {
- transform: [{ scale: 0 }],
+ transform: [{ scaleX: 0 }, { scaleY: 0 }],
},
},
});
@@ -53,7 +53,7 @@ describe("Transforms - Scale", () => {
expect(await renderCurrentTest()).toStrictEqual({
props: {
style: {
- transform: [{ scale: 0.5 }],
+ transform: [{ scaleX: 0.5 }, { scaleY: 0.5 }],
},
},
});
@@ -233,11 +233,12 @@ describe("Transforms - Mixed", () => {
).toStrictEqual({
props: {
style: {
+ // css-transforms-2 §6: translate, then rotate, then the transform list
transform: [
- { skewY: "1deg" },
{ translateX: 3.5 },
{ translateY: 0 },
{ rotateZ: "90deg" },
+ { skewY: "1deg" },
],
},
},
diff --git a/src/compiler/compiler.ts b/src/compiler/compiler.ts
index d410171f..9082f589 100644
--- a/src/compiler/compiler.ts
+++ b/src/compiler/compiler.ts
@@ -5,6 +5,7 @@ import { debug } from "debug";
import {
type ContainerRule,
type CustomAtRules,
+ type Declaration,
type MediaRule,
type ParsedComponent,
type PropertyRule,
@@ -34,6 +35,7 @@ import {
reduceParseUnparsed,
round,
} from "./declarations";
+import { unparseIndividualTransform } from "./individual-transforms";
import { inlineVariables } from "./inline-variables";
import { extractKeyFrames } from "./keyframes";
import { lightningcssLoader } from "./lightningcss-loader";
@@ -190,10 +192,12 @@ export function compile(code: Buffer | string, options: CompilerOptions = {}) {
};
}
+ let countVariable: ((decl: Declaration) => void) | undefined;
+
if (options.inlineVariables !== false) {
const exclusionList: string[] = options.inlineVariables?.exclude ?? [];
- firstPassVisitor.Declaration = (decl) => {
+ countVariable = (decl) => {
if (
decl.property === "custom" &&
decl.value.name.startsWith("--") &&
@@ -212,6 +216,11 @@ export function compile(code: Buffer | string, options: CompilerOptions = {}) {
};
}
+ firstPassVisitor.Declaration = (decl) => {
+ countVariable?.(decl);
+ return unparseIndividualTransform(decl);
+ };
+
const { code: firstPass, warnings: firstPassWarnings } = lightningcss({
code: typeof code === "string" ? new TextEncoder().encode(code) : code,
include: Features.DoublePositionGradients | Features.ColorFunction,
diff --git a/src/compiler/declarations.ts b/src/compiler/declarations.ts
index 52be116b..1591d0ab 100644
--- a/src/compiler/declarations.ts
+++ b/src/compiler/declarations.ts
@@ -102,6 +102,12 @@ const unparsedRuntimeParsing = new Set([
"translate",
]);
+// css-transforms-2 §3: the translate and scale properties take an optional z, which the functions of the same name do not
+const INDIVIDUAL_TRANSFORM_RESOLVERS: ReadonlyMap = new Map([
+ ["scale", "individualScale"],
+ ["translate", "individualTranslate"],
+]);
+
const parsers: {
[K in Declaration["property"]]?: Parser;
} = {
@@ -736,146 +742,131 @@ function parseFont(
builder.addDescriptor("font-weight", parseFontWeight(value.weight, builder));
}
+type TransformFunction = Extract<
+ StyleFunction,
+ [Record, string, StyleDescriptor]
+>;
+
+// An argument React Native has no equivalent for leaves the declaration invalid there, and an invalid declaration is ignored (CSS 2.2 §4.2)
+function hasUnconvertibleArgument(
+ functions: readonly TransformFunction[],
+): boolean {
+ return functions.some(([, , argument]) => argument === undefined);
+}
+
function parseTransform(
{ value }: DeclarationType<"transform">,
builder: StylesheetBuilder,
) {
- builder.addDescriptor("transform", [
- {},
- "transform",
- value.flatMap((t): StyleDescriptor[] => {
- switch (t.type) {
- case "perspective":
- return [[{}, "perspective", parseLength(t.value, builder)]];
- case "translate":
- return [
- [
- {},
- "translateX",
- parseLengthOrCoercePercentageToRuntime(t.value[0], builder),
- ],
- [
- [
- {},
- "translateY",
- parseLengthOrCoercePercentageToRuntime(t.value[1], builder),
- ],
- ],
- ];
- case "translateX":
- return [
- [
- {},
- "translateX",
- parseLengthOrCoercePercentageToRuntime(t.value, builder),
- ],
- ];
- case "translateY":
- return [
- [
- {},
- "translateY",
- parseLengthOrCoercePercentageToRuntime(t.value, builder),
- ],
- ];
- case "rotate":
- return [[{}, "rotate", parseAngle(t.value, builder)]];
- case "rotateX":
- return [[{}, "rotateX", parseAngle(t.value, builder)]];
- case "rotateY":
- return [[{}, "rotateY", parseAngle(t.value, builder)]];
- case "rotateZ":
- return [[{}, "rotateZ", parseAngle(t.value, builder)]];
- case "scale":
- return [
- [{}, "scaleX", parseLength(t.value[0], builder)],
- [{}, "scaleY", parseLength(t.value[1], builder)],
- ];
- case "scaleX":
- return [[{}, "scaleX", parseLength(t.value, builder)]];
- case "scaleY":
- return [[{}, "scaleY", parseLength(t.value, builder)]];
- case "skew":
- return [
- [{}, "skewX", parseAngle(t.value[0], builder)],
- [{}, "skewY", parseAngle(t.value[1], builder)],
- ];
- case "skewX":
- return [[{}, "skewX", parseAngle(t.value, builder)]];
- case "skewY":
- return [[{}, "skewY", parseAngle(t.value, builder)]];
- case "translateZ":
- case "translate3d":
- case "scaleZ":
- case "scale3d":
- case "rotate3d":
- case "matrix":
- case "matrix3d":
- return [[]];
- }
- }),
- ]);
- return;
+ const functions = value.flatMap((t): TransformFunction[] => {
+ switch (t.type) {
+ case "perspective":
+ return [[{}, "perspective", parseLength(t.value, builder)]];
+ case "translate":
+ return [
+ [{}, "translateX", parseLength(t.value[0], builder)],
+ [{}, "translateY", parseLength(t.value[1], builder)],
+ ];
+ case "translateX":
+ return [[{}, "translateX", parseLength(t.value, builder)]];
+ case "translateY":
+ return [[{}, "translateY", parseLength(t.value, builder)]];
+ case "rotate":
+ return [[{}, "rotate", parseAngle(t.value, builder)]];
+ case "rotateX":
+ return [[{}, "rotateX", parseAngle(t.value, builder)]];
+ case "rotateY":
+ return [[{}, "rotateY", parseAngle(t.value, builder)]];
+ case "rotateZ":
+ return [[{}, "rotateZ", parseAngle(t.value, builder)]];
+ case "scale":
+ return [
+ [{}, "scaleX", parseLength(t.value[0], builder)],
+ [{}, "scaleY", parseLength(t.value[1], builder)],
+ ];
+ case "scaleX":
+ return [[{}, "scaleX", parseLength(t.value, builder)]];
+ case "scaleY":
+ return [[{}, "scaleY", parseLength(t.value, builder)]];
+ case "skew":
+ return [
+ [{}, "skewX", parseAngle(t.value[0], builder)],
+ [{}, "skewY", parseAngle(t.value[1], builder)],
+ ];
+ case "skewX":
+ return [[{}, "skewX", parseAngle(t.value, builder)]];
+ case "skewY":
+ return [[{}, "skewY", parseAngle(t.value, builder)]];
+ case "translateZ":
+ case "translate3d":
+ case "scaleZ":
+ case "scale3d":
+ case "rotate3d":
+ case "matrix":
+ case "matrix3d":
+ return [];
+ }
+ });
+
+ if (hasUnconvertibleArgument(functions)) {
+ return;
+ }
+
+ builder.addDescriptor("transform", [{}, "transform", functions]);
}
function parseTranslate(
{ value }: DeclarationType<"translate">,
builder: StylesheetBuilder,
) {
- builder.addDescriptor("translateX", [
- {},
- "translateX",
- parseTranslateProp(value, "x", builder),
- ]);
- builder.addDescriptor("translateY", [
- {},
- "translateY",
- parseTranslateProp(value, "y", builder),
- ]);
+ const translations: TransformFunction[] = [
+ [{}, "translateX", parseTranslateProp(value, "x", builder)],
+ [{}, "translateY", parseTranslateProp(value, "y", builder)],
+ ];
+
+ if (hasUnconvertibleArgument(translations)) {
+ return;
+ }
+
+ builder.addDescriptor("translate", translations);
}
function parseRotate(
{ value }: DeclarationType<"rotate">,
builder: StylesheetBuilder,
) {
+ const angle = parseAngle(value.angle, builder);
+ const rotations: TransformFunction[] = [];
+
if (value.x) {
- builder.addDescriptor("rotateX", [
- {},
- "rotateX",
- parseAngle(value.angle, builder),
- ]);
+ rotations.push([{}, "rotateX", angle]);
}
if (value.y) {
- builder.addDescriptor("rotateY", [
- {},
- "rotateY",
- parseAngle(value.angle, builder),
- ]);
+ rotations.push([{}, "rotateY", angle]);
}
if (value.z) {
- builder.addDescriptor("rotateZ", [
- {},
- "rotateZ",
- parseAngle(value.angle, builder),
- ]);
+ rotations.push([{}, "rotateZ", angle]);
}
+
+ if (hasUnconvertibleArgument(rotations)) {
+ return;
+ }
+
+ builder.addDescriptor(
+ "rotate",
+ rotations.length === 1 ? rotations[0] : rotations,
+ );
}
function parseScale(
{ value }: DeclarationType<"scale">,
builder: StylesheetBuilder,
) {
- builder.addDescriptor("scaleX", [
- {},
- "scaleX",
- parseScaleValue(value, "x", builder),
- ]);
- builder.addDescriptor("scaleY", [
- {},
- "scaleY",
- parseScaleValue(value, "y", builder),
+ builder.addDescriptor("scale", [
+ [{}, "scaleX", parseScaleValue(value, "x", builder)],
+ [{}, "scaleY", parseScaleValue(value, "y", builder)],
]);
}
@@ -989,7 +980,12 @@ export function parseUnparsedDeclaration(
if (property === "animation") {
builder.addDescriptor("animation", [{}, property, args]);
} else {
- builder.addDescriptor(property, [{}, toRNProperty(property), args, 1]);
+ builder.addDescriptor(property, [
+ {},
+ INDIVIDUAL_TRANSFORM_RESOLVERS.get(property) ?? toRNProperty(property),
+ args,
+ 1,
+ ]);
}
} else {
const value = parseUnparsed(declaration.value.value, builder, property);
@@ -1516,6 +1512,7 @@ export function parseLength(
switch (length.type) {
case "calc": {
// TODO: Add the calc polyfill
+ builder.addWarning("value", "calc()");
return undefined;
}
case "number": {
@@ -2408,13 +2405,6 @@ export function parseFontVariantCaps(
return undefined;
}
-export function parseLengthOrCoercePercentageToRuntime(
- value: Length | DimensionPercentageFor_LengthValue | NumberOrPercentage,
- builder: StylesheetBuilder,
-): StyleDescriptor {
- return parseLength(value, builder);
-}
-
export function parseGap(
declaration: DeclarationType<"gap" | "column-gap" | "row-gap">,
builder: StylesheetBuilder,
diff --git a/src/compiler/individual-transforms.ts b/src/compiler/individual-transforms.ts
new file mode 100644
index 00000000..2687cbcf
--- /dev/null
+++ b/src/compiler/individual-transforms.ts
@@ -0,0 +1,129 @@
+import type {
+ Declaration,
+ DimensionPercentageFor_LengthValue,
+ Length,
+ NumberOrPercentage,
+ Rotate,
+ Scale,
+ TokenOrValue,
+ Translate,
+} from "lightningcss";
+
+/**
+ * Carries `translate`, `rotate` and `scale` across the first pass as the tokens
+ * they were written as. lightningcss before
+ * https://github.com/parcel-bundler/lightningcss/pull/1340 folds a parsed one
+ * into `transform` when it serialises the rule, and passes an unparsed one
+ * through in place.
+ */
+export function unparseIndividualTransform(
+ declaration: Declaration,
+): Declaration | undefined {
+ switch (declaration.property) {
+ case "translate": {
+ const value = translateTokens(declaration.value);
+
+ return value
+ ? {
+ property: "unparsed",
+ value: { propertyId: { property: "translate" }, value },
+ }
+ : undefined;
+ }
+ case "rotate":
+ return {
+ property: "unparsed",
+ value: {
+ propertyId: { property: "rotate" },
+ value: rotateTokens(declaration.value),
+ },
+ };
+ case "scale":
+ return {
+ property: "unparsed",
+ value: {
+ propertyId: { property: "scale" },
+ value: scaleTokens(declaration.value),
+ },
+ };
+ default:
+ return undefined;
+ }
+}
+
+const WHITESPACE_TOKEN: TokenOrValue = {
+ type: "token",
+ value: { type: "white-space", value: " " },
+};
+
+const NONE_TOKENS: TokenOrValue[] = [
+ { type: "token", value: { type: "ident", value: "none" } },
+];
+
+function spaceSeparated(tokens: TokenOrValue[]): TokenOrValue[] {
+ return tokens.flatMap((token, index) =>
+ index === 0 ? [token] : [WHITESPACE_TOKEN, token],
+ );
+}
+
+function numberToken(value: number): TokenOrValue {
+ return { type: "token", value: { type: "number", value } };
+}
+
+// lightningcss holds a percentage as its fraction, in a token as in a value: 50% is 0.5
+function percentageToken(value: number): TokenOrValue {
+ return { type: "token", value: { type: "percentage", value } };
+}
+
+function numberOrPercentageToken(value: NumberOrPercentage): TokenOrValue {
+ return value.type === "number"
+ ? numberToken(value.value)
+ : percentageToken(value.value);
+}
+
+// No token holds a calc(), which React Native cannot take anyway: the compiler warns for one and ignores the declaration
+function lengthToken(
+ value: Length | DimensionPercentageFor_LengthValue,
+): TokenOrValue | undefined {
+ switch (value.type) {
+ case "value":
+ case "dimension":
+ return { type: "length", value: value.value };
+ case "percentage":
+ return percentageToken(value.value);
+ case "calc":
+ return undefined;
+ }
+}
+
+// A translate holding a calc() stays parsed, so it reaches the compiler's warning unless lightningcss folds it into a transform beside it
+function translateTokens(value: Translate): TokenOrValue[] | undefined {
+ if (value === "none") {
+ return NONE_TOKENS;
+ }
+
+ const x = lengthToken(value.x);
+ const y = lengthToken(value.y);
+ const z = lengthToken(value.z);
+
+ return x && y && z ? spaceSeparated([x, y, z]) : undefined;
+}
+
+function rotateTokens(value: Rotate): TokenOrValue[] {
+ return spaceSeparated([
+ numberToken(value.x),
+ numberToken(value.y),
+ numberToken(value.z),
+ { type: "angle", value: value.angle },
+ ]);
+}
+
+function scaleTokens(value: Scale): TokenOrValue[] {
+ return value === "none"
+ ? NONE_TOKENS
+ : spaceSeparated([
+ numberOrPercentageToken(value.x),
+ numberOrPercentageToken(value.y),
+ numberOrPercentageToken(value.z),
+ ]);
+}
diff --git a/src/native/objects.ts b/src/native/objects.ts
index 433bf774..d6b5e979 100644
--- a/src/native/objects.ts
+++ b/src/native/objects.ts
@@ -2,7 +2,6 @@
import { commaListItems } from "react-native-css/utilities";
import { ShortHandSymbol } from "../native/styles/constants";
-import { transformKeys } from "../native/styles/defaults";
export function getDeepPath(source: any, paths: string | string[] | false) {
if (!source) {
@@ -25,10 +24,6 @@ export function getDeepPath(source: any, paths: string | string[] | false) {
}
return target;
- } else if (transformKeys.has(paths)) {
- return Array.isArray(source?.transform)
- ? source.transform.find((t: any) => t[paths] !== undefined)
- : source.transform;
} else {
return source?.[paths];
}
@@ -64,23 +59,7 @@ export function applyValue(
value = undefined;
}
- if (transformKeys.has(prop)) {
- if (!Array.isArray(target.transform)) {
- target.transform = [];
- }
-
- const transformArray: Record[] = target.transform;
-
- // Remove any existing values
- target.transform = transformArray.filter((t) => !(prop in t));
-
- if (Array.isArray(value)) {
- target.transform.push(...value);
- } else {
- target.transform.push(value);
- }
- return;
- } else if (typeof value === "object" && value) {
+ if (typeof value === "object" && value) {
if (ShortHandSymbol in value) {
delete value[ShortHandSymbol];
Object.assign(target, value);
diff --git a/src/native/styles/calculate-props.ts b/src/native/styles/calculate-props.ts
index 28b9ed36..fbb2172d 100644
--- a/src/native/styles/calculate-props.ts
+++ b/src/native/styles/calculate-props.ts
@@ -2,6 +2,7 @@
import type {
InlineVariable,
StyleDeclaration,
+ StyleDescriptor,
StyleRule,
} from "react-native-css/compiler";
import { Specificity as S } from "react-native-css/utilities";
@@ -13,7 +14,6 @@ import {
type Getter,
type VariableContextValue,
} from "../reactivity";
-import { transformKeys } from "./defaults";
import { resolveValue } from "./resolve";
export function calculateProps(
@@ -31,7 +31,7 @@ export function calculateProps(
let important: Record | undefined;
const delayedStyles: (() => void)[] = [];
- const transformStyles: (() => void)[] = [];
+ const transforms: TransformRecord[] = [];
for (const rule of rules) {
if (VAR_SYMBOL in rule) {
@@ -50,9 +50,8 @@ export function calculateProps(
}
if (rule.d) {
- let topLevelTarget = rule.s?.[S.Important]
- ? (important ??= {})
- : (normal ??= {});
+ const isImportant = Boolean(rule.s?.[S.Important]);
+ let topLevelTarget = isImportant ? (important ??= {}) : (normal ??= {});
let target = topLevelTarget;
const ruleTarget = rule.target || "style";
@@ -71,10 +70,12 @@ export function calculateProps(
inlineVariables,
inheritedVariables,
delayedStyles,
- transformStyles,
+ transforms,
guards,
target,
topLevelTarget,
+ ruleTarget,
+ isImportant,
);
}
}
@@ -83,8 +84,15 @@ export function calculateProps(
delayedStyle();
}
- for (const transformStyle of transformStyles) {
- transformStyle();
+ if (transforms.length > 0) {
+ composeTransforms(transforms, (value) =>
+ resolveValue(value, get, {
+ inlineVariables,
+ inheritedVariables,
+ renderGuards: guards,
+ calculateProps,
+ }),
+ );
}
return {
@@ -94,16 +102,165 @@ export function calculateProps(
};
}
+// css-transforms-2 §6: an element's transform is its `translate`, then its `rotate`, then its `scale`, then its `transform` list
+const TRANSFORM_SLOTS = 4;
+
+// A transform property's cascade slot in composition order, or -1. This runs for every dynamic declaration
+function transformSlot(prop: string | number): number {
+ switch (prop) {
+ case "translate":
+ return 0;
+ case "rotate":
+ return 1;
+ case "scale":
+ return 2;
+ case "transform":
+ return 3;
+ default:
+ return -1;
+ }
+}
+
+/** A transform property's declaration, kept until every rule has been walked */
+interface TransformRecord {
+ readonly target: Record;
+ readonly path: string | readonly string[];
+ readonly important: boolean;
+ readonly slot: number;
+ readonly value: StyleDescriptor;
+}
+
+/** One style target's slots: the normal ones, then the !important ones */
+interface TransformGroup {
+ readonly path: string | readonly string[];
+ target: Record;
+ readonly slots: (StyleDescriptor | undefined)[];
+}
+
+function samePath(
+ a: string | readonly string[],
+ b: string | readonly string[],
+): boolean {
+ if (a === b) return true;
+ if (typeof a === "string" || typeof b === "string") return false;
+ if (a.length !== b.length) return false;
+ for (let i = 0; i < a.length; i++) {
+ if (a[i] !== b[i]) return false;
+ }
+ return true;
+}
+
+/**
+ * Each transform property of each style target is a cascade slot of its own,
+ * and the slots compose into one `transform`. Records arrive in cascade
+ * order, so a later one replaces an earlier one, and an !important slot
+ * replaces a normal one for the same path.
+ */
+function composeTransforms(
+ records: readonly TransformRecord[],
+ resolve: (value: StyleDescriptor) => unknown,
+) {
+ // One declaration, the usual case, has nothing to compose with
+ if (records.length === 1) {
+ const record = records[0]!;
+ const resolved = resolve(record.value);
+
+ if (resolved !== undefined && resolved !== null) {
+ const composed: unknown[] = [];
+ pushEntries(composed, resolved);
+ record.target.transform = composed;
+ }
+ return;
+ }
+
+ // Almost always one group, so a scan beats keying a Map by path
+ const groups: TransformGroup[] = [];
+
+ for (let r = 0; r < records.length; r++) {
+ const record = records[r]!;
+ let group: TransformGroup | undefined;
+
+ for (let g = 0; g < groups.length; g++) {
+ if (samePath(groups[g]!.path, record.path)) {
+ group = groups[g];
+ break;
+ }
+ }
+
+ if (group === undefined) {
+ group = {
+ path: record.path,
+ target: record.target,
+ slots: [
+ undefined,
+ undefined,
+ undefined,
+ undefined,
+ undefined,
+ undefined,
+ undefined,
+ undefined,
+ ],
+ };
+ groups.push(group);
+ }
+
+ if (record.important) {
+ // The important target is merged over the normal one, so it takes the composed list
+ group.target = record.target;
+ group.slots[record.slot + TRANSFORM_SLOTS] = record.value;
+ } else {
+ group.slots[record.slot] = record.value;
+ }
+ }
+
+ for (let g = 0; g < groups.length; g++) {
+ const group = groups[g]!;
+ let composed: unknown[] | undefined;
+
+ for (let slot = 0; slot < TRANSFORM_SLOTS; slot++) {
+ const important = group.slots[slot + TRANSFORM_SLOTS];
+ const value = important !== undefined ? important : group.slots[slot];
+
+ if (value === undefined) {
+ continue;
+ }
+
+ const resolved = resolve(value);
+
+ // A property that resolves to no value is `none` (css-variables-1 §3.1)
+ if (resolved !== undefined && resolved !== null) {
+ pushEntries((composed ??= []), resolved);
+ }
+ }
+
+ if (composed !== undefined) {
+ group.target.transform = composed;
+ }
+ }
+}
+
+// A resolver returns a group for a two-axis function, so entries are spread into the list
+function pushEntries(entries: unknown[], value: unknown) {
+ if (Array.isArray(value)) {
+ for (let i = 0; i < value.length; i++) pushEntries(entries, value[i]);
+ } else {
+ entries.push(value);
+ }
+}
+
export function applyDeclarations(
get: Getter,
declarations: StyleDeclaration[],
inlineVariables: InlineVariable,
inheritedVariables: VariableContextValue,
delayedStyles: (() => void)[] = [],
- transformStyles: (() => void)[] = [],
+ transforms: TransformRecord[] = [],
guards: RenderGuard[] = [],
target: Record = {},
topLevelTarget = target,
+ path: string | readonly string[] = "style",
+ important = false,
) {
const originalTarget = target;
@@ -162,9 +319,16 @@ export function applyDeclarations(
prop = propPath;
}
+ const slot = target === originalTarget ? transformSlot(prop) : -1;
+
+ if (slot !== -1) {
+ transforms.push({ target, path, important, slot, value });
+ continue;
+ }
+
const shouldDelay = declaration[2];
- if (shouldDelay || transformKeys.has(prop)) {
+ if (shouldDelay) {
/**
* We need to delay the resolution of this value until after all
* styles have been calculated. But another style might override
@@ -175,11 +339,11 @@ export function applyDeclarations(
* mutate the props object and not create a new one
*/
const originalValue = value;
- // This needs to be a object with the [prop] so we can discover in transform arrays
value = { [prop]: true };
- if (transformKeys.has(prop)) {
- transformStyles.push(() => {
+ delayedStyles.push(() => {
+ if (getDeepPath(target, prop) === value) {
+ delete target[prop];
value = resolveValue(originalValue, get, {
inlineVariables,
inheritedVariables,
@@ -187,21 +351,8 @@ export function applyDeclarations(
calculateProps,
});
applyValue(target, prop, value);
- });
- } else {
- delayedStyles.push(() => {
- if (getDeepPath(target, prop) === value) {
- delete target[prop];
- value = resolveValue(originalValue, get, {
- inlineVariables,
- inheritedVariables,
- renderGuards: guards,
- calculateProps,
- });
- applyValue(target, prop, value);
- }
- });
- }
+ }
+ });
} else {
value = resolveValue(value, get, {
inlineVariables,
diff --git a/src/native/styles/functions/transform-functions.ts b/src/native/styles/functions/transform-functions.ts
index 851f469f..8c04a8a1 100644
--- a/src/native/styles/functions/transform-functions.ts
+++ b/src/native/styles/functions/transform-functions.ts
@@ -1,90 +1,83 @@
import type { StyleDescriptor } from "react-native-css/compiler";
-import { isStyleDescriptorArray } from "react-native-css/utilities";
+import {
+ commaListItems,
+ isStyleDescriptorArray,
+} from "react-native-css/utilities";
import type { SimpleResolveValue, StyleFunctionResolver } from "../resolve";
import { scaleFactor } from "../scale-factor";
+// A component left without a valid value makes the declaration invalid at computed-value time (css-variables-1 §3.1), which null carries
export const scale: StyleFunctionResolver = (resolveValue, descriptor) => {
- const args = descriptor[2];
+ const operands = resolveOperands(resolveValue, descriptor[2]);
- if (!isStyleDescriptorArray(args)) {
- return { scale: scaleFactor(resolveValue(args)) };
- }
-
- const x = scaleFactor(argument(resolveValue, args[0]));
- const y = scaleFactor(argument(resolveValue, args[1]));
-
- const isXValid = typeof x === "string" || typeof x === "number";
- const isYValid = typeof y === "string" || typeof y === "number";
+ return scalePair(operands, operands.length);
+};
- if (isXValid && isYValid) {
- return x === y ? { scale: x } : [{ scaleX: x }, { scaleY: y }];
- } else if (isXValid) {
- return { scale: x };
- } else if (isYValid) {
- return { scaleY: y };
- }
+export const rotate: StyleFunctionResolver = (resolveValue, descriptor) => {
+ const operands = resolveOperands(resolveValue, descriptor[2]);
+ const angle = operands[0];
- return;
+ return operands.length === 1 && isTransformComponent(angle)
+ ? { rotate: angle }
+ : null;
};
-export const rotate: StyleFunctionResolver = (resolveValue, descriptor) => {
- const args = descriptor[2];
+export const translate: StyleFunctionResolver = (resolveValue, descriptor) => {
+ const operands = resolveOperands(resolveValue, descriptor[2]);
- if (!isStyleDescriptorArray(args)) {
- return { rotate: resolveValue(args) };
- }
+ return translatePair(operands, operands.length);
+};
- const x = argument(resolveValue, args[0]);
- const y = argument(resolveValue, args[1]);
- const z = argument(resolveValue, args[2]);
-
- const isXValid = typeof x === "string" || typeof x === "number";
- const isYValid = typeof y === "string" || typeof y === "number";
- const isZValid = typeof z === "string" || typeof z === "number";
-
- if (isXValid && isYValid && isZValid) {
- return [{ rotateX: x }, { rotateY: y }, { rotateZ: z }];
- } else if (isXValid && isYValid) {
- return [{ rotateX: x }, { rotateY: y }];
- } else if (isXValid && isZValid) {
- return [{ rotateX: x }, { rotateZ: z }];
- } else if (isYValid && isZValid) {
- return [{ rotateY: y }, { rotateZ: z }];
- } else if (isXValid) {
- return { rotateX: x };
- } else if (isYValid) {
- return { rotateY: y };
- } else if (isZValid) {
- return { rotateZ: z };
- }
+// css-transforms-2 §3: `translate: none | [ ?]?`, and React Native has no z axis to move along
+export const individualTranslate: StyleFunctionResolver = (
+ resolveValue,
+ descriptor,
+) => {
+ const operands = resolveOperands(resolveValue, descriptor[2]);
+ const z = operands.length > 2 ? operands[2] : 0;
+
+ return operands.length <= 3 && typeof z === "number"
+ ? translatePair(operands, Math.min(operands.length, 2))
+ : null;
+};
- return;
+// css-transforms-2 §3: `scale: none | [ | ]{1,3}`, and React Native has no z axis to scale along
+export const individualScale: StyleFunctionResolver = (
+ resolveValue,
+ descriptor,
+) => {
+ const operands = resolveOperands(resolveValue, descriptor[2]);
+ const z = operands.length > 2 ? operands[2] : 1;
+
+ return operands.length <= 3 && scaleFactor(z) !== null
+ ? scalePair(operands, Math.min(operands.length, 2))
+ : null;
};
-export const translate: StyleFunctionResolver = (resolveValue, descriptor) => {
- const args = descriptor[2];
+// The first `count` operands, so a caller can leave out a z without copying the list
+function scalePair(operands: readonly unknown[], count: number): unknown {
+ const x = scaleFactor(operands[0]);
+ const y = count > 1 ? scaleFactor(operands[1]) : x;
- if (!isStyleDescriptorArray(args)) {
- return;
+ if (count > 2 || x === null || y === null) {
+ return null;
}
- const x = argument(resolveValue, args[0]);
- const y = argument(resolveValue, args[1]);
+ return [{ scaleX: x }, { scaleY: y }];
+}
- const isXValid = typeof x === "string" || typeof x === "number";
- const isYValid = typeof y === "string" || typeof y === "number";
+// `translate(x)` is `translate(x, 0)` (css-transforms-1 §9)
+function translatePair(operands: readonly unknown[], count: number): unknown {
+ const x = operands[0];
+ const y = count > 1 ? operands[1] : 0;
- if (isXValid && isYValid) {
- return [{ translateX: x }, { translateY: y }];
- } else if (isXValid) {
- return { translateX: x };
- } else if (isYValid) {
- return { translateY: y };
+ if (count > 2 || !isTransformComponent(x) || !isTransformComponent(y)) {
+ return null;
}
- return;
-};
+ return [{ translateX: x }, { translateY: y }];
+}
/** A comma-separated argument list holds each argument as the array of its tokens */
function argument(resolveValue: SimpleResolveValue, arg: StyleDescriptor) {
@@ -98,3 +91,42 @@ function argument(resolveValue: SimpleResolveValue, arg: StyleDescriptor) {
: arg,
);
}
+
+// A var() substitutes its tokens before the grammar reads them, so it can supply one operand, several, or the whole list (css-variables-1 §3)
+function resolveOperands(
+ resolveValue: SimpleResolveValue,
+ args: StyleDescriptor,
+): unknown[] {
+ const operands: unknown[] = [];
+
+ if (isStyleDescriptorArray(args)) {
+ for (const arg of args) {
+ pushOperand(operands, argument(resolveValue, arg));
+ }
+ } else {
+ // A lone var()'s comma-separated list supplies its items as the operands
+ pushOperand(operands, commaListItems(resolveValue(args)));
+ }
+
+ return operands;
+}
+
+function pushOperand(operands: unknown[], operand: unknown) {
+ if (Array.isArray(operand)) {
+ for (const item of operand as unknown[]) operands.push(item);
+ } else {
+ operands.push(operand);
+ }
+}
+
+// A number, or a dimension such as "45deg" or "-50%". A keyword such as none
+// from a var() is not one: React Native throws on it, and the property is none
+function isTransformComponent(value: unknown): value is string | number {
+ if (typeof value === "number") return true;
+ if (typeof value !== "string") return false;
+
+ const first = value.charCodeAt(0);
+ return (
+ (first >= 48 && first <= 57) || first === 45 || first === 43 || first === 46
+ );
+}
diff --git a/src/native/styles/resolve.ts b/src/native/styles/resolve.ts
index e68f779a..dbc4e3a8 100644
--- a/src/native/styles/resolve.ts
+++ b/src/native/styles/resolve.ts
@@ -123,16 +123,16 @@ export function resolveValue(
) as StyleDescriptor;
} else if (transformKeys.has(name)) {
// translate, rotate, scale, etc.
- let resolved = simpleResolve(value[2], castToArray);
+ const resolved = simpleResolve(value[2], castToArray);
// CSS scale percentages describe a factor, unlike translation percentages.
- if (
- (name === "scaleX" || name === "scaleY" || name === "scale") &&
- typeof resolved === "string" &&
- resolved.endsWith("%")
- ) {
- resolved = scaleFactor(resolved);
- }
- return { [name]: resolved };
+ const component =
+ name === "scaleX" || name === "scaleY" || name === "scale"
+ ? scaleFactor(resolved)
+ : resolved;
+
+ return component === undefined || component === null
+ ? null
+ : { [name]: component };
} else {
let args = simpleResolve(value[2], castToArray);
diff --git a/src/native/styles/scale-factor.ts b/src/native/styles/scale-factor.ts
index 5d30789a..f8fe9d44 100644
--- a/src/native/styles/scale-factor.ts
+++ b/src/native/styles/scale-factor.ts
@@ -1,6 +1,9 @@
-export function scaleFactor(value: unknown) {
- if (typeof value === "string" && value.endsWith("%")) {
- return Number(value.slice(0, -1)) / 100;
- }
- return value;
+// React Native takes a scale only as a number, and its transform validator throws on anything else
+export function scaleFactor(value: unknown): number | null {
+ const factor =
+ typeof value === "string" && value.endsWith("%")
+ ? Number(value.slice(0, -1)) / 100
+ : value;
+
+ return typeof factor === "number" ? factor : null;
}
diff --git a/src/native/styles/shorthands/transform.ts b/src/native/styles/shorthands/transform.ts
index ef603dd8..386c85f8 100644
--- a/src/native/styles/shorthands/transform.ts
+++ b/src/native/styles/shorthands/transform.ts
@@ -1,3 +1,5 @@
+import { isStyleDescriptorArray } from "react-native-css/utilities";
+
import type { StyleFunctionResolver } from "../resolve";
/**
@@ -8,16 +10,39 @@ export const transform: StyleFunctionResolver = (
resolveValue,
transformDescriptor,
) => {
- const transforms = resolveValue(transformDescriptor[2]);
-
- if (Array.isArray(transforms)) {
- return transforms.filter(
- (transform) => transform !== undefined && transform !== "initial",
- ) as unknown;
- } else if (transforms) {
- // If it's a single transform, wrap it in an array
- return [transforms];
- } else {
- return;
+ const args = transformDescriptor[2];
+ const entries: unknown[] = [];
+
+ // Anything but a transform entry, null included, leaves the declaration invalid at computed-value time, so the transform is none (css-variables-1 §3.1)
+ if (!isStyleDescriptorArray(args)) {
+ return appendEntries(entries, resolveValue(args)) ? entries : [];
+ }
+
+ // Each function in turn, rather than resolving the list into an array to copy again
+ for (const arg of args) {
+ if (!appendEntries(entries, resolveValue(arg))) return [];
}
+
+ return entries;
};
+
+// A group from a resolver and the list a var() fallback holds each nest a level, while React Native takes a flat list of single-key objects. Returns false for anything but an entry
+function appendEntries(entries: unknown[], value: unknown): boolean {
+ if (Array.isArray(value)) {
+ for (const item of value as unknown[]) {
+ if (!appendEntries(entries, item)) return false;
+ }
+ return true;
+ }
+
+ if (value === undefined || value === "initial") {
+ return true;
+ }
+
+ if (typeof value === "object" && value !== null) {
+ entries.push(value);
+ return true;
+ }
+
+ return false;
+}