react-native-css 3.0.0-nightly.fa5e95b → 3.0.0-preview.1

package/src/runtime/native/injection.ts

@@ -1,131 +0,0 @@
-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/styles/box-shadow.ts

@@ -1,54 +0,0 @@
-import { isStyleDescriptorArray } from "../../utils";
-import type { StyleFunctionResolver } from "./resolve";
-import { shorthandHandler } from "./shorthand";
-
-const color = ["color", "string"] as const;
-const offsetX = ["offsetX", "number"] as const;
-const offsetY = ["offsetY", "number"] as const;
-const blurRadius = ["blurRadius", "number"] as const;
-const spreadDistance = ["spreadDistance", "number"] as const;
-// const inset = ["inset", "string"] as const;
-
-const handler = shorthandHandler(
-  [
-    [offsetX, offsetY, blurRadius, spreadDistance, color],
-    [color, offsetX, offsetY],
-    [color, offsetX, offsetY, blurRadius],
-    [color, offsetX, offsetY, blurRadius, spreadDistance],
-    [offsetX, offsetY, color],
-    [offsetX, offsetY, blurRadius, color],
-  ],
-  [],
-  "object",
-);
-
-export const boxShadow: StyleFunctionResolver = (
-  resolveValue,
-  func,
-  get,
-  options,
-) => {
-  const args = resolveValue(func[2]);
-
-  if (!isStyleDescriptorArray(args)) {
-    return args;
-  } else {
-    return args.flatMap((shadows) => {
-      if (shadows === undefined) {
-        return [];
-      } else if (isStyleDescriptorArray(shadows)) {
-        if (shadows.length === 0) {
-          return [];
-        } else if (Array.isArray(shadows[0])) {
-          return shadows
-            .map((shadow) => handler(resolveValue, shadow, get, options))
-            .filter((v) => v !== undefined);
-        } else {
-          return handler(resolveValue, shadows, get, options);
-        }
-      } else {
-        return handler(resolveValue, shadows, get, options);
-      }
-    });
-  }
-};

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

@@ -1,97 +0,0 @@
-/* eslint-disable */
-import { isStyleDescriptorArray } from "../../utils";
-import type { StyleFunctionResolver } from "./resolve";
-
-const calcPrecedence: Record<string, number> = {
-  "+": 1,
-  "-": 1,
-  "*": 2,
-  "/": 2,
-};
-
-export const calc: StyleFunctionResolver = (resolveValue, func) => {
-  let mode: "number" | "percentage" | undefined;
-  const values: number[] = [];
-  const ops: string[] = [];
-
-  const args = resolveValue(func[2]);
-
-  if (!isStyleDescriptorArray(args)) return;
-
-  for (let token of args) {
-    if (typeof token === "number") {
-      if (!mode) mode = "number";
-      if (mode !== "number") return;
-      values.push(token);
-      continue;
-    } else if (typeof token === "string") {
-      if (token === "(") {
-        ops.push(token);
-      } else if (token === ")") {
-        // Resolve all values within the brackets
-        while (ops.length && ops[ops.length - 1] !== "(") {
-          applyCalcOperator(ops.pop()!, values.pop(), values.pop(), values);
-        }
-        ops.pop();
-      } else if (token.endsWith("%")) {
-        if (!mode) mode = "percentage";
-        if (mode !== "percentage") return;
-        values.push(Number.parseFloat(token.slice(0, -1)));
-      } else {
-        // This means we have an operator
-        while (
-          ops.length &&
-          ops[ops.length - 1] &&
-          // @ts-ignore
-          calcPrecedence[ops[ops.length - 1]] >= calcPrecedence[token]
-        ) {
-          applyCalcOperator(ops.pop()!, values.pop(), values.pop(), values);
-        }
-        ops.push(token);
-      }
-    } else {
-      // We got something unexpected
-      return;
-    }
-  }
-
-  while (ops.length) {
-    applyCalcOperator(ops.pop()!, values.pop(), values.pop(), values);
-  }
-
-  if (!mode) return;
-
-  const num = values[0];
-
-  if (typeof num !== "number") {
-    return;
-  }
-
-  const value = Math.round((num + Number.EPSILON) * 100) / 100;
-
-  if (mode === "percentage") {
-    return `${value}%`;
-  }
-
-  return value;
-};
-
-function applyCalcOperator(
-  operator: string,
-  b = 0, // These are reversed because we pop them off the stack
-  a = 0,
-  values: number[],
-) {
-  switch (operator) {
-    case "+":
-      return values.push(a + b);
-    case "-":
-      return values.push(a - b);
-    case "*":
-      return values.push(a * b);
-    case "/":
-      return values.push(a / b);
-  }
-
-  return;
-}