chore: merge beta into master A18S1

HISTORY.md

@@ -108,6 +108,25 @@
 * chore(common): move to 18.0 alpha (#10713)
 * chore: move to 18.0 alpha
 
+## 17.0.317 beta 2024-05-01
+
+*  (#11322)
+*  (#11321)
+* fix(linux): Fix icon for .kmp files (#11295)
+
+## 17.0.316 beta 2024-04-30
+
+* fix(windows): check font count display none found (#11282)
+
+## 17.0.315 beta 2024-04-26
+
+* fix(web): osk-view hidden by default on construction (#11258)
+* fix(android): fixes kbd text zoom to prevent accessibility cross-effects (#11281)
+* fix(developer): support export of visual keyboard when Keyman for Windows not installed (#11244)
+* chore(linux): Prepare for stable release (#11301)
+* fix(core): reset on frame keys (#11172)
+* fix(core): ldml backspace processing should delete all markers (#11254)
+
 ## 17.0.314 beta 2024-04-25
 
 * fix(android/engine): URIEncode strings passed to Javascript (#11206)

VERSION.md

@@ -1 +1 @@
-18.0.26
+18.0.26

common/web/gesture-recognizer/src/engine/headless/gestures/matchers/gestureMatcher.ts

@@ -477,6 +477,13 @@ export class GestureMatcher<Type, StateToken = any> implements PredecessorMatch<
           here, as the decision is made due to a validation check against the initial item.
         */
         this.finalize(false, 'cancelled');
+
+        /*
+         * There's no need to process the gesture-model any further... and the
+         * invalid state may correspond to assumptions in the path-model that
+         * will be invalidated if we continue.
+         */
+        return;
       }
     }
 
@@ -507,6 +514,7 @@ export class GestureMatcher<Type, StateToken = any> implements PredecessorMatch<
         instantly fail and thus cancel.
       */
       this.finalize(false, whileInitializing ? 'cancelled' : 'path');
+      return;
     }
 
     // Standard path:  trigger either resolution or rejection when the contact model signals either.
@@ -516,6 +524,13 @@ export class GestureMatcher<Type, StateToken = any> implements PredecessorMatch<
   }
 
   update() {
-    this.pathMatchers.forEach((matcher) => matcher.update());
+    this.pathMatchers.forEach((matcher) => {
+      try {
+        matcher.update();
+      } catch(err) {
+        console.error(err);
+        this.finalize(false, 'cancelled');
+      }
+    });
   }
 }

common/web/gesture-recognizer/src/engine/headless/gestures/matchers/matcherSelector.ts

@@ -409,10 +409,30 @@ export class MatcherSelector<Type, StateToken = any> extends EventEmitter<EventM
     }
 
     /**
-     * In either case, time to spin up gesture models limited to new sources, that don't combine with
-     * already-active ones.  This could be the first stage in a sequence or a followup to a prior stage.
+     * In either case, time to spin up gesture models limited to new sources,
+     * that don't combine with already-active ones.  This could be the first
+     * stage in a sequence or a followup to a prior stage.
      */
-    let newMatchers = gestureModelSet.map((model) => new GestureMatcher(model, unmatchedSource || priorMatcher));
+    let newMatchers = gestureModelSet.map((model) => {
+      try {
+        /*
+          Spinning up a new gesture model means running code for that model and
+          path, which are defined outside of the engine.  We should not allow
+          errors from engine-external code to prevent us from continuing with
+          unaffected models.
+
+          It's also important to keep the overall flow going; this code is run
+          during touch-start spinup.  An abrupt stop due to an unhandled error
+          here can lock up the AsyncDispatchQueue for touch events, locking up
+          the engine!
+         */
+        return new GestureMatcher(model, unmatchedSource || priorMatcher)
+      } catch (err) {
+        console.error(err);
+        return null;
+      }
+      // Filter out any models that failed to 'spin-up' due to exceptions.
+    }).filter((entry) => !!entry);
 
     // If any newly-activating models are disqualified due to initial conditions, don't add them.
     newMatchers = newMatchers.filter((matcher) => !matcher.result || matcher.result.matched !== false);