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; +}