Add ESLint syntax rules to restrict async syntax, no-floating-promises, and no-misused-promises (#7480)

robwalch · web-flow · commit 178333c02286 · 2025-08-24T19:10:26.000-07:00
ESlint error messages explain reasoning
diff --git a/.eslintrc.js b/.eslintrc.js
@@ -1,3 +1,12 @@
+const asyncKeywordConstraintMsg =
+  'The async keyword adds a `regenerator` dependency in the hls.js ES5 output not allowed in v1 due to bundle size constraints.';
+const selfVsWindowGlobalMsg =
+  'Use `self` instead of `window` to access the global context everywhere (including workers).';
+const arrayFindCompatibilityMsg =
+  'Usage of Array find methods is restricted for compatibility.';
+const arrayFindIndexCompatibilityMsg =
+  'Usage of Array findIndex methods is restricted for compatibility.';
+
 module.exports = {
   env: { browser: true, commonjs: true, es6: true },
   globals: {
@@ -27,20 +36,13 @@ module.exports = {
       2,
       {
         name: 'window',
-        message:
-          'Use `self` instead of `window` to access the global context everywhere (including workers).',
+        message: selfVsWindowGlobalMsg,
       },
       { name: 'SourceBuffer', message: 'Use `self.SourceBuffer`' },
       { name: 'setTimeout', message: 'Use `self.setTimeout`' },
       { name: 'setInterval', message: 'Use `self.setInterval`' },
     ],
 
-    'no-restricted-properties': [
-      2,
-      { property: 'findIndex' }, // Intended to block usage of Array.prototype.findIndex
-      { property: 'find' }, // Intended to block usage of Array.prototype.find
-    ],
-
     'import/first': 1,
     'no-var': 1,
     'no-empty': 1,
@@ -67,6 +69,31 @@ module.exports = {
         'no-unused-vars': 0,
         'no-undef': 0,
         'no-use-before-define': 'off',
+        'no-restricted-syntax': [
+          'error',
+          {
+            selector: 'FunctionDeclaration[async=true]',
+            message: asyncKeywordConstraintMsg,
+          },
+          {
+            selector: 'ArrowFunctionExpression[async=true]',
+            message: asyncKeywordConstraintMsg,
+          },
+          {
+            selector: 'MethodDefinition[value.async=true]',
+            message: asyncKeywordConstraintMsg,
+          },
+          {
+            selector:
+              'MemberExpression[property.name="find"][object.type="Identifier"]',
+            message: arrayFindCompatibilityMsg,
+          },
+          {
+            selector:
+              'MemberExpression[property.name="findIndex"][object.type="Identifier"]',
+            message: arrayFindIndexCompatibilityMsg,
+          },
+        ],
         'import/order': [
           'warn',
           {
@@ -98,6 +125,8 @@ module.exports = {
         '@typescript-eslint/consistent-type-imports': 'error',
         '@typescript-eslint/no-import-type-side-effects': 'error',
         '@typescript-eslint/no-restricted-imports': 'error',
+        '@typescript-eslint/no-floating-promises': 'error',
+        '@typescript-eslint/no-misused-promises': 'error',
       },
     },
   ],
diff --git a/src/controller/abr-controller.ts b/src/controller/abr-controller.ts
@@ -845,43 +845,49 @@ class AbrController extends Logger implements AbrComponentAPI {
             mediaCapabilities,
             this.supportedCache,
           );
-          levelInfo.supportedPromise.then((decodingInfo) => {
-            if (!this.hls) {
-              return;
-            }
-            levelInfo.supportedResult = decodingInfo;
-            const levels = this.hls.levels;
-            const index = levels.indexOf(levelInfo);
-            if (decodingInfo.error) {
-              this.warn(
-                `MediaCapabilities decodingInfo error: "${
-                  decodingInfo.error
-                }" for level ${index} ${stringify(decodingInfo)}`,
-              );
-            } else if (!decodingInfo.supported) {
-              this.warn(
-                `Unsupported MediaCapabilities decodingInfo result for level ${index} ${stringify(
-                  decodingInfo,
-                )}`,
-              );
-              if (index > -1 && levels.length > 1) {
-                this.log(`Removing unsupported level ${index}`);
-                this.hls.removeLevel(index);
-                if (this.hls.loadLevel === -1) {
-                  this.hls.nextLoadLevel = 0;
+          levelInfo.supportedPromise
+            .then((decodingInfo) => {
+              if (!this.hls) {
+                return;
+              }
+              levelInfo.supportedResult = decodingInfo;
+              const levels = this.hls.levels;
+              const index = levels.indexOf(levelInfo);
+              if (decodingInfo.error) {
+                this.warn(
+                  `MediaCapabilities decodingInfo error: "${
+                    decodingInfo.error
+                  }" for level ${index} ${stringify(decodingInfo)}`,
+                );
+              } else if (!decodingInfo.supported) {
+                this.warn(
+                  `Unsupported MediaCapabilities decodingInfo result for level ${index} ${stringify(
+                    decodingInfo,
+                  )}`,
+                );
+                if (index > -1 && levels.length > 1) {
+                  this.log(`Removing unsupported level ${index}`);
+                  this.hls.removeLevel(index);
+                  if (this.hls.loadLevel === -1) {
+                    this.hls.nextLoadLevel = 0;
+                  }
                 }
+              } else if (
+                decodingInfo.decodingInfoResults.some(
+                  (info) =>
+                    info.smooth === false || info.powerEfficient === false,
+                )
+              ) {
+                this.log(
+                  `MediaCapabilities decodingInfo for level ${index} not smooth or powerEfficient: ${stringify(decodingInfo)}`,
+                );
               }
-            } else if (
-              decodingInfo.decodingInfoResults.some(
-                (info) =>
-                  info.smooth === false || info.powerEfficient === false,
-              )
-            ) {
-              this.log(
-                `MediaCapabilities decodingInfo for level ${index} not smooth or powerEfficient: ${stringify(decodingInfo)}`,
+            })
+            .catch((error) => {
+              this.warn(
+                `Error handling MediaCapabilities decodingInfo: ${error}`,
               );
-            }
-          });
+            });
         } else {
           levelInfo.supportedResult = SUPPORTED_INFO_DEFAULT;
         }
diff --git a/src/controller/buffer-controller.ts b/src/controller/buffer-controller.ts
@@ -343,6 +343,7 @@ export default class BufferController extends Logger implements ComponentAPI {
       : null;
     const trackCount = trackNames ? trackNames.length : 0;
     const mediaSourceOpenCallback = () => {
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
       Promise.resolve().then(() => {
         if (this.media && this.mediaSourceOpenOrEnded) {
           this._onMediaSourceOpen();
@@ -417,6 +418,7 @@ transfer tracks: ${stringify(transferredTracks, (key, value) => (key === 'initSe
             >;
             this.sourceBuffers[sbIndex] = sbTuple as any;
             if (sb.updating && this.operationQueue) {
+              // eslint-disable-next-line @typescript-eslint/no-floating-promises
               this.operationQueue.prependBlocker(type);
             }
             this.trackSourceBuffer(type, track);
diff --git a/src/controller/eme-controller.ts b/src/controller/eme-controller.ts
@@ -357,6 +357,7 @@ class EMEController extends Logger implements ComponentAPI {
     } else {
       this.warn(`Could not renew expired session. Missing pssh initData.`);
     }
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     this.removeSession(mediaKeySessionContext);
   }
 
@@ -407,7 +408,7 @@ class EMEController extends Logger implements ComponentAPI {
     keySystemsToAttempt: KeySystems[],
   ): Promise<KeySystemFormats> {
     return new Promise((resolve, reject) => {
-      return this.getKeySystemSelectionPromise(keySystemsToAttempt)
+      this.getKeySystemSelectionPromise(keySystemsToAttempt)
         .then(({ keySystem }) => {
           const keySystemFormat = keySystemDomainToKeySystemFormat(keySystem);
           if (keySystemFormat) {
@@ -774,7 +775,9 @@ class EMEController extends Logger implements ComponentAPI {
         });
       } else if (messageType === 'license-release') {
         if (context.keySystem === KeySystems.FAIRPLAY) {
+          // eslint-disable-next-line @typescript-eslint/no-floating-promises
           this.updateKeySession(context, strToUtf8array('acknowledged'));
+          // eslint-disable-next-line @typescript-eslint/no-floating-promises
           this.removeSession(context);
         }
       } else {
@@ -864,6 +867,7 @@ class EMEController extends Logger implements ComponentAPI {
       .then(() => keyUsablePromise)
       .catch((error) => {
         licenseStatus.removeAllListeners();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this.removeSession(context);
         throw error;
       })
@@ -1231,17 +1235,17 @@ class EMEController extends Logger implements ComponentAPI {
       }
       keySessionContext.licenseXhr = xhr;
 
-      this.setupLicenseXHR(xhr, url, keySessionContext, licenseChallenge).then(
-        ({ xhr, licenseChallenge }) => {
+      this.setupLicenseXHR(xhr, url, keySessionContext, licenseChallenge)
+        .then(({ xhr, licenseChallenge }) => {
           if (keySessionContext.keySystem == KeySystems.PLAYREADY) {
             licenseChallenge = this.unpackPlayReadyKeyMessage(
               xhr,
               licenseChallenge,
             );
           }
           xhr.send(licenseChallenge);
-        },
-      );
+        })
+        .catch(reject);
     });
   }
 
@@ -1407,7 +1411,7 @@ class EMEController extends Logger implements ComponentAPI {
               () => reject(new Error(`MediaKeySession.remove() timeout`)),
               8000,
             );
-            mediaKeysSession.remove().then(resolve);
+            mediaKeysSession.remove().then(resolve).catch(reject);
           })
         : Promise.resolve();
       return removePromise
diff --git a/src/controller/level-controller.ts b/src/controller/level-controller.ts
@@ -263,6 +263,7 @@ export default class LevelController extends BasePlaylistController {
 
     if (levels.length === 0) {
       // Dispatch error after MANIFEST_LOADED is done propagating
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
       Promise.resolve().then(() => {
         if (this.hls) {
           let message = 'no level with compatible codecs found in manifest';
diff --git a/src/controller/stream-controller.ts b/src/controller/stream-controller.ts
@@ -1185,26 +1185,34 @@ export default class StreamController
 
   private _loadBitrateTestFrag(fragment: Fragment, level: Level) {
     fragment.bitrateTest = true;
-    this._doFragLoad(fragment, level).then((data) => {
-      const { hls } = this;
-      const frag = data?.frag;
-      if (!frag || this.fragContextChanged(frag)) {
-        return;
-      }
-      level.fragmentError = 0;
-      this.state = State.IDLE;
-      this.startFragRequested = false;
-      this.bitrateTest = false;
-      const stats = frag.stats;
-      // Bitrate tests fragments are neither parsed nor buffered
-      stats.parsing.start =
-        stats.parsing.end =
-        stats.buffering.start =
-        stats.buffering.end =
-          self.performance.now();
-      hls.trigger(Events.FRAG_LOADED, data as FragLoadedData);
-      frag.bitrateTest = false;
-    });
+    this._doFragLoad(fragment, level)
+      .then((data) => {
+        const { hls } = this;
+        const frag = data?.frag;
+        if (!frag || this.fragContextChanged(frag)) {
+          return;
+        }
+        level.fragmentError = 0;
+        this.state = State.IDLE;
+        this.startFragRequested = false;
+        this.bitrateTest = false;
+        const stats = frag.stats;
+        // Bitrate tests fragments are neither parsed nor buffered
+        stats.parsing.start =
+          stats.parsing.end =
+          stats.buffering.start =
+          stats.buffering.end =
+            self.performance.now();
+        hls.trigger(Events.FRAG_LOADED, data as FragLoadedData);
+        frag.bitrateTest = false;
+      })
+      .catch((reason) => {
+        if (this.state === State.STOPPED || this.state === State.ERROR) {
+          return;
+        }
+        this.warn(reason);
+        this.resetFragmentLoading(fragment);
+      });
   }
 
   private _handleTransmuxComplete(transmuxResult: TransmuxerResult) {
diff --git a/src/demux/sample-aes.ts b/src/demux/sample-aes.ts
@@ -56,14 +56,16 @@ class SampleAesDecrypter {
       encryptedData.byteOffset + encryptedData.length,
     );
 
-    this.decryptBuffer(encryptedBuffer).then((decryptedBuffer: ArrayBuffer) => {
-      const decryptedData = new Uint8Array(decryptedBuffer);
-      curUnit.set(decryptedData, 16);
+    this.decryptBuffer(encryptedBuffer)
+      .then((decryptedBuffer: ArrayBuffer) => {
+        const decryptedData = new Uint8Array(decryptedBuffer);
+        curUnit.set(decryptedData, 16);
 
-      if (!this.decrypter.isSync()) {
-        this.decryptAacSamples(samples, sampleIndex + 1, callback);
-      }
-    });
+        if (!this.decrypter.isSync()) {
+          this.decryptAacSamples(samples, sampleIndex + 1, callback);
+        }
+      })
+      .catch(callback);
   }
 
   decryptAacSamples(
@@ -136,13 +138,15 @@ class SampleAesDecrypter {
     const decodedData = discardEPB(curUnit.data);
     const encryptedData = this.getAvcEncryptedData(decodedData);
 
-    this.decryptBuffer(encryptedData.buffer).then((decryptedBuffer) => {
-      curUnit.data = this.getAvcDecryptedUnit(decodedData, decryptedBuffer);
+    this.decryptBuffer(encryptedData.buffer)
+      .then((decryptedBuffer) => {
+        curUnit.data = this.getAvcDecryptedUnit(decodedData, decryptedBuffer);
 
-      if (!this.decrypter.isSync()) {
-        this.decryptAvcSamples(samples, sampleIndex, unitIndex + 1, callback);
-      }
-    });
+        if (!this.decrypter.isSync()) {
+          this.decryptAvcSamples(samples, sampleIndex, unitIndex + 1, callback);
+        }
+      })
+      .catch(callback);
   }
 
   decryptAvcSamples(
diff --git a/src/utils/mediacapabilities-helper.ts b/src/utils/mediacapabilities-helper.ts
diff --git a/tests/unit/controller/eme-controller.ts b/tests/unit/controller/eme-controller.ts
diff --git a/tests/unit/controller/error-controller.ts b/tests/unit/controller/error-controller.ts
