feat(mirror): ignore OS limitations when mirroring to mobile

Author: caugner

scripts/build/mirror.test.ts

@@ -7,9 +7,69 @@ import { BrowserName } from '../../types/types.js';
 import bcd from '../../index.js';
 import { InternalSupportBlock } from '../../types/index.js';
 
-import mirrorSupport from './mirror.js';
+import mirrorSupport, { isOSLimitation } from './mirror.js';
 
 describe('mirror', () => {
+  describe('isOSLimitation', () => {
+    it('returns false for undefined notes', () => {
+      assert.equal(isOSLimitation(undefined), false);
+    });
+
+    it('returns true for OS limitation notes', () => {
+      assert.equal(
+        isOSLimitation('Supported on ChromeOS, macOS, and Windows only.'),
+        true,
+      );
+      assert.equal(
+        isOSLimitation('Supported on Linux and Windows only.'),
+        true,
+      );
+      assert.equal(isOSLimitation('Supported on macOS only.'), true);
+      assert.equal(isOSLimitation('Not supported on Windows.'), true);
+      assert.equal(isOSLimitation('Not yet supported on macOS.'), true);
+    });
+
+    it('returns false for non-OS-limitation notes', () => {
+      assert.equal(
+        isOSLimitation('This feature requires a flag to be enabled.'),
+        false,
+      );
+      assert.equal(
+        isOSLimitation('Before version 70, this method always returned true.'),
+        false,
+      );
+      assert.equal(
+        isOSLimitation('Firefox 73 added support for this thing.'),
+        false,
+      );
+    });
+
+    it('handles array of notes (returns true only if all match)', () => {
+      assert.equal(
+        isOSLimitation([
+          'Supported on ChromeOS, macOS, and Windows only.',
+          'Not yet supported on Linux.',
+        ]),
+        true,
+      );
+      assert.equal(
+        isOSLimitation([
+          'Supported on ChromeOS, macOS, and Windows only.',
+          'This feature requires a flag.',
+        ]),
+        false,
+      );
+      assert.equal(
+        isOSLimitation(['This is a note.', 'This is another note.']),
+        false,
+      );
+    });
+
+    it('returns false for empty string', () => {
+      assert.equal(isOSLimitation(''), false);
+    });
+  });
+
   describe('default export', () => {
     describe('version numbers match expected values', () => {
       const mappings: {
@@ -189,6 +249,38 @@ describe('mirror', () => {
           notes: 'This feature is only supported in ChromeOS, macOS and Linux.',
         });
       });
+
+      it('OS-specific partial_implementation and notes are not mirrored', () => {
+        const support = {
+          chrome: {
+            version_added: '134',
+            partial_implementation: true,
+            notes: 'Supported on ChromeOS, macOS, and Windows only.',
+          },
+        };
+
+        const mirrored = mirrorSupport('chrome_android', support);
+        assert.deepEqual(mirrored, {
+          version_added: '134',
+        });
+      });
+
+      it('Non-OS-specific partial_implementation and notes are still mirrored', () => {
+        const support = {
+          chrome: {
+            version_added: '70',
+            partial_implementation: true,
+            notes: 'This feature is incomplete and may not work as expected.',
+          },
+        };
+
+        const mirrored = mirrorSupport('chrome_android', support);
+        assert.deepEqual(mirrored, {
+          version_added: '70',
+          partial_implementation: true,
+          notes: 'This feature is incomplete and may not work as expected.',
+        });
+      });
     });
 
     describe('Validations', () => {

scripts/build/mirror.ts

@@ -16,7 +16,41 @@ const { browsers } = bcd;
 type Notes = string | [string, string, ...string[]] | null;
 
 /**
+ * Check if a support statement has OS-specific limitation notes
+ * @param notes The notes field from a support statement
+ * @returns True if the notes indicate OS-specific limitations
  */
+export const isOSLimitation = (
+  notes: string | string[] | undefined,
+): boolean => {
+  if (notes === undefined) {
+    return false;
+  } else if (Array.isArray(notes)) {
+    return notes.every(isOSLimitation);
+  }
+
+  const words = notes
+    .split(/\s+/)
+    .map((word) => word.toLowerCase().replace(/[,.;:!?]$/g, '')); // Remove trailing punctuation
+
+  if (words.length === 0) {
+    return false;
+  }
+
+  const os = ['chromeos', 'linux', 'macos', 'windows'];
+  const expectedWords = ['supported', 'on', 'only', 'not', 'yet', 'and'];
+
+  let hasOSKeyword = false;
+  for (const word of words) {
+    if (os.includes(word)) {
+      hasOSKeyword = true;
+    } else if (!expectedWords.includes(word)) {
+      return false;
+    }
+  }
+
+  return hasOSKeyword;
+};
 
 const matchingSafariVersions = new Map([
   ['1', '1'],
@@ -215,6 +249,17 @@ export const bumpSupport = (
 
   const newData: SimpleSupportStatement = copyStatement(sourceData);
 
+  if (
+    browsers[sourceBrowser].type === 'desktop' &&
+    browsers[destination].type === 'mobile' &&
+    sourceData.partial_implementation &&
+    isOSLimitation(sourceData.notes)
+  ) {
+    // Ignore partial flag due to OS limitation.
+    delete newData.partial_implementation;
+    delete newData.notes;
+  }
+
   if (!browsers[destination].accepts_flags && newData.flags) {
     // Remove flag data if the target browser doesn't accept flags
     return { version_added: false };
@@ -254,7 +299,8 @@ export const bumpSupport = (
     return { version_added: false };
   }
 
-  if (sourceData.notes) {
+  // Only process notes if they weren't already removed (e.g., for OS-specific limitations)
+  if (sourceData.notes && newData.notes !== undefined) {
     const sourceBrowserName =
       sourceBrowser === 'chrome'
         ? '(Google )?Chrome'