react-native-boost 1.0.0 → 1.1.0

package/src/plugin/optimizers/view/index.ts

@@ -1,9 +1,10 @@
 import { types as t } from '@babel/core';
 import { HubFile, Optimizer } from '../../types';
 import PluginError from '../../utils/plugin-error';
-import { getFirstBailoutReason } from '../../utils/helpers';
+import { BailoutCheck, getFirstBailoutReason } from '../../utils/helpers';
 import {
   hasBlacklistedProperty,
+  isForcedLine,
   isIgnoredLine,
   isValidJSXComponent,
   isReactNativeImport,
@@ -30,6 +31,7 @@ export const viewBlacklistedProperties = new Set([
 
 export const viewOptimizer: Optimizer = (path, logger, options) => {
   if (!isValidJSXComponent(path, 'View')) return;
+  if (!isReactNativeImport(path, 'View')) return;
 
   let ancestorClassification: ViewAncestorClassification | undefined;
   const getAncestorClassification = () => {
@@ -40,15 +42,9 @@ export const viewOptimizer: Optimizer = (path, logger, options) => {
     return ancestorClassification;
   };
 
-  const skipReason = getFirstBailoutReason([
-    {
-      reason: 'line is marked with @boost-ignore',
-      shouldBail: () => isIgnoredLine(path),
-    },
-    {
-      reason: 'View is not imported from react-native',
-      shouldBail: () => !isReactNativeImport(path, 'View'),
-    },
+  const forced = isForcedLine(path);
+
+  const overridableChecks: BailoutCheck[] = [
     {
       reason: 'contains blacklisted props',
       shouldBail: () => hasBlacklistedProperty(path, viewBlacklistedProperties),
@@ -62,19 +58,29 @@ export const viewOptimizer: Optimizer = (path, logger, options) => {
       shouldBail: () =>
         getAncestorClassification() === 'unknown' && options?.dangerouslyOptimizeViewWithUnknownAncestors !== true,
     },
-  ]);
+  ];
+
+  if (forced) {
+    const overriddenReason = getFirstBailoutReason(overridableChecks);
 
-  if (skipReason) {
-    logger.skipped({
-      component: 'View',
-      path,
-      reason: skipReason,
-    });
+    if (overriddenReason) {
+      logger.forced({ component: 'View', path, reason: overriddenReason });
+    }
+  } else {
+    const skipReason = getFirstBailoutReason([
+      {
+        reason: 'line is marked with @boost-ignore',
+        shouldBail: () => isIgnoredLine(path),
+      },
+      ...overridableChecks,
+    ]);
 
-    return;
+    if (skipReason) {
+      logger.skipped({ component: 'View', path, reason: skipReason });
+      return;
+    }
   }
 
-  // Extract the file from the Babel hub
   const hub = path.hub as unknown;
   const file = typeof hub === 'object' && hub !== null && 'file' in hub ? (hub.file as HubFile) : undefined;
 
@@ -89,6 +95,5 @@ export const viewOptimizer: Optimizer = (path, logger, options) => {
 
   const parent = path.parent as t.JSXElement;
 
-  // Replace the View component with NativeView
   replaceWithNativeComponent(path, parent, file, 'NativeView');
 };

package/src/plugin/types/index.ts

@@ -74,6 +74,7 @@ export interface WarningLogPayload {
 export interface PluginLogger {
   optimized: (payload: OptimizationLogPayload) => void;
   skipped: (payload: SkippedOptimizationLogPayload) => void;
+  forced: (payload: SkippedOptimizationLogPayload) => void;
   warning: (payload: WarningLogPayload) => void;
 }
 

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

@@ -39,54 +39,52 @@ export const isIgnoredFile = (path: NodePath<t.JSXOpeningElement>, ignores: stri
   return false;
 };
 
+export const isForcedLine = (path: NodePath<t.JSXOpeningElement>): boolean => {
+  return hasDecoratorComment(path, '@boost-force');
+};
+
+export const isIgnoredLine = (path: NodePath<t.JSXOpeningElement>): boolean => {
+  return hasDecoratorComment(path, '@boost-ignore');
+};
+
 /**
- * Checks if the JSX element should be ignored based on a preceding comment.
+ * Checks if the JSX element has a preceding comment containing the given decorator string.
  *
- * The function looks up the JSXOpeningElement's own leading comments as well as
- * the parent element's comments before falling back to inspect siblings.
- *
- * @param path - The path to the JSXOpeningElement.
- * @returns true if the JSX element should be ignored.
+ * Scans the JSXOpeningElement's own leading comments, the parent element's comments,
+ * ObjectProperty containers, and backward siblings.
  */
-export const isIgnoredLine = (path: NodePath<t.JSXOpeningElement>): boolean => {
-  // Check for @boost-ignore in the leading comments on the JSX opening element.
-  if (path.node.leadingComments?.some((comment) => comment.value.includes('@boost-ignore'))) {
+function hasDecoratorComment(path: NodePath<t.JSXOpeningElement>, decorator: string): boolean {
+  if (path.node.leadingComments?.some((comment) => comment.value.includes(decorator))) {
     return true;
   }
 
-  // Check for @boost-ignore in the leading comments on the parent JSX element.
   const jsxElementPath = path.parentPath;
-  if (jsxElementPath.node.leadingComments?.some((comment) => comment.value.includes('@boost-ignore'))) {
+  if (jsxElementPath.node.leadingComments?.some((comment) => comment.value.includes(decorator))) {
     return true;
   }
 
-  // NEW: Check for @boost-ignore in the leading comments on the ObjectProperty (if it exists)
-  // This handles cases where the JSX element is used as a value inside an object literal.
+  // Check leading comments on the ObjectProperty (if the JSX element is a value inside an object literal).
   const propertyPath = jsxElementPath.parentPath;
   if (
     propertyPath &&
     propertyPath.isObjectProperty() &&
-    propertyPath.node.leadingComments?.some((comment) => comment.value.includes('@boost-ignore'))
+    propertyPath.node.leadingComments?.some((comment) => comment.value.includes(decorator))
   ) {
     return true;
   }
 
   if (!jsxElementPath.parentPath) return false;
 
-  // Get the container that holds this element (for example, a JSX fragment or JSX element)
   const containerPath = jsxElementPath.parentPath;
   const siblings = ensureArray(containerPath.get('children'));
   const index = siblings.findIndex((sibling) => sibling.node === jsxElementPath.node);
   if (index === -1) return false;
 
-  // Look backward from the current element for a non-empty node.
   for (let index_ = index - 1; index_ >= 0; index_--) {
     const sibling = siblings[index_];
-    // Skip over any whitespace (only in JSXText nodes)
     if (sibling.isJSXText() && sibling.node.value.trim() === '') {
       continue;
     }
-    // If the sibling is a JSX expression container, check its empty expression's comments.
     if (sibling.isJSXExpressionContainer()) {
       const expression = sibling.get('expression');
       if (expression && expression.node) {
@@ -95,22 +93,21 @@ export const isIgnoredLine = (path: NodePath<t.JSXOpeningElement>): boolean => {
           ...(expression.node.trailingComments || []),
           ...(expression.node.innerComments || []),
         ].map((comment) => comment.value.trim());
-        if (comments.some((comment) => comment.includes('@boost-ignore'))) {
+        if (comments.some((comment) => comment.includes(decorator))) {
           return true;
         }
       }
     }
-    // Also check if the node itself carries a leadingComments property.
     if (
       sibling.node.leadingComments &&
-      sibling.node.leadingComments.some((comment) => comment.value.includes('@boost-ignore'))
+      sibling.node.leadingComments.some((comment) => comment.value.includes(decorator))
     ) {
       return true;
     }
-    break; // if the immediate non-whitespace node is not our ignore marker, stop
+    break;
   }
   return false;
-};
+}
 
 /**
  * Checks if the path represents a valid JSX component with the specified name.

package/src/plugin/utils/logger.ts

@@ -12,10 +12,12 @@ const ANSI_RESET = '\u001B[0m';
 const ANSI_GREEN = '\u001B[32m';
 const ANSI_YELLOW = '\u001B[33m';
 const ANSI_MAGENTA = '\u001B[35m';
+const ANSI_RED = '\u001B[31m';
 
 export const noopLogger: PluginLogger = {
   optimized() {},
   skipped() {},
+  forced() {},
   warning() {},
 };
 
@@ -30,6 +32,12 @@ export const createLogger = ({ verbose, silent }: { verbose: boolean; silent: bo
       if (!verbose) return;
       writeLog('skipped', `Skipped ${payload.component} in ${formatPathLocation(payload.path)} (${payload.reason})`);
     },
+    forced(payload) {
+      writeLog(
+        'forced',
+        `Force-optimized ${payload.component} in ${formatPathLocation(payload.path)} (skipped bailout: ${payload.reason})`
+      );
+    },
     warning(payload) {
       const context = formatWarningContext(payload);
       const message = context.length > 0 ? `${context}: ${payload.message}` : payload.message;
@@ -52,12 +60,14 @@ function formatWarningContext(payload: WarningLogPayload): string {
   return location;
 }
 
-function writeLog(level: 'optimized' | 'skipped' | 'warning', message: string): void {
+type LogLevel = 'optimized' | 'skipped' | 'forced' | 'warning';
+
+function writeLog(level: LogLevel, message: string): void {
   const levelTag = formatLevel(level);
   console.log(`${LOG_PREFIX} ${levelTag} ${message}`);
 }
 
-function formatLevel(level: 'optimized' | 'skipped' | 'warning'): string {
+function formatLevel(level: LogLevel): string {
   if (level === 'optimized') {
     return colorize('[optimized]', ANSI_GREEN);
   }
@@ -66,6 +76,10 @@ function formatLevel(level: 'optimized' | 'skipped' | 'warning'): string {
     return colorize('[skipped]', ANSI_YELLOW);
   }
 
+  if (level === 'forced') {
+    return colorize('[forced]', ANSI_RED);
+  }
+
   return colorize('[warning]', ANSI_MAGENTA);
 }