react-native-css 2.1.1 → 3.0.0-nightly.27bd5e2

package/src/runtime/native/api.ts

@@ -0,0 +1,106 @@
+/* eslint-disable  */
+import { useContext, useState } from "react";
+import { Appearance } from "react-native";
+
+import type { InlineVariable, StyleDescriptor } from "../../compiler";
+import type {
+  ColorScheme,
+  Props,
+  StyledConfiguration,
+  StyledOptions,
+} from "../runtime.types";
+import type { ReactComponent } from "../utils";
+import { mappingToConfig, useNativeCss } from "./react/useNativeCss";
+import { usePassthrough } from "./react/usePassthrough";
+import {
+  colorScheme as colorSchemeObs,
+  VAR_SYMBOL,
+  VariableContext,
+  type Effect,
+  type Getter,
+} from "./reactivity";
+import { resolveValue } from "./styles/resolve";
+
+export { StyleCollection } from "./injection";
+
+/**
+ * Generates a new Higher-Order component the wraps the base component and applies the styles.
+ * This is added to the `interopComponents` map so that it can be used in the `wrapJSX` function
+ * @param baseComponent
+ * @param mapping
+ */
+export const styled = <
+  const C extends ReactComponent<any>,
+  const M extends StyledConfiguration<C>,
+>(
+  baseComponent: C,
+  mapping: M,
+  options?: StyledOptions,
+) => {
+  let component: any;
+  // const type = getComponentType(baseComponent);
+
+  const configs = mappingToConfig(mapping);
+
+  if (options?.passThrough) {
+    component = (props: Record<string, any>) => {
+      return usePassthrough(baseComponent, props, configs);
+    };
+  } else {
+    component = (props: Record<string, any>) => {
+      return useNativeCss(baseComponent, props, configs);
+    };
+  }
+
+  const name = baseComponent.displayName ?? baseComponent.name ?? "unknown";
+  component.displayName = `CssInterop.${name}`;
+  return component;
+};
+
+export const colorScheme: ColorScheme = {
+  get() {
+    return colorSchemeObs.get() ?? Appearance.getColorScheme() ?? "light";
+  },
+  set(value) {
+    return colorSchemeObs.set(value);
+  },
+};
+
+export const useUnstableNativeVariable = useNativeVariable;
+
+export const useCssElement = <
+  const C extends ReactComponent<any>,
+  const M extends StyledConfiguration<C>,
+>(
+  component: C,
+  incomingProps: Props,
+  mapping: M,
+) => {
+  const [config] = useState(() => mappingToConfig(mapping));
+  return useNativeCss(component, incomingProps, config);
+};
+
+export function useNativeVariable(name: string) {
+  if (name.startsWith("--")) {
+    name = name.slice(2);
+  }
+
+  const inheritedVariables = useContext(VariableContext);
+  const [effect, setState] = useState(() => {
+    const effect: Effect = {
+      observers: new Set(),
+      run: () => setState((state) => ({ ...state })),
+    };
+
+    const get: Getter = (observable) => observable.get(effect);
+
+    return { ...effect, get };
+  });
+
+  return resolveValue([{}, "var", [name]], effect.get, { inheritedVariables });
+}
+
+export function vars(variables: Record<string, StyleDescriptor>) {
+  (variables as InlineVariable)[VAR_SYMBOL] = "inline";
+  return variables;
+}

package/src/runtime/native/conditions/container-query.ts

@@ -0,0 +1,157 @@
+/* eslint-disable */
+import type { MediaFeatureNameFor_ContainerSizeFeatureId } from "lightningcss";
+
+import type {
+  ContainerQuery,
+  MediaCondition,
+  PseudoClassesQuery,
+  StyleDescriptor,
+} from "../../../compiler";
+import {
+  activeFamily,
+  containerHeightFamily,
+  containerWidthFamily,
+  focusFamily,
+  hoverFamily,
+  type ContainerContextValue,
+  type Effect,
+} from "../reactivity";
+import type { RenderGuard } from "./guards";
+
+export const DEFAULT_CONTAINER_NAME = "c:___default___";
+
+export function testContainerQueries(
+  queries: ContainerQuery[],
+  inheritedContainers: ContainerContextValue,
+  guards: RenderGuard[],
+  effect: Effect,
+) {
+  return queries.every((query) => {
+    return testContainerQuery(query, inheritedContainers, guards, effect);
+  });
+}
+
+export function testContainerQuery(
+  query: ContainerQuery,
+  inheritedContainers: ContainerContextValue,
+  guards: RenderGuard[],
+  effect?: Effect,
+): boolean {
+  const name = query.n ?? DEFAULT_CONTAINER_NAME;
+  const container = inheritedContainers[name]!;
+
+  guards.push(["c", name, container]);
+
+  if (!container) {
+    return false;
+  }
+
+  if (query.m && !testContainerMediaCondition(query.m, container, effect)) {
+    return false;
+  }
+
+  if (query.p && !testContainerPseudoCondition(query.p, container, effect)) {
+    return false;
+  }
+
+  return true;
+}
+
+function testContainerPseudoCondition(
+  query: PseudoClassesQuery,
+  containerKey: WeakKey,
+  effect?: Effect,
+): boolean {
+  if (query.h && !hoverFamily(containerKey).get(effect)) {
+    return false;
+  }
+  if (query.a && !activeFamily(containerKey).get(effect)) {
+    return false;
+  }
+  if (query.f && !focusFamily(containerKey).get(effect)) {
+    return false;
+  }
+  return true;
+}
+
+function testContainerMediaCondition(
+  condition: MediaCondition,
+  containerKey: WeakKey,
+  effect?: Effect,
+): boolean {
+  switch (condition[0]) {
+    case "!":
+      return !testContainerMediaCondition(condition[1], containerKey, effect);
+    case "&":
+      return condition[1].every((query) => {
+        return testContainerMediaCondition(query, containerKey, effect);
+      });
+    case "|":
+      return condition[1].some((query) => {
+        return testContainerMediaCondition(query, containerKey, effect);
+      });
+    case "!!":
+      return false;
+    case "[]":
+      return false;
+    case ">":
+    case ">=":
+    case "<":
+    case "<=":
+    case "=": {
+      const left = getContainerFeatureValue(condition[1], containerKey, effect);
+      const right = condition[2];
+
+      if (condition[0] === "=") {
+        return left === right;
+      }
+
+      if (typeof left !== "number" || typeof right !== "number") {
+        return false;
+      }
+
+      switch (condition[0]) {
+        case ">":
+          return left > right;
+        case ">=":
+          return left > right;
+        case "<":
+          return left > right;
+        case "<=":
+          return left > right;
+        default:
+          condition[0] satisfies never;
+          return false;
+      }
+    }
+    default:
+      condition satisfies never;
+      return false;
+  }
+}
+
+function getContainerFeatureValue(
+  name: MediaFeatureNameFor_ContainerSizeFeatureId,
+  containerKey: WeakKey,
+  effect?: Effect,
+): StyleDescriptor {
+  switch (name) {
+    case "width":
+      return containerWidthFamily(containerKey).get(effect);
+    case "height":
+      return containerHeightFamily(containerKey).get(effect);
+    case "aspect-ratio": {
+      const width = containerWidthFamily(containerKey).get(effect);
+      const height = containerWidthFamily(containerKey).get(effect);
+      return width / height;
+    }
+    case "orientation":
+      const width = containerWidthFamily(containerKey).get(effect);
+      const height = containerWidthFamily(containerKey).get(effect);
+      return width > height ? "landscape" : "portrait";
+    case "inline-size":
+    case "block-size":
+    default:
+      return;
+  }
+}

package/src/runtime/native/conditions/guards.ts

@@ -0,0 +1,45 @@
+/* eslint-disable */
+import type { ComponentState } from "../react/useNativeCss";
+import type {
+  ContainerContextValue,
+  Effect,
+  VariableContextValue,
+} from "../reactivity";
+
+export type RenderGuard =
+  | ["a", string, any]
+  | ["d", string, any]
+  | ["v", string, any]
+  | ["c", string, Effect];
+
+export function testGuards(
+  state: ComponentState,
+  currentProps: any,
+  inheritedVariables: VariableContextValue,
+  inheritedContainers: ContainerContextValue,
+) {
+  return state.guards?.some((guard) => {
+    let result = false;
+
+    switch (guard[0]) {
+      case "a":
+        // Attribute
+        result = currentProps?.[guard[1]] !== guard[2];
+        break;
+      case "d":
+        // DataSet
+        result = currentProps?.dataSet?.[guard[1]] !== guard[2];
+        break;
+      case "v":
+        // Variables
+        result = inheritedVariables[guard[1]] !== guard[2];
+        break;
+      case "c":
+        // Containers
+        result = inheritedContainers[guard[1]] !== guard[2];
+        break;
+    }
+
+    return result;
+  });
+}

package/src/runtime/native/conditions/index.ts

@@ -0,0 +1,106 @@
+/* eslint-disable */
+import type {
+  AttributeQuery,
+  PseudoClassesQuery,
+  StyleRule,
+} from "../../../compiler";
+import type { Props } from "../../runtime.types";
+import {
+  activeFamily,
+  focusFamily,
+  hoverFamily,
+  type ContainerContextValue,
+  type Effect,
+} from "../reactivity";
+import { testContainerQueries } from "./container-query";
+import type { RenderGuard } from "./guards";
+import { testMediaQuery } from "./media-query";
+
+export function testRule(
+  rule: StyleRule,
+  effect: Effect,
+  props: Props,
+  guards: RenderGuard[],
+  containerContext: ContainerContextValue,
+) {
+  if (rule.p && !pseudoClasses(rule.p, effect)) {
+    return false;
+  }
+  if (rule.m && !testMediaQuery(rule.m, effect)) {
+    return false;
+  }
+  if (rule.aq && !attributes(rule.aq, props, guards)) {
+    return false;
+  }
+  if (
+    rule.cq &&
+    !testContainerQueries(rule.cq, containerContext, guards, effect)
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+function pseudoClasses(query: PseudoClassesQuery, effect: Effect) {
+  if (query.h && !hoverFamily(effect).get(effect)) {
+    return false;
+  }
+  if (query.a && !activeFamily(effect).get(effect)) {
+    return false;
+  }
+  if (query.f && !focusFamily(effect).get(effect)) {
+    return false;
+  }
+  return true;
+}
+
+function attributes(
+  queries: AttributeQuery[],
+  props: Props,
+  guards: RenderGuard[],
+) {
+  return queries.every((query) => testAttribute(query, props, guards));
+}
+
+function testAttribute(
+  query: AttributeQuery,
+  props: Props,
+  guards: RenderGuard[],
+) {
+  let value: any;
+
+  if (query[0] === "a") {
+    value = props?.[query[1]];
+  } else {
+    value = props?.dataSet?.[query[1]];
+  }
+
+  guards.push([query[0], query[1], value]);
+
+  const operator = query[2];
+
+  if (!operator) {
+    return value !== undefined && value !== null && value !== false;
+  }
+
+  switch (operator) {
+    case "!":
+      return !value;
+    case "=":
+      return value == query[3];
+    case "~=":
+      return value?.toString().split(" ").includes(query[3]);
+    case "|=":
+      return value?.toString().startsWith(query[3] + "-");
+    case "^=":
+      return value?.toString().startsWith(query[3]);
+    case "$=":
+      return value?.toString().endsWith(query[3]);
+    case "*=":
+      return value?.toString().includes(query[3]);
+    default:
+      operator satisfies never;
+      return false;
+  }
+}

package/src/runtime/native/conditions/media-query.ts

@@ -0,0 +1,94 @@
+/* eslint-disable */
+import { PixelRatio, Platform } from "react-native";
+
+import type { MediaCondition } from "../../../compiler";
+import { colorScheme, vh, vw, type Effect } from "../reactivity";
+
+export function testMediaQuery(mediaQueries: MediaCondition[], effect: Effect) {
+  return mediaQueries.every((query) => test(query, effect));
+}
+
+function test(mediaQuery: MediaCondition, effect: Effect): Boolean {
+  switch (mediaQuery[0]) {
+    case "[]":
+    case "!!":
+      return false;
+    case "!":
+      return !test(mediaQuery[1], effect);
+    case "&":
+      return mediaQuery[1].every((query) => {
+        return test(query, effect);
+      });
+    case "|":
+      return mediaQuery[1].some((query) => {
+        return test(query, effect);
+      });
+    case ">":
+    case ">=":
+    case "<":
+    case "<=":
+    case "=": {
+      return testComparison(mediaQuery, effect);
+    }
+  }
+}
+
+function testComparison(mediaQuery: MediaCondition, effect: Effect): Boolean {
+  let left: number | undefined;
+  const right = mediaQuery[2];
+
+  switch (mediaQuery[1]) {
+    case "platform":
+      return right === Platform.OS;
+    case "prefers-color-scheme": {
+      return right === colorScheme.get(effect);
+    }
+    case "display-mode":
+      return right === "native" || Platform.OS === right;
+    case "min-width":
+      return typeof right === "number" && vw.get(effect) >= right;
+    case "max-width":
+      return typeof right === "number" && vw.get(effect) <= right;
+    case "min-height":
+      return typeof right === "number" && vh.get(effect) >= right;
+    case "max-height":
+      return typeof right === "number" && vh.get(effect) <= right;
+    case "orientation":
+      return right === "landscape"
+        ? vh.get(effect) < vw.get(effect)
+        : vh.get(effect) >= vw.get(effect);
+  }
+
+  if (typeof right !== "number") {
+    return false;
+  }
+
+  switch (mediaQuery[1]) {
+    case "width":
+      left = vw.get(effect);
+      break;
+    case "height":
+      left = vh.get(effect);
+      break;
+    case "resolution":
+      left = PixelRatio.get();
+      break;
+    default:
+      return false;
+  }
+
+  switch (mediaQuery[0]) {
+    case "=":
+      return left === right;
+    case ">":
+      return left > right;
+    case ">=":
+      return left >= right;
+    case "<":
+      return left < right;
+    case "<=":
+      return left <= right;
+    default:
+      return false;
+  }
+}

package/src/runtime/native/index.ts

@@ -0,0 +1,4 @@
+export * from "./metro";
+
+export * from "./api";
+export type * from "../runtime.types";

package/src/runtime/native/injection.ts

@@ -0,0 +1,131 @@
+import type {
+  Animation_V2,
+  ReactNativeCssStyleSheet,
+  StyleRuleSet,
+} from "../../compiler";
+import {
+  family,
+  observable,
+  observableBatch,
+  rootVariables,
+  type Observable,
+} from "./reactivity";
+
+export function StyleCollection() {
+  return null;
+}
+
+export const inlineStylesMap = new WeakMap();
+
+StyleCollection.styles = family<string, Observable<StyleRuleSet>>(() => {
+  return observable([], isDeepEqual);
+});
+StyleCollection.keyframes = family<string, Observable<Animation_V2[1]>>(() => {
+  return observable([], isDeepEqual);
+});
+
+StyleCollection.inject = function (options: ReactNativeCssStyleSheet) {
+  observableBatch.current = new Set();
+
+  if (options.s) {
+    for (const style of options.s) {
+      StyleCollection.styles(style[0]).set(style[1]);
+    }
+  }
+
+  if (options.k) {
+    for (const keyframes of options.k) {
+      StyleCollection.keyframes(keyframes[0]).set(keyframes[1]);
+    }
+  }
+
+  if (options.vr) {
+    for (const entry of options.vr) {
+      rootVariables(entry[0]).set(entry[1]);
+    }
+  }
+
+  if (options.vu) {
+    for (const entry of options.vu) {
+      rootVariables(entry[0]).set(entry[1]);
+    }
+  }
+
+  for (const effect of observableBatch.current) {
+    effect.run();
+  }
+
+  observableBatch.current = undefined;
+};
+
+function isDeepEqual(a: unknown, b: unknown): boolean {
+  const aArray = Array.isArray(a);
+  const bArray = Array.isArray(b);
+  const requiresKeyComparison =
+    typeof a === "object" && typeof b === "object" && aArray === bArray;
+
+  // Only compare keys when both are an object or array
+  // This does not account for complex types like Date/Regex, because we don't use them
+  if (!requiresKeyComparison) return a === b;
+
+  // Make either are not null
+  if (!a || !b) {
+    return a === b;
+  }
+
+  // Shortcut for arrays
+  if (aArray && bArray && a.length !== b.length) {
+    return false;
+  }
+
+  // Compare a to b
+  for (const key in a) {
+    if (
+      !isDeepEqual(
+        (a as Record<string, unknown>)[key],
+        (b as Record<string, unknown>)[key],
+      )
+    ) {
+      return false;
+    }
+  }
+
+  // Compare b to a
+  for (const key in b) {
+    if (!(key in a)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+StyleCollection.styles("will-change-variable").set([
+  {
+    s: [0],
+    v: [],
+  },
+]);
+
+StyleCollection.styles("will-change-container").set([
+  {
+    s: [0],
+    c: [],
+  },
+]);
+
+StyleCollection.styles("will-change-animation").set([
+  {
+    s: [0],
+    a: true,
+  },
+]);
+
+StyleCollection.styles("will-change-pressable").set([
+  {
+    s: [0],
+    p: {
+      h: 1,
+    },
+  },
+]);

package/src/runtime/native/metro.ts

@@ -0,0 +1,2 @@
+// This file will be overwritten by Metro
+export {};