react-native-css 0.0.0-nightly.03a4e35

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/Switch.tsx

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

package/src/components/Text.tsx

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

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/View.tsx

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

package/src/components/index.tsx

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

package/src/components/react-native-safe-area-context.native.tsx

@@ -0,0 +1,44 @@
+import { useContext, useMemo, type PropsWithChildren } from "react";
+
+import {
+  VariableContext,
+  VariableContextProvider,
+} from "react-native-css/native-internal";
+import {
+  SafeAreaProvider as OriginalSafeAreaProvider,
+  useSafeAreaInsets,
+  type SafeAreaProviderProps,
+} from "react-native-safe-area-context";
+
+export * from "react-native-safe-area-context";
+
+export function SafeAreaProvider({
+  children,
+  ...props
+}: SafeAreaProviderProps) {
+  return (
+    <OriginalSafeAreaProvider {...props}>
+      <SafeAreaEnv>{children}</SafeAreaEnv>
+    </OriginalSafeAreaProvider>
+  );
+}
+
+function SafeAreaEnv({ children }: PropsWithChildren) {
+  const insets = useSafeAreaInsets();
+  const parentVars = useContext(VariableContext);
+
+  const value = useMemo(
+    () => ({
+      ...parentVars,
+      "--react-native-css-safe-area-inset-bottom": insets.bottom,
+      "--react-native-css-safe-area-inset-left": insets.left,
+      "--react-native-css-safe-area-inset-right": insets.right,
+      "--react-native-css-safe-area-inset-top": insets.top,
+    }),
+    [parentVars, insets],
+  );
+
+  return (
+    <VariableContextProvider value={value}>{children}</VariableContextProvider>
+  );
+}

package/src/components/react-native-safe-area-context.tsx

@@ -0,0 +1 @@
+export * from "react-native-safe-area-context";

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./runtime";

package/src/jest/expect.d.ts

@@ -0,0 +1 @@
+declare module "expect/build/matchers";

package/src/jest/index.ts

@@ -0,0 +1,74 @@
+import { Appearance, Dimensions } from "react-native";
+
+import { inspect } from "node:util";
+
+import { compile, type CompilerOptions } from "react-native-css/compiler";
+import { StyleCollection } from "react-native-css/native";
+
+import { colorScheme, dimensions } from "../native/reactivity";
+
+declare global {
+  /* eslint-disable @typescript-eslint/no-namespace */
+  namespace jest {
+    interface Matchers<R> {
+      toHaveAnimatedStyle(style?: unknown): R;
+    }
+  }
+}
+
+export const testID = "react-native-css";
+
+beforeEach(() => {
+  StyleCollection.styles.clear();
+  dimensions.set(Dimensions.get("window"));
+  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,
+  options: CompilerOptions & { debug?: boolean } = {},
+) {
+  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.stylesheet());
+
+  return compiled;
+}
+
+export function compileWithAutoDebug(
+  css: string,
+  {
+    debug = debugDefault,
+    ...options
+  }: CompilerOptions & { debug?: boolean | "verbose" } = {},
+) {
+  const logger = debug
+    ? (text: string) => {
+        // Just log the rules
+        if (text.startsWith("[") && debug === "verbose") {
+          console.log(`Rules:\n---\n${text}`);
+        }
+      }
+    : undefined;
+
+  return compile(css, { ...options, logger });
+}

package/src/jest/setup.ts

@@ -0,0 +1 @@
+// require("react-native-reanimated").setUpTests();

package/src/jest/setupAfterEnv.ts

@@ -0,0 +1,13 @@
+// import matchers from "expect/build/matchers";
+
+// // I do not know why this is needed
+// matchers.customTesters = [];
+
+// expect.extend({
+//   toHaveStyle(received, style) {
+//     const receivedStyle = received?.props?.style
+//       ? Object.fromEntries(Object.entries(received?.props?.style))
+//       : undefined;
+//     return matchers.toStrictEqual(receivedStyle, style);
+//   },
+// });

package/src/metro/index.ts

@@ -0,0 +1,241 @@
+/* eslint-disable */
+import { dirname, relative, sep } from "node:path";
+import { versions } from "node:process";
+
+import debug from "debug";
+import type { MetroConfig } from "metro-config";
+
+import {
+  compile,
+  type CompilerOptions,
+  type ReactNativeCssStyleSheet,
+} from "../compiler";
+import { getNativeInjectionCode, getWebInjectionCode } from "./injection-code";
+import { nativeResolver, webResolver } from "./resolver";
+import { setupTypeScript } from "./typescript";
+
+export interface WithReactNativeCSSOptions extends CompilerOptions {
+  /* Specify the path to the TypeScript environment file. Defaults types-env.d.ts */
+  typescriptEnvPath?: string;
+  /* Disable generation of the types-env.d.ts file. Defaults false */
+  disableTypeScriptGeneration?: boolean;
+  /** Add className to all React Native primitives. Defaults false */
+  globalClassNamePolyfill?: boolean;
+  hexColors?: boolean;
+}
+
+const defaultLogger = debug("react-native-css:metro");
+
+export function withReactNativeCSS<
+  T extends MetroConfig | (() => Promise<MetroConfig>),
+>(config: T, options?: WithReactNativeCSSOptions): T {
+  if (typeof config === "function") {
+    return (async () => {
+      return withReactNativeCSS(await config(), options);
+    }) as T;
+  }
+
+  if (Number(versions.node.split(".")[0]) < 20) {
+    throw new Error("react-native-css only supports NodeJS >20");
+  }
+
+  const {
+    disableTypeScriptGeneration,
+    typescriptEnvPath,
+    globalClassNamePolyfill = false,
+    logger = defaultLogger,
+  } = options || {};
+
+  const loggerEnabled = "enabled" in logger ? logger.enabled : true;
+
+  if (disableTypeScriptGeneration !== true) {
+    setupTypeScript(typescriptEnvPath);
+  }
+
+  return {
+    ...config,
+    // transformerPath: require.resolve("./metro-transformer"),
+    transformer: {
+      ...config.transformer,
+      reactNativeCSS: options,
+    },
+    resolver: {
+      ...config.resolver,
+      sourceExts: [...(config?.resolver?.sourceExts || []), "css"],
+      resolveRequest: (context, moduleName, platform) => {
+        if (moduleName.includes("poison.pill")) {
+          return { type: "empty" };
+        }
+
+        const parentResolver =
+          config.resolver?.resolveRequest ?? context.resolveRequest;
+
+        // Don't hijack the resolution of react-native imports
+        if (!globalClassNamePolyfill) {
+          return parentResolver(context, moduleName, platform);
+        }
+
+        const resolver = platform === "web" ? webResolver : nativeResolver;
+        const resolved = resolver(
+          parentResolver,
+          context,
+          moduleName,
+          platform,
+        );
+
+        return resolved;
+      },
+    },
+    server: {
+      ...config.server,
+      enhanceMiddleware(metroMiddleware, metroServer) {
+        const bundler: any = metroServer.getBundler().getBundler();
+
+        if (!bundler.__react_native_css__patched) {
+          bundler.__react_native_css__patched = true;
+
+          const nativeCSSFiles = new Map<
+            string,
+            [string, ReactNativeCssStyleSheet]
+          >();
+          const webCSSFiles = new Set<string>();
+
+          const nativeInjectionPath = require.resolve("../native/metro");
+          const nativeInjectionFilepaths = [
+            // CommonJS
+            nativeInjectionPath,
+            // ES Module
+            nativeInjectionPath.replace(
+              `dist${sep}commonjs`,
+              `dist${sep}module`,
+            ),
+            // TypeScript
+            nativeInjectionPath
+              .replace(`dist${sep}commonjs`, `src`)
+              .replace(".js", ".ts"),
+          ];
+
+          const webInjectionPath = require.resolve("../web/metro");
+          const webInjectionFilepaths = [
+            // CommonJS
+            webInjectionPath,
+            // ES Module
+            webInjectionPath.replace(`dist${sep}commonjs`, `dist${sep}module`),
+            // TypeScript
+            webInjectionPath
+              .replace(`dist${sep}commonjs`, `src`)
+              .replace(".js", ".ts"),
+          ];
+
+          // Keep the original
+          const transformFile = bundler.transformFile.bind(bundler);
+
+          const watcher = bundler.getWatcher();
+
+          // Patch with our functionality
+          bundler.transformFile = async function (
+            filePath: string,
+            transformOptions: any,
+            fileBuffer?: Buffer,
+          ) {
+            const isCss = /\.(s?css|sass)$/.test(filePath);
+
+            if (transformOptions.platform === "web") {
+              if (isCss) {
+                webCSSFiles.add(filePath);
+              } else if (webInjectionFilepaths.includes(filePath)) {
+                fileBuffer = getWebInjectionCode(Array.from(webCSSFiles));
+              }
+
+              return transformFile(filePath, transformOptions, fileBuffer);
+            } else {
+              // Handle CSS files on native platforms
+              if (isCss) {
+                const webTransform = await transformFile(
+                  filePath,
+                  {
+                    ...transformOptions,
+                    // Force the platform to web for CSS files
+                    platform: "web",
+                    // Let the transformer know that we will handle compilation
+                    customTransformOptions: {
+                      ...transformOptions.customTransformOptions,
+                      reactNativeCSS: options,
+                    },
+                  },
+                  fileBuffer,
+                );
+
+                const lastTransform = nativeCSSFiles.get(filePath);
+                const last = lastTransform?.[0];
+                const next = webTransform.output[0].data.css.code.toString();
+
+                // The CSS file has changed, we need to recompile the injection file
+                if (next !== last) {
+                  nativeCSSFiles.set(filePath, [
+                    next,
+                    compile(next, {
+                      hexColors: options?.hexColors,
+                    }).stylesheet(),
+                  ]);
+
+                  watcher.emit("change", {
+                    eventsQueue: nativeInjectionFilepaths.map((filePath) => ({
+                      filePath,
+                      metadata: {
+                        modifiedTime: Date.now(),
+                        size: 1, // Can be anything
+                        type: "virtual", // Can be anything
+                      },
+                      type: "change",
+                    })),
+                  });
+                }
+
+                const nativeTransform = await transformFile(
+                  filePath,
+                  transformOptions,
+                  fileBuffer,
+                );
+
+                // Tell Expo to skip caching this file
+                nativeTransform.output[0].data.css = {
+                  skipCache: true,
+                  // Expo requires a `code` property
+                  code: "",
+                };
+
+                return nativeTransform;
+              } else if (nativeInjectionFilepaths.includes(filePath)) {
+                // If this is the injection file, we to swap its content with the
+                // compiled CSS files
+                fileBuffer = getNativeInjectionCode(
+                  Array.from(nativeCSSFiles.keys()).map((key) =>
+                    relative(dirname(filePath), key),
+                  ),
+                  Array.from(nativeCSSFiles.values()).map(([, value]) => value),
+                );
+
+                if (loggerEnabled && fileBuffer) {
+                  logger(`Transformed ${filePath}`);
+                  logger(fileBuffer?.toString());
+                }
+              }
+
+              return transformFile(filePath, transformOptions, fileBuffer);
+            }
+          };
+        }
+
+        /**
+         * We don't modify the middleware, we just use this function to get the metroServer
+         * So simply return the existing middleware
+         */
+        return (
+          config.server?.enhanceMiddleware?.(metroMiddleware, metroServer) ??
+          metroMiddleware
+        );
+      },
+    },
+  };
+}

package/src/metro/injection-code.ts

@@ -0,0 +1,34 @@
+/**
+ * This is a hack around Metro's handling of bundles.
+ * When a component is inside a lazy() barrier, it is inside a different JS bundle.
+ * So when it updates, it only updates its local bundle, not the global one which contains the CSS files.
+ *
+ * This means that the CSS file will not be re-evaluated when a component in a different bundle updates,
+ * breaking tools like Tailwind CSS
+ *
+ * To fix this, we force our code to always import the CSS files, so now the CSS files are in every bundle.
+ */
+export function getWebInjectionCode(filePaths: string[]) {
+  const importStatements = filePaths
+    .map((filePath) => `import "${filePath}";`)
+    .join("\n");
+
+  return Buffer.from(importStatements);
+}
+
+export function getNativeInjectionCode(
+  cssFilePaths: string[],
+  values: unknown[],
+) {
+  const importStatements = cssFilePaths
+    .map((filePath) => `import "${filePath}";`)
+    .join("\n");
+
+  const contents = values
+    .map((value) => `StyleCollection.inject(${JSON.stringify(value)});`)
+    .join("\n");
+
+  return Buffer.from(
+    `import { StyleCollection } from "react-native-css/native-internal";\n${importStatements}\n${contents};export {};`,
+  );
+}

package/src/metro/metro-transformer.ts

@@ -0,0 +1,48 @@
+import { unstable_transformerPath } from "@expo/metro-config";
+import type {
+  JsTransformerConfig,
+  JsTransformOptions,
+  TransformResponse,
+} from "metro-transform-worker";
+
+import { compile, type CompilerOptions } from "../compiler";
+import { getNativeInjectionCode } from "./injection-code";
+
+const worker =
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  require(unstable_transformerPath) as typeof import("metro-transform-worker");
+
+export async function transform(
+  config: JsTransformerConfig,
+  projectRoot: string,
+  filePath: string,
+  data: Buffer,
+  options: JsTransformOptions & {
+    reactNativeCSS?: CompilerOptions | undefined;
+  },
+): Promise<TransformResponse> {
+  const isCss = options.type !== "asset" && /\.(s?css|sass)$/.test(filePath);
+
+  if (options.platform === "web" || !isCss) {
+    return worker.transform(config, projectRoot, filePath, data, options);
+  }
+
+  const cssFile = (await worker.transform(config, projectRoot, filePath, data, {
+    ...options,
+    platform: "web",
+  })) as TransformResponse & {
+    output: [{ data: { css: { code: Buffer } } }];
+  };
+
+  const css = cssFile.output[0].data.css.code.toString();
+
+  const productionJS = compile(css, {
+    ...options.reactNativeCSS,
+    filename: filePath,
+    projectRoot: projectRoot,
+  }).stylesheet();
+
+  data = Buffer.from(getNativeInjectionCode([], [productionJS]));
+
+  return worker.transform(config, projectRoot, `${filePath}.js`, data, options);
+}