react-native-css 3.0.0-nightly.27bd5e2 → 3.0.0-nightly.46bc0ab

package/src/compiler/stylesheet.ts

@@ -1,3 +1,5 @@
+import type { SelectorList } from "lightningcss";
+
 import {
   isStyleDescriptorArray,
   Specificity,
@@ -17,8 +19,9 @@ import type {
   StyleRuleMapping,
   StyleRuleSet,
   VariableRecord,
+  VariableValue,
 } from "./compiler.types";
-import { toRNProperty, type NormalizeSelector } from "./selectors";
+import { getClassNameSelectors, toRNProperty } from "./selector-builder";
 
 type BuilderMode = "style" | "media" | "container" | "keyframes";
 
@@ -29,6 +32,8 @@ const staticDeclarations = new WeakMap<
 
 const extraRules = new WeakMap<StyleRule, Partial<StyleRule>[]>();
 
+const keywords = new Set(["unset"]);
+
 export class StylesheetBuilder {
   animationFrames?: AnimationKeyframes_V2[];
   animationDeclarations: StyleDeclaration[] = [];
@@ -47,6 +52,7 @@ export class StylesheetBuilder {
     private ruleTemplate: StyleRule = {
       s: [],
     },
+    // Any default mapping should be included in the @prop parsing
     private mapping: StyleRuleMapping = {},
     public descriptorProperty?: string,
     private shared: {
@@ -56,22 +62,49 @@ export class StylesheetBuilder {
       animations?: AnimationRecord;
       rem: number;
       ruleOrder: number;
-    } = { ruleSets: {}, rem: 14, ruleOrder: 0 },
+      warningProperty?: string;
+      warningProperties: string[];
+      warningValues: Record<string, unknown[]>;
+      warningFunctions: string[];
+    } = {
+      ruleSets: {},
+      rem: 14,
+      ruleOrder: 0,
+      warningProperties: [],
+      warningValues: {},
+      warningFunctions: [],
+    },
+    private selectors: SelectorList = [],
   ) {}
 
-  fork(mode = this.mode, rule?: Partial<StyleRule>): StylesheetBuilder {
+  fork(mode = this.mode, selectors: SelectorList = []): StylesheetBuilder {
     this.shared.ruleOrder++;
+
+    /**
+     * If we already have selectors and we are added more
+     * Then these must be nested selectors.
+     *
+     * We need to extrapolate out the selectors to their full values
+     */
+    selectors =
+      this.selectors.length && selectors.length
+        ? this.selectors.flatMap((selectorA) => {
+            return selectors.map((selectorB) => [...selectorA, ...selectorB]);
+          })
+        : [...this.selectors, ...selectors];
+
     return new StylesheetBuilder(
       this.options,
       mode,
-      this.cloneRule(rule ? { ...this.rule, ...rule } : undefined),
+      this.cloneRule(),
       { ...this.mapping },
       this.descriptorProperty,
       this.shared,
+      selectors,
     );
   }
 
-  cloneRule({ ...rule } = this.rule): StyleRule {
+  cloneRule({ ...rule } = this.ruleTemplate): StyleRule {
     rule.s = [...rule.s];
     rule.aq &&= [...rule.aq];
     rule.c &&= [...rule.c];
@@ -123,11 +156,17 @@ export class StylesheetBuilder {
     }
 
     if (this.shared.rootVariables) {
-      stylesheetOptions.vr = Object.entries(this.shared.rootVariables);
+      stylesheetOptions.vr = Object.entries(this.shared.rootVariables).map(
+        // Reverse these so the most specific variables are first
+        ([key, value]) => [key, value.reverse()] as const,
+      );
     }
 
     if (this.shared.universalVariables) {
-      stylesheetOptions.vu = Object.entries(this.shared.universalVariables);
+      stylesheetOptions.vu = Object.entries(this.shared.universalVariables).map(
+        // Reverse these so the most specific variables are first
+        ([key, value]) => [key, value.reverse()] as const,
+      );
     }
 
     if (this.shared.animations) {
@@ -150,11 +189,64 @@ export class StylesheetBuilder {
     );
   }
 
+  setWarningProperty(property: string) {
+    this.shared.warningProperty = property;
+  }
+
+  addWarning(type: "property" | "value", property: string): void;
+  addWarning(type: "style", property: string, value: unknown): void;
   addWarning(
-    _type: "property" | "value" | "function",
-    _property: string | number,
+    type: "property" | "style" | "value",
+    property: string,
+    value?: unknown,
   ): void {
-    // TODO
+    switch (type) {
+      case "property":
+        this.shared.warningProperties.push(property);
+        break;
+      case "value": {
+        value = property;
+        property = this.shared.warningProperty ?? "";
+
+        if (!property) {
+          return;
+        }
+
+        this.shared.warningValues[property] ??= [];
+        this.shared.warningValues[property]?.push(value);
+        break;
+      }
+      case "style":
+        this.shared.warningValues[property] ??= [];
+        this.shared.warningValues[property]?.push(value);
+        break;
+    }
+  }
+
+  getWarnings() {
+    const result: {
+      properties?: string[];
+      values?: Record<string, unknown[]>;
+      functions?: string[];
+    } = {};
+
+    if (this.shared.warningProperties.length) {
+      result.properties = this.shared.warningProperties;
+    }
+
+    if (Object.keys(this.shared.warningValues).length) {
+      result.values = this.shared.warningValues;
+    }
+
+    if (this.shared.warningFunctions.length) {
+      result.functions = this.shared.warningFunctions;
+    }
+
+    return result;
+  }
+
+  addMapping(mapping: StyleRuleMapping) {
+    this.mapping = { ...this.mapping, ...mapping };
   }
 
   newRule(mapping = this.mapping, { important = false } = {}) {
@@ -166,6 +258,12 @@ export class StylesheetBuilder {
     }
   }
 
+  /** Used by nested declarations (for example @media inside a RuleSet) */
+  newNestedRule({ important = false } = {}) {
+    this.newRule(this.mapping, { important });
+  }
+
+  /** Hack for light-dark, which requires adding a new rule without changing the current rule */
   addExtraRule(rule: Partial<StyleRule>) {
     let extraRuleArray = extraRules.get(this.rule);
     if (!extraRuleArray) {
@@ -184,8 +282,8 @@ export class StylesheetBuilder {
   }
 
   addMediaQuery(condition: MediaCondition) {
-    this.rule.m ??= [];
-    this.rule.m.push(condition);
+    this.ruleTemplate.m ??= [];
+    this.ruleTemplate.m.push(condition);
   }
 
   addContainer(value: string[] | false) {
@@ -244,7 +342,10 @@ export class StylesheetBuilder {
       const [delayed, usesVariables] = postProcessStyleFunction(value);
 
       rule.d ??= [];
-      if (value[1] === "@animation") {
+      if (
+        value[1].startsWith("animation") ||
+        value[1].startsWith("transition")
+      ) {
         rule.a ??= true;
       }
 
@@ -284,43 +385,46 @@ export class StylesheetBuilder {
   }
 
   private pushDescriptor(
-    property: string,
+    rawProperty: string,
     value: StyleDescriptor,
     declarations: StyleDeclaration[],
     forceTuple = false,
     delayed = false,
   ) {
-    property = toRNProperty(property);
+    const property = toRNProperty(rawProperty);
 
-    let propPath: string | string[] =
-      this.mapping[property] ?? this.mapping["*"] ?? property;
+    let propPath: string | string[] | undefined =
+      this.mapping[rawProperty] ?? this.mapping[property] ?? this.mapping["*"];
 
     if (Array.isArray(propPath)) {
-      const first = propPath[0];
+      const [first, second] = propPath;
 
-      if (!first) {
-        // This should not happen, but if it does, we skip the property
-        return;
-      }
-
-      if (propPath.length === 1) {
-        propPath = first;
+      if (propPath.length === 2 && first === "*" && second) {
+        propPath = second;
       } else {
         forceTuple = true;
       }
+    } else if (propPath) {
+      forceTuple = true;
+    } else {
+      propPath = property;
+    }
+
+    if (forceTuple && !Array.isArray(propPath)) {
+      propPath = [propPath];
     }
 
-    if (isStyleFunction(value)) {
+    if (isStyleFunction(value) || Array.isArray(propPath)) {
       if (delayed) {
         declarations.push([value, propPath, 1]);
       } else {
         declarations.push([value, propPath]);
       }
-    } else if (forceTuple || Array.isArray(propPath)) {
-      declarations.push([value, propPath]);
     } else if (Array.isArray(value) && value.some(isStyleFunction)) {
       declarations.push([value, propPath]);
-    } else {
+    } else if (typeof value === "string" && keywords.has(value)) {
+      declarations.push([value, propPath]);
+    } else if (typeof propPath === "string") {
       let staticDeclarationRecord = staticDeclarations.get(declarations);
       if (!staticDeclarationRecord) {
         staticDeclarationRecord = {};
@@ -331,13 +435,24 @@ export class StylesheetBuilder {
     }
   }
 
-  applyRuleToSelectors(selectorList: NormalizeSelector[]): void {
-    if (!this.rule.d && !this.rule.v) {
+  applyRuleToSelectors(selectorList = this.selectors): void {
+    if (!selectorList.length) {
+      // If there are no selectors, we cannot apply the rule
       return;
     }
 
-    for (const selector of selectorList) {
-      const rule = this.cloneRule();
+    if (!this.rule.d && !this.rule.v && !this.rule.c) {
+      return;
+    }
+
+    const normalizedSelectors = getClassNameSelectors(
+      selectorList,
+      this.options,
+    );
+
+    for (const selector of normalizedSelectors) {
+      // We are going to be apply the current rule to n selectors, so we clone the rule
+      const rule = this.cloneRule(this.rule);
 
       if (selector.type === "className") {
         const {
@@ -349,6 +464,10 @@ export class StylesheetBuilder {
           attributeQuery,
         } = selector;
 
+        if (!className) {
+          continue; // No className, nothing to do
+        }
+
         // Combine the specificity of the selector with the rule's specificity
         for (let i = 0; i < specificity.length; i++) {
           const spec = specificity[i];
@@ -372,14 +491,29 @@ export class StylesheetBuilder {
               continue;
             }
 
+            const [first, ...rest] = name.split(".");
+
+            if (typeof first !== "string") {
+              continue;
+            }
+
             const containerRule: StyleRule = {
               // These are not "real" rules, so they use the lowest specificity
               s: [0],
               c: [name],
             };
 
+            if (rest.length) {
+              containerRule.aq = rest.map((attr) => [
+                "a",
+                "className",
+                "*=",
+                attr,
+              ]);
+            }
+
             // Create rules for the parent classes
-            this.addRuleToRuleSet(name, containerRule);
+            this.addRuleToRuleSet(first, containerRule);
           }
         }
 
@@ -408,21 +542,24 @@ export class StylesheetBuilder {
         if (!this.rule.v) {
           continue;
         }
-
-        const { type, subtype } = selector;
-
+        const { type } = selector;
         for (const [name, value] of this.rule.v) {
           this.shared[type] ??= {};
-          this.shared[type][name] ??= [undefined];
-          this.shared[type][name][subtype === "light" ? 0 : 1] = value;
+          this.shared[type][name] ??= [];
+          const mediaQueries = this.rule.m;
+          const variableValue: VariableValue = mediaQueries
+            ? [value, [...mediaQueries]]
+            : [value];
+          // Append extra media queries if they exist
+          this.shared[type][name].push(variableValue);
         }
       }
     }
   }
 
   addContainerQuery(query: ContainerQuery) {
-    this.rule.cq ??= [];
-    this.rule.cq.push(query);
+    this.ruleTemplate.cq ??= [];
+    this.ruleTemplate.cq.push(query);
   }
 
   newAnimationFrames(name: string) {
@@ -484,7 +621,7 @@ function postProcessStyleFunction(value: StyleDescriptor): [
   let [shouldDelay, usesVariables] = postProcessStyleFunction(value[2]);
 
   usesVariables ||= value[1] === "var";
-  shouldDelay ||= value[3] === 1;
+  shouldDelay ||= value[3] === 1 || usesVariables;
 
   if (shouldDelay) {
     return [true, usesVariables];

package/src/components/ActivityIndicator.tsx

@@ -0,0 +1,27 @@
+import {
+  ActivityIndicator as RNActivityIndicator,
+  type ActivityIndicatorProps,
+} from "react-native";
+
+import {
+  useCssElement,
+  type StyledConfiguration,
+  type StyledProps,
+} from "../runtime";
+
+const mapping = {
+  className: {
+    target: "style",
+    nativeStyleMapping: {
+      color: "color",
+    },
+  },
+} satisfies StyledConfiguration<typeof RNActivityIndicator>;
+
+export function ActivityIndicator(
+  props: StyledProps<ActivityIndicatorProps, typeof mapping>,
+) {
+  return useCssElement(RNActivityIndicator, props, mapping);
+}
+
+export default ActivityIndicator;

package/src/components/Button.tsx

@@ -0,0 +1,22 @@
+import { Button as RNButton, type ButtonProps } from "react-native";
+
+import {
+  useCssElement,
+  type StyledConfiguration,
+  type StyledProps,
+} from "../runtime";
+
+const mapping = {
+  className: {
+    target: false,
+    nativeStyleMapping: {
+      color: "color",
+    },
+  },
+} satisfies StyledConfiguration<typeof RNButton>;
+
+export function Button(props: StyledProps<ButtonProps, typeof mapping>) {
+  return useCssElement(RNButton, props, mapping);
+}
+
+export default Button;

package/src/components/FlatList.tsx

@@ -0,0 +1,21 @@
+import { FlatList as RNFlatList, type FlatListProps } from "react-native";
+
+import {
+  useCssElement,
+  type StyledConfiguration,
+  type StyledProps,
+} from "../runtime";
+
+const mapping = {
+  columnWrapperStyle: "columnWrapperStyle",
+  listFooterComponentClassName: "ListFooterComponentStyle",
+  listHeaderComponentClassName: "ListHeaderComponentStyle",
+} satisfies StyledConfiguration<typeof RNFlatList>;
+
+export function FlatList<ItemT>(
+  props: StyledProps<FlatListProps<ItemT>, typeof mapping>,
+) {
+  return useCssElement(RNFlatList, props, mapping);
+}
+
+export default FlatList;

package/src/components/Image.tsx

@@ -0,0 +1,17 @@
+import { Image as RNImage, type ImageProps } from "react-native";
+
+import {
+  useCssElement,
+  type StyledConfiguration,
+  type StyledProps,
+} from "../runtime";
+
+const mapping = {
+  className: "style",
+} satisfies StyledConfiguration<typeof RNImage>;
+
+export function Image(props: StyledProps<ImageProps, typeof mapping>) {
+  return useCssElement(RNImage, props, mapping);
+}
+
+export default Image;

package/src/components/TextInput.tsx

@@ -0,0 +1,17 @@
+import { TextInput as RNTextInput, type TextInputProps } from "react-native";
+
+import {
+  useCssElement,
+  type StyledConfiguration,
+  type StyledProps,
+} from "../runtime";
+
+const mapping = {
+  className: "style",
+} satisfies StyledConfiguration<typeof RNTextInput>;
+
+export function TextInput(props: StyledProps<TextInputProps, typeof mapping>) {
+  return useCssElement(RNTextInput, props, mapping);
+}
+
+export default TextInput;

package/src/components/index.tsx

@@ -1,4 +1,9 @@
 export * from "react-native";
 
+export { ActivityIndicator } from "./ActivityIndicator";
+export { Button } from "./Button";
+export { FlatList } from "./FlatList";
+export { Image } from "./Image";
 export { Text } from "./Text";
+export { TextInput } from "./TextInput";
 export { View } from "./View";

package/src/jest/index.ts

@@ -1,42 +1,74 @@
-/* eslint-disable @typescript-eslint/no-namespace */
-import { Dimensions } from "react-native";
+import { Appearance, Dimensions } from "react-native";
+
+import { inspect } from "node:util";
 
 import { compile, type CompilerOptions } from "../compiler";
 import { StyleCollection } from "../runtime/native/injection";
 import { colorScheme, dimensions, rem } from "../runtime/native/reactivity";
 
 declare global {
+  /* eslint-disable @typescript-eslint/no-namespace */
   namespace jest {
     interface Matchers<R> {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      toHaveAnimatedStyle(style?: any): R;
+      toHaveAnimatedStyle(style?: unknown): R;
     }
   }
 }
 
-export * from "@testing-library/react-native";
 export const testID = "react-native-css";
 
 beforeEach(() => {
   StyleCollection.styles.clear();
   dimensions.set(Dimensions.get("window"));
   rem.set(14);
+  Appearance.setColorScheme(null);
   colorScheme.set(null);
 });
 
+const debugDefault = Boolean(
+  process.env.REACT_NATIVE_CSS_TEST_DEBUG &&
+    process.env.NODE_OPTIONS?.includes("--inspect"),
+);
+
 export function registerCSS(
   css: string,
-  {
-    debugCompiled = process.env.NODE_OPTIONS?.includes("--inspect"),
-    ...options
-  }: CompilerOptions & { debugCompiled?: boolean } = {},
+  options: CompilerOptions & { debug?: boolean } = {},
 ) {
-  const compiled = compile(css, options);
-  if (debugCompiled) {
-    console.log(`Compiled styles:\n\n${JSON.stringify({ compiled }, null, 2)}`);
+  const { debug = debugDefault } = options;
+  const compiled = compileWithAutoDebug(css, options);
+
+  if (debug) {
+    console.log(
+      `Compiled:\n---\n${inspect(
+        {
+          stylesheet: compiled.stylesheet(),
+          warnings: compiled.warnings(),
+        },
+        { depth: null, colors: true, compact: false },
+      )}`,
+    );
   }
 
-  StyleCollection.inject(compiled);
+  StyleCollection.inject(compiled.stylesheet());
 
   return compiled;
 }
+
+export function compileWithAutoDebug(
+  css: string,
+  {
+    debug = debugDefault,
+    ...options
+  }: CompilerOptions & { debug?: boolean } = {},
+) {
+  const logger = debug
+    ? (text: string) => {
+        // Just log the rules
+        if (text.startsWith("[")) {
+          console.log(`Rules:\n---\n${text}`);
+        }
+      }
+    : undefined;
+
+  return compile(css, { ...options, logger });
+}

package/src/metro/index.ts

@@ -6,7 +6,7 @@ import connect from "connect";
 import debug from "debug";
 import type { MetroConfig } from "metro-config";
 
-import type { CompilerOptions } from "../compiler";
+import type { CompilerOptions, ReactNativeCssStyleSheet_V2 } from "../compiler";
 import { compile } from "../compiler/compiler";
 import { getNativeInjectionCode, getWebInjectionCode } from "./injection-code";
 import { nativeResolver, webResolver } from "./resolver";
@@ -41,8 +41,11 @@ export function withReactNativeCSS<
     disableTypeScriptGeneration,
     typescriptEnvPath,
     globalClassNamePolyfill = false,
+    logger = defaultLogger,
   } = options || {};
 
+  const loggerEnabled = "enabled" in logger ? logger.enabled : true;
+
   if (disableTypeScriptGeneration !== true) {
     setupTypeScript(typescriptEnvPath);
   }
@@ -90,7 +93,10 @@ export function withReactNativeCSS<
         if (!bundler.__react_native_css__patched) {
           bundler.__react_native_css__patched = true;
 
-          const nativeCSSFiles = new Map();
+          const nativeCSSFiles = new Map<
+            string,
+            [string, ReactNativeCssStyleSheet_V2]
+          >();
           const webCSSFiles = new Set<string>();
 
           const nativeInjectionPath = require.resolve(
@@ -171,7 +177,7 @@ export function withReactNativeCSS<
                     next,
                     compile(next, {
                       hexColors: options?.hexColors,
-                    }),
+                    }).stylesheet(),
                   ]);
 
                   watcher.emit("change", {
@@ -211,9 +217,9 @@ export function withReactNativeCSS<
                   Array.from(nativeCSSFiles.values()).map(([, value]) => value),
                 );
 
-                if (defaultLogger.enabled && fileBuffer) {
-                  defaultLogger(`Transformed ${filePath}`);
-                  defaultLogger(fileBuffer?.toString());
+                if (loggerEnabled && fileBuffer) {
+                  logger(`Transformed ${filePath}`);
+                  logger(fileBuffer?.toString());
                 }
               }
 

package/src/poison.pill.ts

@@ -1,4 +1,7 @@
-throw new Error(`react-native-css has encountered a setup error. 
+const canWarn = process.env.NODE_ENV !== "test";
+
+if (canWarn) {
+  throw new Error(`react-native-css has encountered a setup error. 
 
 ┌─────-─┐
 | Metro | 
@@ -28,5 +31,6 @@ If you are using NativeWind with the 'withNativeWind' function, follow the Metro
 
 If you are using another bundler (Vite, Webpack, etc), or non-Metro framework (Next.js, Remix, etc), please ensure you have included 'react-native-css/babel' as a babel preset.
 `);
+}
 
 export {};