react-native-css 2.1.2 → 3.0.0-nightly.26b272f

package/src/jest/index.ts

@@ -0,0 +1,65 @@
+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> {
+      toHaveAnimatedStyle(style?: unknown): R;
+    }
+  }
+}
+
+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,
+  {
+    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;
+
+  const compiled = compile(css, { ...options, logger });
+  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;
+}

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,237 @@
+/* eslint-disable */
+import { dirname, relative, sep } from "node:path";
+import { versions } from "node:process";
+
+import connect from "connect";
+import debug from "debug";
+import type { MetroConfig } from "metro-config";
+
+import type { CompilerOptions, ReactNativeCssStyleSheet_V2 } from "../compiler";
+import { compile } from "../compiler/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);
+  }
+
+  const originalMiddleware = config.server?.enhanceMiddleware;
+  const originalResolver = config.resolver?.resolveRequest;
+
+  const poisonPillPath = "./poison.pill";
+
+  return {
+    ...config,
+    transformerPath: require.resolve("./metro-transformer"),
+    resolver: {
+      ...config.resolver,
+      sourceExts: [...(config?.resolver?.sourceExts || []), "css"],
+      resolveRequest: (context, moduleName, platform) => {
+        if (moduleName === poisonPillPath) {
+          return { type: "empty" };
+        }
+
+        // Don't hijack the resolution of react-native imports
+        if (!globalClassNamePolyfill) {
+          const parentResolver = originalResolver ?? context.resolveRequest;
+          return parentResolver(context, moduleName, platform);
+        }
+
+        const parentResolver = originalResolver ?? context.resolveRequest;
+        const resolver = platform === "web" ? webResolver : nativeResolver;
+        const resolved = resolver(
+          parentResolver,
+          context,
+          moduleName,
+          platform,
+        );
+
+        return resolved;
+      },
+    },
+    server: {
+      ...config.server,
+      enhanceMiddleware(middleware, metroServer) {
+        const server = connect();
+        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_V2]
+          >();
+          const webCSSFiles = new Set<string>();
+
+          const nativeInjectionPath = require.resolve(
+            "../runtime/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("../runtime/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,
+                      reactNativeCSSCompile: false,
+                    },
+                  },
+                  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);
+            }
+          };
+        }
+
+        return originalMiddleware
+          ? server.use(originalMiddleware(middleware, metroServer))
+          : server.use(middleware);
+      },
+    },
+  };
+}

package/src/metro/injection-code.ts

@@ -0,0 +1,38 @@
+/**
+ * This is a hack around Expo's handling of CSS files.
+ * 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.
+ *
+ * To fix this, we force our code to always import the CSS files.
+ * Now the CSS files are in every bundle.
+ *
+ * We achieve this by collecting all CSS files and injecting them into a special file
+ * which is included inside react-native-css's runtime.
+ *
+ * This is why both of these function add imports for the CSS files.
+ */
+
+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 importPath = `import { StyleCollection } from "./api";`;
+  const contents = values
+    .map((value) => `StyleCollection.inject(${JSON.stringify(value)});`)
+    .join("\n");
+
+  return Buffer.from(
+    `${importStatements}\n${importPath}\n${contents};export {};`,
+  );
+}

package/src/metro/metro-transformer.ts

@@ -0,0 +1,31 @@
+import type {
+  JsTransformerConfig,
+  JsTransformOptions,
+  TransformResponse,
+} from "metro-transform-worker";
+
+const worker =
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  require("@expo/metro-config/build/transform-worker/transform-worker.js") as typeof import("metro-transform-worker");
+
+export function transform(
+  config: JsTransformerConfig,
+  projectRoot: string,
+  filePath: string,
+  data: Buffer,
+  options: JsTransformOptions,
+): Promise<TransformResponse> {
+  const isCss = options.type !== "asset" && /\.(s?css|sass)$/.test(filePath);
+  const skipCompile =
+    options.customTransformOptions &&
+    "reactNativeCSSCompile" in options.customTransformOptions &&
+    options.customTransformOptions.reactNativeCSSCompile === false;
+
+  if (!isCss || skipCompile) {
+    return worker.transform(config, projectRoot, filePath, data, options);
+  }
+
+  // TODO - compile the CSS file inline
+
+  return worker.transform(config, projectRoot, filePath, data, options);
+}

package/src/metro/picocolors.ts

@@ -0,0 +1,77 @@
+/* eslint-disable */
+// ISC License
+
+// Copyright (c) 2021 Alexey Raspopov, Kostiantyn Denysov, Anton Verinov
+
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+//
+// https://github.com/alexeyraspopov/picocolors/blob/b6261487e7b81aaab2440e397a356732cad9e342/picocolors.js#L1
+
+const { env, stdout } = globalThis?.process ?? {};
+
+const enabled =
+  env &&
+  !env.NO_COLOR &&
+  (env.FORCE_COLOR || (stdout?.isTTY && !env.CI && env.TERM !== "dumb"));
+
+const replaceClose = (
+  str: string,
+  close: string,
+  replace: string,
+  index: number,
+): string => {
+  const start = str.substring(0, index) + replace;
+  const end = str.substring(index + close.length);
+  const nextIndex = end.indexOf(close);
+  return ~nextIndex
+    ? start + replaceClose(end, close, replace, nextIndex)
+    : start + end;
+};
+
+const formatter = (open: string, close: string, replace = open) => {
+  if (!enabled) return String;
+  return (input: string) => {
+    const string = "" + input;
+    const index = string.indexOf(close, open.length);
+    return ~index
+      ? open + replaceClose(string, close, replace, index) + close
+      : open + string + close;
+  };
+};
+
+export const reset = enabled ? (s: string) => `\x1b[0m${s}\x1b[0m` : String;
+export const bold = formatter("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m");
+export const dim = formatter("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m");
+export const italic = formatter("\x1b[3m", "\x1b[23m");
+export const underline = formatter("\x1b[4m", "\x1b[24m");
+export const inverse = formatter("\x1b[7m", "\x1b[27m");
+export const hidden = formatter("\x1b[8m", "\x1b[28m");
+export const strikethrough = formatter("\x1b[9m", "\x1b[29m");
+export const black = formatter("\x1b[30m", "\x1b[39m");
+export const red = formatter("\x1b[31m", "\x1b[39m");
+export const green = formatter("\x1b[32m", "\x1b[39m");
+export const yellow = formatter("\x1b[33m", "\x1b[39m");
+export const blue = formatter("\x1b[34m", "\x1b[39m");
+export const magenta = formatter("\x1b[35m", "\x1b[39m");
+export const purple = formatter("\x1b[38;2;173;127;168m", "\x1b[39m");
+export const cyan = formatter("\x1b[36m", "\x1b[39m");
+export const white = formatter("\x1b[37m", "\x1b[39m");
+export const gray = formatter("\x1b[90m", "\x1b[39m");
+export const bgBlack = formatter("\x1b[40m", "\x1b[49m");
+export const bgRed = formatter("\x1b[41m", "\x1b[49m");
+export const bgGreen = formatter("\x1b[42m", "\x1b[49m");
+export const bgYellow = formatter("\x1b[43m", "\x1b[49m");
+export const bgBlue = formatter("\x1b[44m", "\x1b[49m");
+export const bgMagenta = formatter("\x1b[45m", "\x1b[49m");
+export const bgCyan = formatter("\x1b[46m", "\x1b[49m");
+export const bgWhite = formatter("\x1b[47m", "\x1b[49m");

package/src/metro/resolver.ts

@@ -0,0 +1,89 @@
+import { basename, resolve, sep } from "node:path";
+
+import type {
+  CustomResolutionContext,
+  CustomResolver,
+  Resolution,
+} from "metro-resolver";
+
+import { allowedModules } from "../babel/allowedModules";
+
+const thisModuleDist = resolve(__dirname, "../../../dist");
+const thisModuleSrc = resolve(__dirname, "../../../src");
+
+function isFromThisModule(filename: string): boolean {
+  return (
+    filename.startsWith(thisModuleDist) || filename.startsWith(thisModuleSrc)
+  );
+}
+
+export function nativeResolver(
+  resolver: CustomResolver,
+  context: CustomResolutionContext,
+  moduleName: string,
+  platform: string | null,
+): Resolution {
+  const resolution = resolver(context, moduleName, platform);
+
+  if (
+    // Don't include our internal files
+    isFromThisModule(context.originModulePath) ||
+    // Only operate on source files
+    resolution.type !== "sourceFile" ||
+    // Skip the React Native barrel file to prevent infinite recursion
+    context.originModulePath.endsWith("react-native/index.js") ||
+    // Skip anything that isn't importing a React Native component
+    !(
+      moduleName.startsWith("react-native") ||
+      moduleName.startsWith("react-native/")
+    )
+  ) {
+    return resolution;
+  }
+
+  if (moduleName === "react-native") {
+    return resolver(context, `react-native-css/components`, platform);
+  }
+
+  // We only care about `react-native/Library/Components/<module>.js` components
+  const segments = resolution.filePath.split(sep);
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const module = basename(segments.at(-1)!).split(".")[0];
+
+  if (!module || !allowedModules.has(module)) {
+    return resolution;
+  }
+
+  return resolver(context, `react-native-css/components/${module}`, platform);
+}
+
+export function webResolver(
+  resolver: CustomResolver,
+  context: CustomResolutionContext,
+  moduleName: string,
+  platform: string | null,
+): Resolution {
+  const resolution = resolver(context, moduleName, platform);
+
+  if (
+    // Don't include our internal files
+    isFromThisModule(context.originModulePath) ||
+    // Only operate on source files
+    resolution.type !== "sourceFile" ||
+    // Skip anything that isn't importing from `react-native-web`
+    !resolution.filePath.includes(`${sep}react-native-web${sep}`)
+  ) {
+    return resolution;
+  }
+
+  // We only care about `react-native-web/<segment>/<segment>/<module>/index.js` components
+  const segments = resolution.filePath.split(sep);
+  const isIndex = segments.at(-1)?.startsWith("index.");
+  const module = segments.at(-2);
+
+  if (!isIndex || !module || !allowedModules.has(module)) {
+    return resolution;
+  }
+
+  return resolver(context, `react-native-css/components/${module}`, platform);
+}

package/src/metro/stringify.ts

@@ -0,0 +1,59 @@
+/* eslint-disable */
+/**
+ * Convert a data structure to JavaScript.
+ * The output should be similar to JSON, but without the extra characters.
+ * This is simply to reduce file size in production
+ */
+export function stringify(data: unknown): string {
+  switch (typeof data) {
+    case "bigint":
+    case "symbol":
+    case "function":
+      throw new Error(`Cannot stringify ${typeof data}`);
+    case "string":
+      return `"${data}"`;
+    case "number":
+      // Reduce to 3 decimal places
+      return `${Math.round(data * 1000) / 1000}`;
+    case "boolean":
+      return `${data}`;
+    case "undefined":
+      // null is processed faster than undefined
+      // JSON.stringify also converts undefined to null
+      return "null";
+    case "object": {
+      if (data === null) {
+        return "null";
+      } else if (Array.isArray(data)) {
+        return `[${data
+          .map((value) => {
+            // These values can be omitted to create a holey array
+            // This is slightly slower to parse at runtime, but keeps the
+            // file size smaller
+            return value === null || value === undefined
+              ? ""
+              : stringify(value);
+          })
+          .join(",")}]`;
+      } else {
+        return `{${Object.entries(data)
+          .flatMap(([key, value]) => {
+            // If an object's property is undefined or null we can just skip it
+            if (value === null || value === undefined) {
+              return [];
+            }
+
+            // Make sure we quote strings that require quotes
+            if (key.match(/[^a-zA-Z]/)) {
+              key = `"${key}"`;
+            }
+
+            value = stringify(value);
+
+            return [`${key}:${value}`];
+          })
+          .join(",")}}`;
+      }
+    }
+  }
+}

package/src/metro/typescript.ts

@@ -0,0 +1,73 @@
+/* eslint-disable */
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+import { CommentArray, parse, stringify } from "comment-json";
+
+import { bold, cyan } from "./picocolors";
+
+export function setupTypeScript(
+  envPath = "react-native-css-env.d.ts",
+  name = "react-native-css",
+) {
+  try {
+    const ts = require("typescript");
+    if (!ts) {
+      return;
+    }
+
+    const configFileName = ts.findConfigFile(
+      "./",
+      ts.sys.fileExists,
+      "tsconfig.json",
+    );
+
+    const userConfig = parse(
+      readFileSync(configFileName, {
+        encoding: "utf-8",
+      }),
+    );
+
+    if (
+      typeof userConfig !== "object" ||
+      !userConfig ||
+      Array.isArray(userConfig)
+    ) {
+      return;
+    }
+
+    const output: string[] = [];
+    let updatedConfig = false;
+
+    if (!existsSync(envPath)) {
+      writeFileSync(
+        envPath,
+        `/// <reference types="react-native-css/types" />
+
+// NOTE: This file should not be edited and should be committed with your source code. It is generated by ${name}. If you need to move or disable this file, please see the documentation.`,
+      );
+      output.push(`Created ${cyan(envPath)}`);
+    }
+
+    userConfig.include ??= new CommentArray(envPath);
+    if (
+      Array.isArray(userConfig.include) &&
+      !userConfig.include.includes(envPath)
+    ) {
+      userConfig.include.push(envPath);
+      updatedConfig = true;
+      output.push(
+        `Updated ${configFileName} to include the ${cyan(envPath)} file`,
+      );
+    }
+
+    if (updatedConfig) {
+      writeFileSync(configFileName, stringify(userConfig, null, 2));
+    }
+
+    if (output.length) {
+      console.log(
+        `${cyan(bold("NativeWind"))} made the following changes to your project to support TypeScript:\n  - ${output.join("\n  - ")}`,
+      );
+    }
+  } catch {}
+}