react-native-css 3.0.0-nightly.df0f885 → 3.0.0-preview.0

package/src/runtime/native/styles/calculate-props.ts

@@ -4,13 +4,14 @@ import type {
   StyleDeclaration,
   StyleRule,
 } from "../../../compiler";
-import { applyValue, Specificity as S } from "../../utils";
+import { applyValue, getDeepPath, Specificity as S } from "../../utils";
 import type { RenderGuard } from "../conditions/guards";
 import {
   VAR_SYMBOL,
   type Getter,
   type VariableContextValue,
 } from "../reactivity";
+import { transformKeys } from "./defaults";
 import { resolveValue } from "./resolve";
 
 export function calculateProps(
@@ -28,6 +29,7 @@ export function calculateProps(
   let important: Record<string, any> | undefined;
 
   const delayedStyles: (() => void)[] = [];
+  const transformStyles: (() => void)[] = [];
 
   for (const rule of rules) {
     if (VAR_SYMBOL in rule) {
@@ -67,6 +69,7 @@ export function calculateProps(
         inlineVariables,
         inheritedVariables,
         delayedStyles,
+        transformStyles,
         guards,
         target,
         topLevelTarget,
@@ -78,6 +81,10 @@ export function calculateProps(
     delayedStyle();
   }
 
+  for (const transformStyle of transformStyles) {
+    transformStyle();
+  }
+
   return {
     normal,
     guards,
@@ -91,6 +98,7 @@ export function applyDeclarations(
   inlineVariables: InlineVariable,
   inheritedVariables: VariableContextValue,
   delayedStyles: (() => void)[] = [],
+  transformStyles: (() => void)[] = [],
   guards: RenderGuard[] = [],
   target: Record<string, any> = {},
   topLevelTarget = target,
@@ -103,42 +111,66 @@ export function applyDeclarations(
       // Dynamic styles
       let value: any = declaration[0];
       let propPath = declaration[1];
-      let prop = "";
+      let prop: string;
+
+      if (Array.isArray(propPath)) {
+        const [first, ...rest] = propPath;
 
-      if (typeof propPath === "string") {
-        if (propPath.startsWith("^")) {
-          propPath = propPath.slice(1);
-          target = topLevelTarget[propPath] ??= {};
+        if (!first) {
+          continue;
         }
-        prop = propPath;
-      } else {
-        for (prop of propPath) {
-          if (prop.startsWith("^")) {
-            prop = prop.slice(1);
-            target = topLevelTarget[prop] ??= {};
-          } else {
-            target = target[prop] ??= {};
+
+        const final = rest.pop();
+
+        if (final) {
+          if (first !== "*") {
+            topLevelTarget[first] ??= {};
+            target = topLevelTarget[first];
+          }
+
+          for (prop of rest) {
+            target[prop] ??= {};
+            target = target[prop];
           }
+
+          prop = final;
+        } else {
+          target = topLevelTarget;
+          prop = first;
         }
+      } else {
+        prop = propPath;
       }
 
-      if (Array.isArray(value)) {
-        const shouldDelay = declaration[2];
-
-        if (shouldDelay) {
-          /**
-           * We need to delay the resolution of this value until after all
-           * styles have been calculated. But another style might override
-           * this value. So we set a placeholder value and only override
-           * if the placeholder is preserved
-           *
-           * This also ensures the props exist, so setValue will properly
-           * mutate the props object and not create a new one
-           */
-          const originalValue = value;
-          value = {};
+      const shouldDelay = declaration[2];
+
+      if (shouldDelay || transformKeys.has(prop)) {
+        /**
+         * We need to delay the resolution of this value until after all
+         * styles have been calculated. But another style might override
+         * this value. So we set a placeholder value and only override
+         * if the placeholder is preserved
+         *
+         * This also ensures the props exist, so setValue will properly
+         * 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(() => {
+            value = resolveValue(originalValue, get, {
+              inlineVariables,
+              inheritedVariables,
+              renderGuards: guards,
+              calculateProps,
+            });
+            applyValue(target, prop, value);
+          });
+        } else {
           delayedStyles.push(() => {
-            if (target[prop] === value) {
+            if (getDeepPath(target, prop) === value) {
               delete target[prop];
               value = resolveValue(originalValue, get, {
                 inlineVariables,
@@ -149,17 +181,17 @@ export function applyDeclarations(
               applyValue(target, prop, value);
             }
           });
-        } else {
-          value = resolveValue(value, get, {
-            inlineVariables,
-            inheritedVariables,
-            renderGuards: guards,
-            calculateProps,
-          });
         }
-
-        applyValue(target, prop, value);
+      } else {
+        value = resolveValue(value, get, {
+          inlineVariables,
+          inheritedVariables,
+          renderGuards: guards,
+          calculateProps,
+        });
       }
+
+      applyValue(target, prop, value);
     }
   }
 }

package/src/runtime/native/styles/defaults.ts

@@ -1,5 +1,6 @@
 /* eslint-disable */
 export const transformKeys = new Set([
+  "translate",
   "translateX",
   "translateY",
   "scale",

package/src/runtime/native/styles/functions/animation-timing.ts

@@ -0,0 +1,44 @@
+import type { StyleFunctionResolver } from "../resolve";
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+const advancedTimingFunctions: Record<
+  string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  () => (...args: any[]) => unknown
+> = {
+  cubicBezier: () => {
+    return (
+      require("react-native-reanimated") as typeof import("react-native-reanimated")
+    ).cubicBezier;
+  },
+  steps: () => {
+    return (
+      require("react-native-reanimated") as typeof import("react-native-reanimated")
+    ).steps;
+  },
+};
+
+const timingFunctionResolver: StyleFunctionResolver = (resolveValue, value) => {
+  const name = value[1];
+  const resolver = advancedTimingFunctions[name];
+
+  if (!resolver) {
+    return;
+  }
+
+  const args = resolveValue(value[2]);
+
+  if (!Array.isArray(args)) {
+    return;
+  }
+
+  const fn = resolver();
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  const result = fn(...args);
+
+  return result;
+};
+
+export const cubicBezier = timingFunctionResolver;
+export const steps = timingFunctionResolver;

package/src/runtime/native/styles/functions/calc.ts

@@ -0,0 +1,121 @@
+import type { StyleFunctionResolver } from "../resolve";
+
+interface Value {
+  value: number;
+  isPercent: boolean;
+}
+
+const precedence: Record<string, number> = { "+": 1, "-": 1, "*": 2, "/": 2 };
+
+export const calc: StyleFunctionResolver = (resolveValue, func) => {
+  const tokens = resolveValue(func[2]);
+
+  if (!Array.isArray(tokens)) {
+    return tokens;
+  }
+
+  // --- Step 1: Convert to RPN (Shunting-Yard) ---
+  const output: (string | Value)[] = [];
+  const ops: string[] = [];
+
+  for (const t of tokens) {
+    if (typeof t === "number") {
+      output.push({ value: round(t), isPercent: false });
+    } else if (typeof t === "string") {
+      if (t.endsWith("%")) {
+        const num = parseFloat(t.slice(0, -1));
+        if (Number.isNaN(num)) return undefined;
+        output.push({ value: round(num / 100), isPercent: true });
+      } else if (t === "+" || t === "-" || t === "*" || t === "/") {
+        while (
+          ops.length &&
+          (ops[ops.length - 1] === "+" ||
+            ops[ops.length - 1] === "-" ||
+            ops[ops.length - 1] === "*" ||
+            ops[ops.length - 1] === "/") &&
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          (precedence[ops[ops.length - 1]!] ?? 0) >= (precedence[t] ?? 0)
+        ) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          output.push(ops.pop()!);
+        }
+        ops.push(t);
+      } else if (t === "(") {
+        ops.push(t);
+      } else if (t === ")") {
+        while (ops.length && ops[ops.length - 1] !== "(") {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          output.push(ops.pop()!);
+        }
+        if (ops.pop() !== "(") return undefined; // mismatched parens
+      } else {
+        return undefined; // invalid token
+      }
+    } else {
+      return undefined;
+    }
+  }
+  while (ops.length) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const op = ops.pop()!;
+    if (op === "(" || op === ")") return undefined;
+    output.push(op);
+  }
+
+  // --- Step 2: Evaluate RPN ---
+  const stack: Value[] = [];
+  for (const t of output) {
+    if (typeof t !== "string") {
+      stack.push(t);
+    } else {
+      const b = stack.pop();
+      const a = stack.pop();
+      if (!a || !b) return undefined;
+
+      const res: Value = { value: 0, isPercent: false };
+
+      switch (t) {
+        case "+":
+        case "-": {
+          if (a.isPercent !== b.isPercent) return undefined; // cannot mix
+          res.isPercent = a.isPercent;
+          res.value =
+            t === "+" ? round(a.value + b.value) : round(a.value - b.value);
+          break;
+        }
+        case "*": {
+          if (a.isPercent && b.isPercent) return undefined; // ambiguous
+          res.isPercent = a.isPercent || b.isPercent;
+          res.value = round(a.value * b.value);
+          break;
+        }
+        case "/": {
+          if (b.value === 0) return undefined;
+          if (a.isPercent && b.isPercent) {
+            // % / % → plain number ratio
+            res.isPercent = false;
+            res.value = round(a.value / b.value);
+          } else {
+            res.isPercent = a.isPercent || b.isPercent;
+            res.value = round(a.value / b.value);
+          }
+          break;
+        }
+      }
+      stack.push(res);
+    }
+  }
+
+  if (stack.length !== 1) return undefined;
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const final = stack[0]!;
+  if (final.isPercent) {
+    return `${final.value * 100}%`;
+  }
+  return final.value;
+};
+
+function round(number: number) {
+  return Math.round((number + Number.EPSILON) * 10000) / 10000;
+}

package/src/runtime/native/styles/{filters.ts → functions/filters.ts}

@@ -1,6 +1,6 @@
-import { isStyleDescriptorArray } from "../../utils";
-import type { StyleFunctionResolver } from "./resolve";
-import { shorthandHandler } from "./shorthand";
+import { isStyleDescriptorArray } from "../../../utils";
+import type { StyleFunctionResolver } from "../resolve";
+import { shorthandHandler } from "../shorthands/_handler";
 
 export const blur: StyleFunctionResolver = (resolveValue, value) => {
   const args = resolveValue(value[2]);

package/src/runtime/native/styles/functions/index.ts

@@ -0,0 +1,7 @@
+export * from "./animation-timing";
+export * from "./calc";
+export * from "./filters";
+export * from "./numeric-functions";
+export * from "./platform-functions";
+export * from "./string-functions";
+export * from "./transform-functions";

package/src/runtime/native/styles/functions/numeric-functions.ts

@@ -0,0 +1,38 @@
+import type { StyleFunctionResolver } from "../resolve";
+
+export const max: StyleFunctionResolver = (resolveValue, value) => {
+  const args = resolveValue(value[2]);
+
+  if (!Array.isArray(args) || args.some((arg) => typeof arg !== "number")) {
+    return;
+  }
+
+  return Math.max(...(args as number[]));
+};
+
+export const min: StyleFunctionResolver = (resolveValue, value) => {
+  const args = resolveValue(value[2]);
+
+  if (!Array.isArray(args) || args.some((arg) => typeof arg !== "number")) {
+    return;
+  }
+
+  return Math.min(...(args as number[]));
+};
+
+export const clamp: StyleFunctionResolver = (resolveValue, value) => {
+  const args = resolveValue(value[2]);
+
+  const [clampValue, min, max] = args as number[];
+
+  if (
+    !Array.isArray(args) ||
+    typeof clampValue !== "number" ||
+    typeof min !== "number" ||
+    typeof max !== "number"
+  ) {
+    return;
+  }
+
+  return Math.min(Math.max(clampValue, min), max);
+};

package/src/runtime/native/styles/{platform-functions.ts → functions/platform-functions.ts}

@@ -1,6 +1,6 @@
 import { PixelRatio, PlatformColor, StyleSheet } from "react-native";
 
-import type { StyleFunctionResolver } from "./resolve";
+import type { StyleFunctionResolver } from "../resolve";
 
 export const platformColor: StyleFunctionResolver = (resolveValue, value) => {
   const color: unknown = resolveValue(value[2]);
@@ -25,7 +25,7 @@ export const fontScale: StyleFunctionResolver = () => {
   return PixelRatio.getFontScale();
 };
 
-export const pixelSizeForLayoutSize: StyleFunctionResolver = (
+export const getPixelSizeForLayoutSize: StyleFunctionResolver = (
   resolveValue,
   value,
 ) => {

package/src/runtime/native/styles/functions/string-functions.ts

@@ -0,0 +1,22 @@
+import type { StyleFunctionResolver } from "../resolve";
+
+export const join: StyleFunctionResolver = (resolveValue, value) => {
+  const args = resolveValue(value[2]);
+
+  if (!Array.isArray(args)) {
+    return args;
+  }
+
+  const array: unknown = args[0];
+  const separator: unknown = args[1] ?? ",";
+
+  if (!Array.isArray(array)) {
+    return array;
+  }
+
+  if (!separator || typeof separator !== "string") {
+    return array.join();
+  }
+
+  return array.join(separator);
+};

package/src/runtime/native/styles/functions/transform-functions.ts

@@ -0,0 +1,84 @@
+import { isStyleDescriptorArray } from "../../../utils";
+import type { StyleFunctionResolver } from "../resolve";
+
+export const scale: StyleFunctionResolver = (resolveValue, descriptor) => {
+  const args = descriptor[2];
+
+  if (!isStyleDescriptorArray(args)) {
+    return { scale: resolveValue(args) };
+  }
+
+  const x = resolveValue(args[0]);
+  const y = resolveValue(args[1]);
+
+  const isXValid = typeof x === "string" || typeof x === "number";
+  const isYValid = typeof y === "string" || typeof y === "number";
+
+  if (isXValid && isYValid) {
+    return x === y ? { scale: x } : [{ scaleX: x }, { scaleY: y }];
+  } else if (isXValid) {
+    return { scaleX: x };
+  } else if (isYValid) {
+    return { scaleY: y };
+  }
+
+  return;
+};
+
+export const rotate: StyleFunctionResolver = (resolveValue, descriptor) => {
+  const args = descriptor[2];
+
+  if (!isStyleDescriptorArray(args)) {
+    return { rotate: resolveValue(args) };
+  }
+
+  const x = resolveValue(args[0]);
+  const y = resolveValue(args[1]);
+  const z = 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 };
+  }
+
+  return;
+};
+
+export const translate: StyleFunctionResolver = (resolveValue, descriptor) => {
+  const args = descriptor[2];
+
+  if (!isStyleDescriptorArray(args)) {
+    return;
+  }
+
+  const x = resolveValue(args[0]);
+  const y = resolveValue(args[1]);
+
+  const isXValid = typeof x === "string" || typeof x === "number";
+  const isYValid = typeof y === "string" || typeof y === "number";
+
+  if (isXValid && isYValid) {
+    return [{ translateX: x }, { translateY: y }];
+  } else if (isXValid) {
+    return { translateX: x };
+  } else if (isYValid) {
+    return { translateY: y };
+  }
+
+  return;
+};

package/src/runtime/native/styles/resolve.ts

@@ -7,34 +7,10 @@ import type {
 } from "../../../compiler";
 import type { RenderGuard } from "../conditions/guards";
 import { type Getter, type VariableContextValue } from "../reactivity";
-import { animation, timingFunctionResolver } from "./animation";
-import { border } from "./border";
-import { boxShadow } from "./box-shadow";
-import { calc } from "./calc";
 import type { calculateProps } from "./calculate-props";
 import { transformKeys } from "./defaults";
-import {
-  blur,
-  brightness,
-  contrast,
-  dropShadow,
-  grayscale,
-  hueRotate,
-  invert,
-  opacity,
-  saturate,
-  sepia,
-} from "./filters";
-import {
-  fontScale,
-  hairlineWidth,
-  pixelRatio,
-  pixelSizeForLayoutSize,
-  platformColor,
-  roundToNearestPixel,
-} from "./platform-functions";
-import { textShadow } from "./text-shadow";
-import { transform } from "./transform";
+import * as functions from "./functions";
+import * as shorthands from "./shorthands";
 import { em, rem, vh, vw } from "./units";
 import { varResolver } from "./variables";
 
@@ -57,34 +33,12 @@ export type StyleResolver = (
   options: ResolveValueOptions,
 ) => unknown;
 
-const functions: Record<string, StyleFunctionResolver> = {
-  "@animation": animation,
-  "@border": border,
-  "@boxShadow": boxShadow,
-  "@textShadow": textShadow,
-  "@transform": transform,
-  "animationName": animation,
-  "cubic-bezier": timingFunctionResolver,
-  "steps": timingFunctionResolver,
-  "hue-rotate": hueRotate,
-  "drop-shadow": dropShadow,
-  blur,
-  brightness,
-  calc,
-  contrast,
+const functionResolvers = {
+  ...shorthands,
+  ...functions,
+  animationName: shorthands.animation,
   em,
-  fontScale,
-  grayscale,
-  hairlineWidth,
-  invert,
-  opacity,
-  pixelRatio,
-  pixelSizeForLayoutSize,
-  platformColor,
   rem,
-  roundToNearestPixel,
-  saturate,
-  sepia,
   vh,
   vw,
 };
@@ -116,10 +70,16 @@ export function resolveValue(
     case "number":
     case "boolean":
       return value;
-    case "string":
-      return value.endsWith("px") // Inline vars() might set a value with a px suffix
-        ? parseInt(value.slice(0, -2), 10)
-        : value;
+    case "string": {
+      if (value === "unset") {
+        return null;
+      } else if (value.endsWith("px")) {
+        // Inline vars() might set a value with a px suffix
+        return parseInt(value.slice(0, -2), 10);
+      } else {
+        return value;
+      }
+    }
     case "object": {
       if (!Array.isArray(value)) {
         return value;
@@ -145,8 +105,8 @@ export function resolveValue(
 
       if (name === "var") {
         return varResolver(simpleResolve, value, get, options);
-      } else if (name in functions) {
-        const fn = functions[name];
+      } else if (name in functionResolvers) {
+        const fn = functionResolvers[name as keyof typeof functionResolvers];
 
         if (typeof fn !== "function") {
           throw new Error(`Unknown function: ${name}`);
@@ -160,11 +120,7 @@ export function resolveValue(
         ) as StyleDescriptor;
       } else if (transformKeys.has(name)) {
         // translate, rotate, scale, etc.
-        const args = value[2];
-        return simpleResolve(args, castToArray);
-      } else if (transformKeys.has(name.slice(1))) {
-        // @translate, @rotate, @scale, etc.
-        return { [name.slice(1)]: simpleResolve(value[2], castToArray) };
+        return { [name]: simpleResolve(value[2], castToArray) };
       } else {
         let args = simpleResolve(value[2], castToArray);
 
@@ -178,6 +134,7 @@ export function resolveValue(
               }
               return arg;
             })
+            .filter((value) => value !== "/")
             .join(", ");
 
           if (name === "radial-gradient") {

package/src/runtime/native/styles/{shorthand.ts → shorthands/_handler.ts}

@@ -1,9 +1,9 @@
 /* eslint-disable */
-import { setDeepPath } from "../../utils/objects";
-import { isStyleDescriptorArray } from "../../utils/style-value";
-import { ShortHandSymbol } from "./constants";
-import { defaultValues } from "./defaults";
-import type { StyleResolver } from "./resolve";
+import { setDeepPath } from "../../../utils/objects";
+import { isStyleDescriptorArray } from "../../../utils/style-value";
+import { ShortHandSymbol } from "../constants";
+import { defaultValues } from "../defaults";
+import type { StyleResolver } from "../resolve";
 
 type ShorthandType =
   | "string"