react-native-boost 0.6.2 → 1.0.0

package/src/plugin/types/index.ts

@@ -1,33 +1,83 @@
 import { NodePath, types as t } from '@babel/core';
 
+export interface PluginOptimizationOptions {
+  /**
+   * Whether to optimize the `Text` component.
+   * @default true
+   */
+  text?: boolean;
+  /**
+   * Whether to optimize the `View` component.
+   * @default true
+   */
+  view?: boolean;
+}
+
 export interface PluginOptions {
   /**
-   * Paths to ignore from optimization. Relative to the Babel configuration file.
+   * Paths to ignore from optimization.
+   *
+   * Patterns are resolved from Babel's current working directory.
+   * In nested monorepo apps, parent segments may be needed, for example `../../node_modules/**`.
+   * @default []
    */
   ignores?: string[];
   /**
-   * Whether or not to log optimized files to the console.
+   * Enables verbose logging.
+   *
+   * With `silent: false`, optimized components are logged by default.
+   * When enabled, skipped components and their skip reasons are also logged.
    * @default false
    */
   verbose?: boolean;
   /**
-   * The optimizations to apply to the plugin.
-   */
-  optimizations?: {
-    /**
-     * Whether or not to optimize the Text component.
-     * @default true
-     */
-    text?: boolean;
-    /**
-     * Whether or not to optimize the View component.
-     * @default true
-     */
-    view?: boolean;
-  };
+   * Disables all plugin logs.
+   *
+   * When set to `true`, this overrides `verbose`.
+   * @default false
+   */
+  silent?: boolean;
+  /**
+   * Toggle individual optimizers.
+   *
+   * If omitted, all available optimizers are enabled.
+   */
+  optimizations?: PluginOptimizationOptions;
+  /**
+   * Opt-in flag that allows View optimization when ancestor components cannot be statically resolved.
+   *
+   * This increases optimization coverage, but may introduce behavioral differences
+   * when unresolved ancestors render React Native `Text` wrappers.
+   * Prefer targeted ignores first, and enable this only after verifying affected screens.
+   * @default false
+   */
+  dangerouslyOptimizeViewWithUnknownAncestors?: boolean;
+}
+
+export type OptimizableComponent = 'Text' | 'View';
+
+export interface OptimizationLogPayload {
+  component: OptimizableComponent;
+  path: NodePath<t.JSXOpeningElement>;
+}
+
+export interface SkippedOptimizationLogPayload extends OptimizationLogPayload {
+  reason: string;
+}
+
+export interface WarningLogPayload {
+  message: string;
+  component?: OptimizableComponent;
+  path?: NodePath<t.JSXOpeningElement>;
+}
+
+export interface PluginLogger {
+  optimized: (payload: OptimizationLogPayload) => void;
+  skipped: (payload: SkippedOptimizationLogPayload) => void;
+  warning: (payload: WarningLogPayload) => void;
 }
 
-export type Optimizer = (path: NodePath<t.JSXOpeningElement>, log?: (message: string) => void) => void;
+export type Optimizer = (path: NodePath<t.JSXOpeningElement>, logger: PluginLogger, options?: PluginOptions) => void;
 
 export type HubFile = t.File & {
   opts: {

package/src/plugin/utils/common/attributes.ts

@@ -1,5 +1,6 @@
 import { NodePath, types as t } from '@babel/core';
 import { ACCESSIBILITY_PROPERTIES } from '../constants';
+import { USER_SELECT_STYLE_TO_SELECTABLE_PROP } from '../constants';
 
 /**
  * Checks if the JSX element has a blacklisted property.
@@ -46,6 +47,67 @@ export const hasBlacklistedProperty = (path: NodePath<t.JSXOpeningElement>, blac
   });
 };
 
+/**
+ * Adds a default property to a JSX element if it's not already defined. It avoids adding a default
+ * if it cannot statically determine whether the property is already set.
+ *
+ * @param path - The path to the JSXOpeningElement.
+ * @param key - The property key.
+ * @param value - The default value expression.
+ */
+export const addDefaultProperty = (path: NodePath<t.JSXOpeningElement>, key: string, value: t.Expression) => {
+  let propertyIsFound = false;
+  let hasUnresolvableSpread = false;
+
+  for (const attribute of path.node.attributes) {
+    if (t.isJSXAttribute(attribute) && attribute.name.name === key) {
+      propertyIsFound = true;
+      break;
+    }
+
+    if (t.isJSXSpreadAttribute(attribute)) {
+      if (t.isObjectExpression(attribute.argument)) {
+        const propertyInSpread = attribute.argument.properties.some(
+          (p) =>
+            (t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === key) ||
+            (t.isObjectProperty(p) && t.isStringLiteral(p.key) && p.key.value === key)
+        );
+        if (propertyInSpread) {
+          propertyIsFound = true;
+          break;
+        }
+      } else if (t.isIdentifier(attribute.argument)) {
+        const binding = path.scope.getBinding(attribute.argument.name);
+        if (
+          binding?.path.node &&
+          t.isVariableDeclarator(binding.path.node) &&
+          t.isObjectExpression(binding.path.node.init)
+        ) {
+          const propertyInSpread = binding.path.node.init.properties.some(
+            (p) =>
+              (t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === key) ||
+              (t.isObjectProperty(p) && t.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(t.jsxAttribute(t.jsxIdentifier(key), t.jsxExpressionContainer(value)));
+  }
+};
+
 /**
  * Helper that builds an Object.assign expression out of the existing JSX attributes.
  * It handles both plain JSXAttributes and spread attributes.
@@ -142,3 +204,106 @@ export const hasAccessibilityProperty = (
   }
   return false;
 };
+
+/**
+ * Extracts the `style` attribute from a JSX attributes list.
+ *
+ * @returns An object containing the attribute node itself (if found) and the expression inside
+ */
+export function extractStyleAttribute(attributes: Array<t.JSXAttribute | t.JSXSpreadAttribute>): {
+  styleAttribute?: t.JSXAttribute;
+  styleExpr?: t.Expression;
+} {
+  for (const attribute of attributes) {
+    if (t.isJSXAttribute(attribute) && t.isJSXIdentifier(attribute.name, { name: 'style' })) {
+      if (
+        attribute.value &&
+        t.isJSXExpressionContainer(attribute.value) &&
+        !t.isJSXEmptyExpression(attribute.value.expression)
+      ) {
+        return {
+          styleAttribute: attribute,
+          styleExpr: attribute.value.expression,
+        };
+      }
+      return { styleAttribute: attribute };
+    }
+  }
+  return {};
+}
+
+/**
+ * Attempts to statically extract the `userSelect` style property from a style expression.
+ *
+ * If the `userSelect` value can be resolved at compile-time, the property is removed from the
+ * object literal (or array element) and its mapped boolean value for the native `selectable`
+ * prop is returned. When the value is unknown or the expression is not statically analysable,
+ * `undefined` is returned and no modification is made.
+ */
+export function extractSelectableAndUpdateStyle(styleExpr: t.Expression): boolean | undefined {
+  // Helper to process a single ObjectExpression
+  const handleObjectExpression = (objectExpr: t.ObjectExpression): boolean | undefined => {
+    let selectableValue: boolean | undefined;
+
+    objectExpr.properties = objectExpr.properties.filter((property) => {
+      if (
+        !t.isObjectProperty(property) ||
+        (!t.isIdentifier(property.key, { name: 'userSelect' }) &&
+          !(t.isStringLiteral(property.key) && property.key.value === 'userSelect'))
+      ) {
+        return true; // keep property
+      }
+
+      if (t.isStringLiteral(property.value)) {
+        const mapped = USER_SELECT_STYLE_TO_SELECTABLE_PROP[property.value.value];
+        if (mapped !== undefined) {
+          selectableValue = mapped;
+        }
+      }
+
+      // Remove the `userSelect` property
+      return false;
+    });
+
+    return selectableValue;
+  };
+
+  if (t.isObjectExpression(styleExpr)) {
+    return handleObjectExpression(styleExpr);
+  }
+
+  if (t.isArrayExpression(styleExpr)) {
+    let selectableValue: boolean | undefined;
+    for (const element of styleExpr.elements) {
+      if (element && t.isObjectExpression(element)) {
+        const value = handleObjectExpression(element);
+        if (value !== undefined) {
+          selectableValue = value; // prefer last defined value
+        }
+      }
+    }
+    return selectableValue;
+  }
+
+  return undefined; // not statically analysable
+}
+
+/**
+ * Checks if a node represents a string value.
+ */
+export const isStringNode = (path: NodePath<t.JSXOpeningElement>, child: t.Node): boolean => {
+  if (t.isJSXText(child) || t.isStringLiteral(child)) return true;
+
+  if (t.isJSXExpressionContainer(child)) {
+    const expression = child.expression;
+    if (t.isIdentifier(expression)) {
+      const binding = path.scope.getBinding(expression.name);
+      if (binding && binding.path.node && t.isVariableDeclarator(binding.path.node)) {
+        return !!binding.path.node.init && t.isStringLiteral(binding.path.node.init);
+      }
+      return false;
+    }
+    if (t.isStringLiteral(expression)) return true;
+  }
+  return false;
+};

package/src/plugin/utils/common/index.ts

@@ -1,5 +1,3 @@
-export * from './base';
 export * from './validation';
 export * from './attributes';
-export * from './node-types';
-export * from './ancestors';
+export * from './base';