react-native-boost 0.6.1 → 0.7.0

package/dist/plugin/esm/index.mjs

@@ -1,8 +1,8 @@
 import { declare } from '@babel/helper-plugin-utils';
 import { types } from '@babel/core';
-import { addDefault, addNamed } from '@babel/helper-module-imports';
 import { minimatch } from 'minimatch';
 import nodePath from 'node:path';
+import { addDefault, addNamed } from '@babel/helper-module-imports';
 
 class PluginError extends Error {
   constructor(message) {
@@ -11,52 +11,6 @@ class PluginError extends Error {
   }
 }
 
-const RUNTIME_MODULE_NAME = "react-native-boost/runtime";
-const ACCESSIBILITY_PROPERTIES = /* @__PURE__ */ new Set([
-  "accessibilityLabel",
-  "aria-label",
-  "accessibilityState",
-  "aria-busy",
-  "aria-checked",
-  "aria-disabled",
-  "aria-expanded",
-  "aria-selected",
-  "accessible"
-]);
-
-function addFileImportHint({
-  file,
-  nameHint,
-  path,
-  importName,
-  moduleName,
-  importType = "named"
-}) {
-  var _a;
-  if (!((_a = file.__hasImports) == null ? void 0 : _a[nameHint])) {
-    file.__hasImports = file.__hasImports || {};
-    file.__hasImports[nameHint] = importType === "default" ? addDefault(path, moduleName, { nameHint }) : addNamed(path, importName, moduleName, { nameHint });
-  }
-  return file.__hasImports[nameHint];
-}
-const replaceWithNativeComponent = (path, parent, file, nativeComponentName) => {
-  const nativeIdentifier = addFileImportHint({
-    file,
-    nameHint: nativeComponentName,
-    path,
-    importName: nativeComponentName,
-    moduleName: RUNTIME_MODULE_NAME,
-    importType: "named"
-  });
-  const currentName = path.node.name.name;
-  const jsxName = path.node.name;
-  jsxName.name = nativeIdentifier.name;
-  if (!path.node.selfClosing && parent.closingElement && types.isJSXIdentifier(parent.closingElement.name) && parent.closingElement.name.name === currentName) {
-    parent.closingElement.name.name = nativeIdentifier.name;
-  }
-  return nativeIdentifier;
-};
-
 const ensureArray = (value) => {
   if (Array.isArray(value)) return value;
   return [value];
@@ -157,6 +111,372 @@ const isReactNativeImport = (path, expectedImportedName) => {
   }
   return false;
 };
+const hasUnsafeViewAncestor = (path, allowUnknownAncestors = false) => {
+  const classification = classifyViewAncestors(path);
+  if (classification === "text") return true;
+  if (classification === "unknown" && !allowUnknownAncestors) return true;
+  return false;
+};
+function classifyViewAncestors(path) {
+  const context = {
+    componentCache: /* @__PURE__ */ new WeakMap(),
+    componentInProgress: /* @__PURE__ */ new WeakSet(),
+    renderExpressionInProgress: /* @__PURE__ */ new WeakSet()
+  };
+  let classification = "safe";
+  let ancestorPath = path.parentPath.parentPath;
+  while (ancestorPath) {
+    if (ancestorPath.isJSXElement()) {
+      const ancestorClassification = classifyJSXElementAsAncestor(ancestorPath, context);
+      classification = mergeAncestorClassification(classification, ancestorClassification);
+      if (classification === "text") return classification;
+    }
+    ancestorPath = ancestorPath.parentPath;
+  }
+  return classification;
+}
+function classifyJSXElementAsAncestor(path, context) {
+  const openingElementName = path.node.openingElement.name;
+  if (types.isJSXIdentifier(openingElementName)) {
+    return classifyJSXIdentifierAsAncestor(path, openingElementName.name, context);
+  }
+  if (types.isJSXMemberExpression(openingElementName)) {
+    return classifyJSXMemberExpressionAsAncestor(path, openingElementName);
+  }
+  return "unknown";
+}
+function classifyJSXIdentifierAsAncestor(path, identifierName, context) {
+  if (identifierName === "Fragment") return "safe";
+  const binding = path.scope.getBinding(identifierName);
+  if (!binding) return "unknown";
+  return classifyBindingAsAncestor(binding, context);
+}
+function classifyJSXMemberExpressionAsAncestor(path, expression) {
+  if (!types.isJSXIdentifier(expression.object) || !types.isJSXIdentifier(expression.property)) {
+    return "unknown";
+  }
+  const binding = path.scope.getBinding(expression.object.name);
+  if (!binding || binding.kind !== "module" || !types.isImportNamespaceSpecifier(binding.path.node)) {
+    return "unknown";
+  }
+  const importDeclaration = binding.path.parent;
+  if (!types.isImportDeclaration(importDeclaration)) return "unknown";
+  if (importDeclaration.source.value === "react-native") {
+    return expression.property.name === "Text" ? "text" : "safe";
+  }
+  if (importDeclaration.source.value === "react" && expression.property.name === "Fragment") {
+    return "safe";
+  }
+  return "unknown";
+}
+function classifyBindingAsAncestor(binding, context) {
+  if (binding.kind === "module") {
+    return classifyModuleBindingAsAncestor(binding);
+  }
+  return classifyLocalBindingAsAncestor(binding, context);
+}
+function classifyModuleBindingAsAncestor(binding) {
+  const importDeclaration = binding.path.parent;
+  if (!types.isImportDeclaration(importDeclaration)) return "unknown";
+  const source = importDeclaration.source.value;
+  if (source === "react-native") {
+    if (types.isImportSpecifier(binding.path.node)) {
+      const importedName = getImportSpecifierImportedName(binding.path.node);
+      if (!importedName) return "unknown";
+      return importedName === "Text" ? "text" : "safe";
+    }
+    if (types.isImportNamespaceSpecifier(binding.path.node)) {
+      return "safe";
+    }
+    return "unknown";
+  }
+  if (source === "react" && types.isImportSpecifier(binding.path.node)) {
+    const importedName = getImportSpecifierImportedName(binding.path.node);
+    if (importedName === "Fragment") return "safe";
+  }
+  return "unknown";
+}
+function classifyLocalBindingAsAncestor(binding, context) {
+  const cacheKey = binding.path.node;
+  const cached = context.componentCache.get(cacheKey);
+  if (cached) return cached;
+  if (context.componentInProgress.has(cacheKey)) {
+    return "unknown";
+  }
+  context.componentInProgress.add(cacheKey);
+  let classification;
+  if (binding.path.isFunctionDeclaration()) {
+    classification = analyzeFunctionComponent(binding.path, context);
+  } else if (binding.path.isVariableDeclarator()) {
+    classification = analyzeVariableDeclaratorComponent(binding.path, context);
+  } else {
+    classification = "unknown";
+  }
+  context.componentInProgress.delete(cacheKey);
+  context.componentCache.set(cacheKey, classification);
+  return classification;
+}
+function analyzeVariableDeclaratorComponent(path, context) {
+  const initPath = path.get("init");
+  if (!initPath.node) return "unknown";
+  if (initPath.isArrowFunctionExpression() || initPath.isFunctionExpression()) {
+    return analyzeFunctionComponent(initPath, context);
+  }
+  if (initPath.isCallExpression()) {
+    return analyzeCallWrappedComponent(initPath, context);
+  }
+  if (initPath.isIdentifier()) {
+    const aliasBinding = path.scope.getBinding(initPath.node.name);
+    if (!aliasBinding) return "unknown";
+    return classifyBindingAsAncestor(aliasBinding, context);
+  }
+  return "unknown";
+}
+function analyzeCallWrappedComponent(path, context) {
+  if (!isReactMemoOrForwardRefCall(path)) return "unknown";
+  const [firstArgumentPath] = path.get("arguments");
+  if (!(firstArgumentPath == null ? void 0 : firstArgumentPath.node)) return "unknown";
+  if (firstArgumentPath.isArrowFunctionExpression() || firstArgumentPath.isFunctionExpression()) {
+    return analyzeFunctionComponent(firstArgumentPath, context);
+  }
+  if (firstArgumentPath.isIdentifier()) {
+    const wrappedComponentBinding = path.scope.getBinding(firstArgumentPath.node.name);
+    if (!wrappedComponentBinding) return "unknown";
+    return classifyBindingAsAncestor(wrappedComponentBinding, context);
+  }
+  if (firstArgumentPath.isCallExpression()) {
+    return analyzeCallWrappedComponent(firstArgumentPath, context);
+  }
+  return "unknown";
+}
+function isReactMemoOrForwardRefCall(path) {
+  const calleePath = path.get("callee");
+  if (calleePath.isIdentifier()) {
+    if (!isMemoOrForwardRefName(calleePath.node.name)) return false;
+    const binding = path.scope.getBinding(calleePath.node.name);
+    return isReactImportBinding(binding);
+  }
+  if (calleePath.isMemberExpression()) {
+    const objectPath = calleePath.get("object");
+    const propertyPath = calleePath.get("property");
+    if (!objectPath.isIdentifier() || !propertyPath.isIdentifier()) return false;
+    if (!isMemoOrForwardRefName(propertyPath.node.name)) return false;
+    const objectBinding = path.scope.getBinding(objectPath.node.name);
+    return isReactImportBinding(objectBinding);
+  }
+  return false;
+}
+function isMemoOrForwardRefName(name) {
+  return name === "memo" || name === "forwardRef";
+}
+function isReactImportBinding(binding) {
+  if (!binding || binding.kind !== "module") return false;
+  const importDeclaration = binding.path.parent;
+  return types.isImportDeclaration(importDeclaration) && importDeclaration.source.value === "react";
+}
+function analyzeFunctionComponent(path, context) {
+  const bodyPath = path.get("body");
+  if (!bodyPath.isBlockStatement()) {
+    return analyzeRenderExpression(bodyPath, context);
+  }
+  let classification = "safe";
+  for (const statementPath of bodyPath.get("body")) {
+    if (!statementPath.isReturnStatement()) continue;
+    const argumentPath = statementPath.get("argument");
+    if (!argumentPath.node) continue;
+    const returnClassification = analyzeRenderExpression(argumentPath, context);
+    classification = mergeAncestorClassification(classification, returnClassification);
+    if (classification === "text") return classification;
+  }
+  return classification;
+}
+function analyzeRenderExpression(path, context) {
+  if (path.isJSXFragment()) {
+    return analyzeJSXChildren(path.get("children"), context);
+  }
+  let classification = "safe";
+  let hasJSX = false;
+  path.traverse({
+    JSXOpeningElement(jsxPath) {
+      hasJSX = true;
+      const jsxElementPath = jsxPath.parentPath;
+      if (!jsxElementPath.isJSXElement()) {
+        classification = mergeAncestorClassification(classification, "unknown");
+        return;
+      }
+      const jsxClassification = classifyJSXElementAsAncestor(jsxElementPath, context);
+      classification = mergeAncestorClassification(classification, jsxClassification);
+      if (classification === "text") {
+        jsxPath.stop();
+      }
+    }
+  });
+  if (hasJSX) return classification;
+  if (path.isIdentifier()) {
+    return analyzeIdentifierRenderExpression(path, context);
+  }
+  if (path.isMemberExpression() && isPropsChildrenMemberExpression(path.node)) {
+    return "safe";
+  }
+  if (path.isNullLiteral() || path.isBooleanLiteral() || path.isNumericLiteral() || path.isStringLiteral() || path.isBigIntLiteral()) {
+    return "safe";
+  }
+  return "unknown";
+}
+function analyzeJSXChildren(children, context) {
+  let classification = "safe";
+  for (const childPath of children) {
+    if (childPath.isJSXElement()) {
+      const childClassification = classifyJSXElementAsAncestor(childPath, context);
+      classification = mergeAncestorClassification(classification, childClassification);
+    } else if (childPath.isJSXFragment()) {
+      const fragmentClassification = analyzeJSXChildren(childPath.get("children"), context);
+      classification = mergeAncestorClassification(classification, fragmentClassification);
+    } else if (childPath.isJSXExpressionContainer()) {
+      const expressionPath = childPath.get("expression");
+      if (!expressionPath.node || expressionPath.isJSXEmptyExpression()) continue;
+      const expressionClassification = analyzeRenderExpression(expressionPath, context);
+      classification = mergeAncestorClassification(classification, expressionClassification);
+    } else if (childPath.isJSXSpreadChild()) {
+      classification = mergeAncestorClassification(classification, "unknown");
+    }
+    if (classification === "text") {
+      return classification;
+    }
+  }
+  return classification;
+}
+function analyzeIdentifierRenderExpression(path, context) {
+  if (path.node.name === "children") return "safe";
+  const binding = path.scope.getBinding(path.node.name);
+  if (!binding) return "unknown";
+  if (binding.kind === "param") {
+    return binding.identifier.name === "children" ? "safe" : "unknown";
+  }
+  if (!binding.path.isVariableDeclarator()) return "unknown";
+  const cacheKey = binding.path.node;
+  if (context.renderExpressionInProgress.has(cacheKey)) {
+    return "unknown";
+  }
+  const initPath = binding.path.get("init");
+  if (!initPath.node) return "unknown";
+  context.renderExpressionInProgress.add(cacheKey);
+  const classification = analyzeRenderExpression(initPath, context);
+  context.renderExpressionInProgress.delete(cacheKey);
+  return classification;
+}
+function isPropsChildrenMemberExpression(expression) {
+  if (!types.isIdentifier(expression.object, { name: "props" })) return false;
+  if (!types.isIdentifier(expression.property, { name: "children" })) return false;
+  return !expression.computed;
+}
+function mergeAncestorClassification(current, next) {
+  if (current === "text" || next === "text") return "text";
+  if (current === "unknown" || next === "unknown") return "unknown";
+  return "safe";
+}
+function getImportSpecifierImportedName(specifier) {
+  if (types.isIdentifier(specifier.imported)) {
+    return specifier.imported.name;
+  }
+  if (types.isStringLiteral(specifier.imported)) {
+    return specifier.imported.value;
+  }
+  return void 0;
+}
+const hasExpoRouterLinkParentWithAsChild = (path) => {
+  const textElementPath = path.parentPath;
+  if (!textElementPath.isJSXElement()) return false;
+  let ancestorPath = textElementPath.parentPath;
+  while (ancestorPath) {
+    if (ancestorPath.isJSXElement()) {
+      if (!isExpoRouterLinkElement(ancestorPath)) return false;
+      return hasTruthyAsChildAttribute(ancestorPath.node.openingElement.attributes);
+    }
+    ancestorPath = ancestorPath.parentPath;
+  }
+  return false;
+};
+function isExpoRouterLinkElement(path) {
+  const openingElementName = path.node.openingElement.name;
+  if (types.isJSXIdentifier(openingElementName)) {
+    const binding = path.scope.getBinding(openingElementName.name);
+    if (!binding || binding.kind !== "module") return false;
+    if (!types.isImportSpecifier(binding.path.node)) return false;
+    const importDeclaration = binding.path.parent;
+    if (!types.isImportDeclaration(importDeclaration) || importDeclaration.source.value !== "expo-router") return false;
+    const imported = binding.path.node.imported;
+    return types.isIdentifier(imported, { name: "Link" }) || types.isStringLiteral(imported) && imported.value === "Link";
+  }
+  if (types.isJSXMemberExpression(openingElementName)) {
+    if (!types.isJSXIdentifier(openingElementName.object)) return false;
+    if (!types.isJSXIdentifier(openingElementName.property, { name: "Link" })) return false;
+    const namespaceBinding = path.scope.getBinding(openingElementName.object.name);
+    if (!namespaceBinding || namespaceBinding.kind !== "module") return false;
+    if (!types.isImportNamespaceSpecifier(namespaceBinding.path.node)) return false;
+    const importDeclaration = namespaceBinding.path.parent;
+    return types.isImportDeclaration(importDeclaration) && importDeclaration.source.value === "expo-router";
+  }
+  return false;
+}
+function hasTruthyAsChildAttribute(attributes) {
+  let asChildAttribute;
+  for (const attribute of attributes) {
+    if (types.isJSXAttribute(attribute) && types.isJSXIdentifier(attribute.name, { name: "asChild" })) {
+      asChildAttribute = attribute;
+    }
+  }
+  if (!asChildAttribute) return false;
+  return isJSXAttributeValueTruthy(asChildAttribute.value);
+}
+function isJSXAttributeValueTruthy(value) {
+  if (!value) return true;
+  if (types.isStringLiteral(value)) return value.value.length > 0;
+  if (types.isJSXElement(value) || types.isJSXFragment(value)) return true;
+  if (types.isJSXExpressionContainer(value)) {
+    const staticTruthiness = getStaticExpressionTruthiness(value.expression);
+    return staticTruthiness != null ? staticTruthiness : true;
+  }
+  return true;
+}
+function getStaticExpressionTruthiness(expression) {
+  var _a, _b;
+  if (types.isJSXEmptyExpression(expression)) return false;
+  if (types.isBooleanLiteral(expression)) return expression.value;
+  if (types.isNullLiteral(expression)) return false;
+  if (types.isStringLiteral(expression)) return expression.value.length > 0;
+  if (types.isNumericLiteral(expression)) return expression.value !== 0 && !Number.isNaN(expression.value);
+  if (types.isBigIntLiteral(expression)) return expression.value !== "0";
+  if (types.isIdentifier(expression, { name: "undefined" })) return false;
+  if (types.isTemplateLiteral(expression) && expression.expressions.length === 0) {
+    return ((_b = (_a = expression.quasis[0]) == null ? void 0 : _a.value.cooked) != null ? _b : "").length > 0;
+  }
+  if (types.isUnaryExpression(expression, { operator: "!" })) {
+    const staticTruthiness = getStaticExpressionTruthiness(expression.argument);
+    return staticTruthiness === void 0 ? void 0 : !staticTruthiness;
+  }
+  return void 0;
+}
+
+const RUNTIME_MODULE_NAME = "react-native-boost/runtime";
+const ACCESSIBILITY_PROPERTIES = /* @__PURE__ */ new Set([
+  "accessibilityLabel",
+  "aria-label",
+  "accessibilityState",
+  "aria-busy",
+  "aria-checked",
+  "aria-disabled",
+  "aria-expanded",
+  "aria-selected",
+  "accessible"
+]);
+const USER_SELECT_STYLE_TO_SELECTABLE_PROP = {
+  auto: true,
+  text: true,
+  none: false,
+  contain: true,
+  all: true
+};
 
 const hasBlacklistedProperty = (path, blacklist) => {
   return path.node.attributes.some((attribute) => {
@@ -188,6 +508,47 @@ const hasBlacklistedProperty = (path, blacklist) => {
     return false;
   });
 };
+const addDefaultProperty = (path, key, value) => {
+  let propertyIsFound = false;
+  let hasUnresolvableSpread = false;
+  for (const attribute of path.node.attributes) {
+    if (types.isJSXAttribute(attribute) && attribute.name.name === key) {
+      propertyIsFound = true;
+      break;
+    }
+    if (types.isJSXSpreadAttribute(attribute)) {
+      if (types.isObjectExpression(attribute.argument)) {
+        const propertyInSpread = attribute.argument.properties.some(
+          (p) => types.isObjectProperty(p) && types.isIdentifier(p.key) && p.key.name === key || types.isObjectProperty(p) && types.isStringLiteral(p.key) && p.key.value === key
+        );
+        if (propertyInSpread) {
+          propertyIsFound = true;
+          break;
+        }
+      } else if (types.isIdentifier(attribute.argument)) {
+        const binding = path.scope.getBinding(attribute.argument.name);
+        if ((binding == null ? void 0 : binding.path.node) && types.isVariableDeclarator(binding.path.node) && types.isObjectExpression(binding.path.node.init)) {
+          const propertyInSpread = binding.path.node.init.properties.some(
+            (p) => types.isObjectProperty(p) && types.isIdentifier(p.key) && p.key.name === key || types.isObjectProperty(p) && types.isStringLiteral(p.key) && p.key.value === key
+          );
+          if (propertyInSpread) {
+            propertyIsFound = true;
+            break;
+          }
+        } else {
+          hasUnresolvableSpread = true;
+          break;
+        }
+      } else {
+        hasUnresolvableSpread = true;
+        break;
+      }
+    }
+  }
+  if (!propertyIsFound && !hasUnresolvableSpread) {
+    path.node.attributes.push(types.jsxAttribute(types.jsxIdentifier(key), types.jsxExpressionContainer(value)));
+  }
+};
 const buildPropertiesFromAttributes = (attributes) => {
   const arguments_ = [];
   for (const attribute of attributes) {
@@ -253,7 +614,54 @@ const hasAccessibilityProperty = (path, attributes) => {
   }
   return false;
 };
-
+function extractStyleAttribute(attributes) {
+  for (const attribute of attributes) {
+    if (types.isJSXAttribute(attribute) && types.isJSXIdentifier(attribute.name, { name: "style" })) {
+      if (attribute.value && types.isJSXExpressionContainer(attribute.value) && !types.isJSXEmptyExpression(attribute.value.expression)) {
+        return {
+          styleAttribute: attribute,
+          styleExpr: attribute.value.expression
+        };
+      }
+      return { styleAttribute: attribute };
+    }
+  }
+  return {};
+}
+function extractSelectableAndUpdateStyle(styleExpr) {
+  const handleObjectExpression = (objectExpr) => {
+    let selectableValue;
+    objectExpr.properties = objectExpr.properties.filter((property) => {
+      if (!types.isObjectProperty(property) || !types.isIdentifier(property.key, { name: "userSelect" }) && !(types.isStringLiteral(property.key) && property.key.value === "userSelect")) {
+        return true;
+      }
+      if (types.isStringLiteral(property.value)) {
+        const mapped = USER_SELECT_STYLE_TO_SELECTABLE_PROP[property.value.value];
+        if (mapped !== void 0) {
+          selectableValue = mapped;
+        }
+      }
+      return false;
+    });
+    return selectableValue;
+  };
+  if (types.isObjectExpression(styleExpr)) {
+    return handleObjectExpression(styleExpr);
+  }
+  if (types.isArrayExpression(styleExpr)) {
+    let selectableValue;
+    for (const element of styleExpr.elements) {
+      if (element && types.isObjectExpression(element)) {
+        const value = handleObjectExpression(element);
+        if (value !== void 0) {
+          selectableValue = value;
+        }
+      }
+    }
+    return selectableValue;
+  }
+  return void 0;
+}
 const isStringNode = (path, child) => {
   if (types.isJSXText(child) || types.isStringLiteral(child)) return true;
   if (types.isJSXExpressionContainer(child)) {
@@ -270,63 +678,40 @@ const isStringNode = (path, child) => {
   return false;
 };
 
-function hasComponentAncestor(path, componentName, skipComponents = ["Fragment"]) {
-  const directAncestor = path.findParent((parentPath) => {
-    return types.isJSXElement(parentPath.node) && types.isJSXIdentifier(parentPath.node.openingElement.name, { name: componentName });
-  });
-  if (directAncestor) return true;
-  return !!path.findParent((parentPath) => {
-    if (!types.isJSXElement(parentPath.node)) return false;
-    const openingElement = parentPath.node.openingElement;
-    if (!types.isJSXIdentifier(openingElement.name)) return false;
-    const ancestorComponentName = openingElement.name.name;
-    if (ancestorComponentName === componentName) {
-      return false;
-    }
-    if (skipComponents.includes(ancestorComponentName)) {
-      return false;
-    }
-    if (ancestorComponentName[0] === ancestorComponentName[0].toLowerCase()) {
-      return false;
-    }
-    const binding = parentPath.scope.getBinding(ancestorComponentName);
-    if (!binding) return false;
-    if (types.isVariableDeclarator(binding.path.node)) {
-      const init = binding.path.node.init;
-      if (types.isArrowFunctionExpression(init) || types.isFunctionExpression(init)) {
-        return types.isBlockStatement(init.body) ? hasComponentInReturnStatement(init.body, componentName) : hasComponentInExpression(init.body, componentName);
-      }
-    } else if (types.isFunctionDeclaration(binding.path.node)) {
-      return hasComponentInReturnStatement(binding.path.node.body, componentName);
-    }
-    return false;
-  });
-}
-function hasComponentInReturnStatement(blockStatement, componentName) {
-  for (const statement of blockStatement.body) {
-    if (types.isReturnStatement(statement) && statement.argument && hasComponentInExpression(statement.argument, componentName)) {
-      return true;
-    }
+function addFileImportHint({
+  file,
+  nameHint,
+  path,
+  importName,
+  moduleName,
+  importType = "named"
+}) {
+  var _a;
+  if (!((_a = file.__hasImports) == null ? void 0 : _a[nameHint])) {
+    file.__hasImports = file.__hasImports || {};
+    file.__hasImports[nameHint] = importType === "default" ? addDefault(path, moduleName, { nameHint }) : addNamed(path, importName, moduleName, { nameHint });
   }
-  return false;
+  return file.__hasImports[nameHint];
 }
-function hasComponentInExpression(expression, componentName) {
-  if (types.isJSXElement(expression)) {
-    if (types.isJSXIdentifier(expression.openingElement.name, { name: componentName })) {
-      return true;
-    }
-    for (const child of expression.children) {
-      if (types.isJSXElement(child) && types.isJSXIdentifier(child.openingElement.name, { name: componentName })) {
-        return true;
-      }
-    }
+const replaceWithNativeComponent = (path, parent, file, nativeComponentName) => {
+  const nativeIdentifier = addFileImportHint({
+    file,
+    nameHint: nativeComponentName,
+    path,
+    importName: nativeComponentName,
+    moduleName: RUNTIME_MODULE_NAME,
+    importType: "named"
+  });
+  const currentName = path.node.name.name;
+  const jsxName = path.node.name;
+  jsxName.name = nativeIdentifier.name;
+  if (!path.node.selfClosing && parent.closingElement && types.isJSXIdentifier(parent.closingElement.name) && parent.closingElement.name.name === currentName) {
+    parent.closingElement.name.name = nativeIdentifier.name;
   }
-  return false;
-}
+  return nativeIdentifier;
+};
 
 const textBlacklistedProperties = /* @__PURE__ */ new Set([
-  "allowFontScaling",
-  "ellipsizeMode",
   "id",
   "nativeID",
   "onLongPress",
@@ -341,8 +726,8 @@ const textBlacklistedProperties = /* @__PURE__ */ new Set([
   "onStartShouldSetResponder",
   "pressRetentionOffset",
   "suppressHighlighting",
-  "selectable",
   "selectionColor"
+  // TODO: we can use react-native's internal `processColor` to process this at runtime
 ]);
 const textOptimizer = (path, log = () => {
 }) => {
@@ -351,6 +736,7 @@ const textOptimizer = (path, log = () => {
   if (!isValidJSXComponent(path, "Text")) return;
   if (!isReactNativeImport(path, "Text")) return;
   if (hasBlacklistedProperty(path, textBlacklistedProperties)) return;
+  if (hasExpoRouterLinkParentWithAsChild(path)) return;
   const parent = path.parent;
   if (hasInvalidChildren(path, parent)) return;
   const hub = path.hub;
@@ -361,9 +747,10 @@ const textOptimizer = (path, log = () => {
   const filename = ((_a = file.opts) == null ? void 0 : _a.filename) || "unknown file";
   const lineNumber = (_c = (_b = path.node.loc) == null ? void 0 : _b.start.line) != null ? _c : "unknown line";
   log(`Optimizing Text component in ${filename}:${lineNumber}`);
-  const originalAttributes = [...path.node.attributes];
   fixNegativeNumberOfLines({ path, log });
-  processProps(path, file, originalAttributes);
+  addDefaultProperty(path, "allowFontScaling", types.booleanLiteral(true));
+  addDefaultProperty(path, "ellipsizeMode", types.stringLiteral("tail"));
+  processProps(path, file);
   replaceWithNativeComponent(path, parent, file, "NativeText");
 };
 function hasInvalidChildren(path, parent) {
@@ -397,27 +784,16 @@ function fixNegativeNumberOfLines({
     }
   }
 }
-function extractStyleAttribute(attributes) {
-  for (const attribute of attributes) {
-    if (types.isJSXAttribute(attribute) && types.isJSXIdentifier(attribute.name, { name: "style" })) {
-      if (attribute.value && types.isJSXExpressionContainer(attribute.value) && !types.isJSXEmptyExpression(attribute.value.expression)) {
-        return {
-          styleAttribute: attribute,
-          styleExpr: attribute.value.expression
-        };
-      }
-      return { styleAttribute: attribute };
-    }
-  }
-  return {};
-}
-function processProps(path, file, originalAttributes) {
-  const { styleExpr } = extractStyleAttribute(originalAttributes);
-  const hasA11y = hasAccessibilityProperty(path, originalAttributes);
-  if (styleExpr && hasA11y) {
-    const accessibilityAttributes = originalAttributes.filter(
-      (attribute) => !(types.isJSXAttribute(attribute) && types.isJSXIdentifier(attribute.name, { name: "style" }))
-    );
+function processProps(path, file) {
+  const currentAttributes = [...path.node.attributes];
+  const { styleExpr, styleAttribute } = extractStyleAttribute(currentAttributes);
+  const hasA11y = hasAccessibilityProperty(path, currentAttributes);
+  const spreadAttributes = [];
+  if (hasA11y) {
+    const accessibilityAttributes = currentAttributes.filter((attribute) => {
+      if (!types.isJSXAttribute(attribute)) return false;
+      return types.isJSXIdentifier(attribute.name) && ACCESSIBILITY_PROPERTIES.has(attribute.name.name);
+    });
     const normalizeIdentifier = addFileImportHint({
       file,
       nameHint: "processAccessibilityProps",
@@ -427,6 +803,17 @@ function processProps(path, file, originalAttributes) {
     });
     const accessibilityObject = buildPropertiesFromAttributes(accessibilityAttributes);
     const accessibilityExpr = types.callExpression(types.identifier(normalizeIdentifier.name), [accessibilityObject]);
+    spreadAttributes.push(types.jsxSpreadAttribute(accessibilityExpr));
+  }
+  let selectableAttribute;
+  if (styleExpr) {
+    const selectableValue = extractSelectableAndUpdateStyle(styleExpr);
+    if (selectableValue != null) {
+      selectableAttribute = types.jsxAttribute(
+        types.jsxIdentifier("selectable"),
+        types.jsxExpressionContainer(types.booleanLiteral(selectableValue))
+      );
+    }
     const flattenIdentifier = addFileImportHint({
       file,
       nameHint: "processTextStyle",
@@ -435,29 +822,19 @@ function processProps(path, file, originalAttributes) {
       moduleName: RUNTIME_MODULE_NAME
     });
     const flattenedStyleExpr = types.callExpression(types.identifier(flattenIdentifier.name), [styleExpr]);
-    path.node.attributes = [types.jsxSpreadAttribute(accessibilityExpr), types.jsxSpreadAttribute(flattenedStyleExpr)];
-  } else if (styleExpr) {
-    const flattenIdentifier = addFileImportHint({
-      file,
-      nameHint: "processTextStyle",
-      path,
-      importName: "processTextStyle",
-      moduleName: RUNTIME_MODULE_NAME
-    });
-    const flattened = types.callExpression(types.identifier(flattenIdentifier.name), [styleExpr]);
-    path.node.attributes = [types.jsxSpreadAttribute(flattened)];
-  } else if (hasA11y) {
-    const normalizeIdentifier = addFileImportHint({
-      file,
-      nameHint: "processAccessibilityProps",
-      path,
-      importName: "processAccessibilityProps",
-      moduleName: RUNTIME_MODULE_NAME
-    });
-    const propsObject = buildPropertiesFromAttributes(originalAttributes);
-    const normalized = types.callExpression(types.identifier(normalizeIdentifier.name), [propsObject]);
-    path.node.attributes = [types.jsxSpreadAttribute(normalized)];
+    spreadAttributes.push(types.jsxSpreadAttribute(flattenedStyleExpr));
+  }
+  const remainingAttributes = [];
+  for (const attribute of currentAttributes) {
+    if (styleAttribute && attribute === styleAttribute) continue;
+    if (hasA11y && types.isJSXAttribute(attribute) && types.isJSXIdentifier(attribute.name) && ACCESSIBILITY_PROPERTIES.has(attribute.name.name)) {
+      continue;
+    }
+    remainingAttributes.push(attribute);
   }
+  path.node.attributes = [...spreadAttributes, selectableAttribute, ...remainingAttributes].filter(
+    (attribute) => attribute !== void 0
+  );
 }
 
 const log = (message) => {
@@ -465,46 +842,29 @@ const log = (message) => {
 };
 
 const viewBlacklistedProperties = /* @__PURE__ */ new Set([
+  // TODO: process a11y props at runtime
   "accessible",
   "accessibilityLabel",
   "accessibilityState",
-  "allowFontScaling",
   "aria-busy",
   "aria-checked",
   "aria-disabled",
   "aria-expanded",
   "aria-label",
   "aria-selected",
-  "ellipsizeMode",
-  "disabled",
   "id",
   "nativeID",
-  "numberOfLines",
-  "onLongPress",
-  "onPress",
-  "onPressIn",
-  "onPressOut",
-  "onResponderGrant",
-  "onResponderMove",
-  "onResponderRelease",
-  "onResponderTerminate",
-  "onResponderTerminationRequest",
-  "onStartShouldSetResponder",
-  "pressRetentionOffset",
-  "selectable",
-  "selectionColor",
-  "suppressHighlighting",
   "style"
+  // TODO: process style at runtime
 ]);
-const skipComponents = ["View", "Fragment", "ScrollView", "FlatList"];
 const viewOptimizer = (path, log = () => {
-}) => {
+}, options) => {
   var _a, _b, _c;
   if (isIgnoredLine(path)) return;
   if (!isValidJSXComponent(path, "View")) return;
   if (!isReactNativeImport(path, "View")) return;
   if (hasBlacklistedProperty(path, viewBlacklistedProperties)) return;
-  if (hasComponentAncestor(path, "Text", skipComponents)) return;
+  if (hasUnsafeViewAncestor(path, (options == null ? void 0 : options.dangerouslyOptimizeViewWithUnknownAncestors) === true)) return;
   const hub = path.hub;
   const file = typeof hub === "object" && hub !== null && "file" in hub ? hub.file : void 0;
   if (!file) {
@@ -529,7 +889,7 @@ var index = declare((api) => {
         };
         if (isIgnoredFile(path, (_b = options.ignores) != null ? _b : [])) return;
         if (((_c = options.optimizations) == null ? void 0 : _c.text) !== false) textOptimizer(path, logger);
-        if (((_d = options.optimizations) == null ? void 0 : _d.view) !== false) viewOptimizer(path, logger);
+        if (((_d = options.optimizations) == null ? void 0 : _d.view) !== false) viewOptimizer(path, logger, options);
       }
     }
   };