@lightningjs/blits 1.26.2 → 1.27.0

package/.eslintrc.cjs

@@ -52,7 +52,6 @@ module.exports = {
   },
   parser: '@babel/eslint-parser',
   parserOptions: {
-    parser: 'babel-eslint',
     ecmaVersion: 2018,
     sourceType: 'module',
     requireConfigFile: false,

package/.github/workflows/comment-lint-results.yml

@@ -0,0 +1,151 @@
+name: Comment ESLint Results
+
+on:
+  workflow_run:
+    workflows: ["Run ESLint"]
+    types:
+      - completed
+
+jobs:
+  comment-lint-results:
+    # Only run this job if the previous workflow failed (indicating lint errors)
+    if: github.event.workflow_run.conclusion == 'failure'
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    steps:
+    - name: Download Lint Results
+      id: download
+      uses: actions/github-script@v6
+      with:
+        script: |
+          try {
+            core.info('Downloading lint results artifact');
+
+            const artifacts = await github.rest.actions.listWorkflowRunArtifacts({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              run_id: ${{ github.event.workflow_run.id }}
+            });
+
+            const matchArtifact = artifacts.data.artifacts.find(artifact => artifact.name === "lint-results");
+            if (!matchArtifact) {
+              core.setFailed('No lint results artifact found');
+              return false;
+            }
+
+            core.info(`Found artifact id: ${matchArtifact.id}`);
+
+            const download = await github.rest.actions.downloadArtifact({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              artifact_id: matchArtifact.id,
+              archive_format: 'zip'
+            });
+
+            const fs = require('fs');
+            try {
+              fs.writeFileSync('lint-results.zip', Buffer.from(download.data));
+              core.info('Successfully downloaded and saved artifact');
+              return true;
+            } catch (error) {
+              core.setFailed(`Failed to write artifact: ${error.message}`);
+              return false;
+            }
+          } catch (error) {
+            core.setFailed(`Failed to download artifact: ${error.message}`);
+            return false;
+          }
+        result-encoding: string
+
+    - name: Extract Lint Results
+      if: steps.download.outputs.result == 'true'
+      id: extract
+      run: |
+        mkdir -p lint-results
+        unzip -o lint-results.zip -d lint-results
+
+        if [ -f lint-results/errors.md ]; then
+          # Use GitHub's EOF syntax for multiline content
+          echo "LINT_ERRORS<<EOF" >> $GITHUB_ENV
+          cat lint-results/errors.md >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+          echo "HAS_ERRORS=true" >> $GITHUB_OUTPUT
+        else
+          echo "HAS_ERRORS=false" >> $GITHUB_OUTPUT
+        fi
+
+    - name: Find PR Number
+      if: steps.extract.outputs.HAS_ERRORS == 'true'
+      id: find-pr
+      uses: actions/github-script@v6
+      with:
+        script: |
+          try {
+            core.info('Finding associated PR');
+
+            const { owner, repo } = context.repo;
+            const run_id = ${{ github.event.workflow_run.id }};
+
+            // Get the triggering workflow run
+            const run = await github.rest.actions.getWorkflowRun({
+              owner,
+              repo,
+              run_id
+            });
+
+            // Find associated PR - first try the event payload
+            if (run.data.pull_requests && run.data.pull_requests.length > 0) {
+              core.info(`Found PR directly from run data: #${run.data.pull_requests[0].number}`);
+              return run.data.pull_requests[0].number;
+            }
+
+            // Fallback to searching by head SHA
+            core.info(`Searching for PR using head SHA: ${run.data.head_sha}`);
+            const pulls = await github.rest.pulls.list({
+              owner,
+              repo,
+              state: 'open',
+              head: `${owner}:${run.data.head_branch}`
+            });
+
+            if (pulls.data.length > 0) {
+              core.info(`Found PR by branch: #${pulls.data[0].number}`);
+              return pulls.data[0].number;
+            }
+
+            core.info('No PR found for this workflow run');
+            return null;
+          } catch (error) {
+            core.setFailed(`Failed to find PR: ${error.message}`);
+            return null;
+          }
+        result-encoding: string
+
+    - name: Post Lint Results as PR Comment
+      if: steps.find-pr.outputs.result != 'null' && steps.find-pr.outputs.result != ''
+      uses: actions/github-script@v6
+      with:
+        script: |
+          try {
+            const pr_number = parseInt(${{ steps.find-pr.outputs.result }});
+
+            if (isNaN(pr_number)) {
+              core.warning('Invalid PR number');
+              return;
+            }
+
+            core.info(`Posting comment to PR #${pr_number}`);
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: pr_number,
+              body: process.env.LINT_ERRORS
+            });
+
+            core.info(`Successfully posted lint errors comment to PR #${pr_number}`);
+          } catch (error) {
+            core.setFailed(`Failed to post comment: ${error.message}`);
+          }

package/.github/workflows/comment-test-results.yml

@@ -0,0 +1,114 @@
+name: Comment Test Results
+
+on:
+  workflow_run:
+    workflows: ["Run Blits Tests"]
+    types:
+      - completed
+
+jobs:
+  comment-test-results:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    steps:
+    - name: Download Test Results
+      uses: actions/github-script@v6
+      with:
+        script: |
+          const artifacts = await github.rest.actions.listWorkflowRunArtifacts({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            run_id: ${{ github.event.workflow_run.id }}
+          });
+
+          const matchArtifact = artifacts.data.artifacts.find(artifact => artifact.name === "test-results");
+          if (!matchArtifact) {
+            core.setFailed('No test results artifact found');
+            return;
+          }
+
+          const download = await github.rest.actions.downloadArtifact({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            artifact_id: matchArtifact.id,
+            archive_format: 'zip'
+          });
+
+          const fs = require('fs');
+          fs.writeFileSync('test-results.zip', Buffer.from(download.data));
+
+    - name: Extract Test Results
+      run: |
+        mkdir -p test-results
+        unzip -o test-results.zip -d test-results
+
+        TIMESTAMP=$(cat test-results/timestamp.txt)
+        SUMMARY=$(cat test-results/summary.txt)
+        FAILED=$(cat test-results/failed.txt)
+
+        echo "TIMESTAMP=$TIMESTAMP" >> $GITHUB_ENV
+        echo "SUMMARY=$SUMMARY" >> $GITHUB_ENV
+        echo "FAILED=$FAILED" >> $GITHUB_ENV
+
+        # Check if error.txt exists and read it if it does
+        if [ -f test-results/error.txt ]; then
+          # Store raw error output in a file for the next step
+          cat test-results/error.txt > raw_error.txt
+        fi
+
+    - name: Find PR Number
+      id: find-pr
+      uses: actions/github-script@v6
+      with:
+        script: |
+          const { owner, repo } = context.repo;
+          const run_id = ${{ github.event.workflow_run.id }};
+
+          // Get the triggering workflow run
+          const run = await github.rest.actions.getWorkflowRun({
+            owner,
+            repo,
+            run_id
+          });
+
+          // Find associated PR
+          const pulls = await github.rest.pulls.list({
+            owner,
+            repo,
+            state: 'open',
+            head: run.data.head_sha
+          });
+
+          if (pulls.data.length > 0) {
+            return pulls.data[0].number;
+          }
+
+          console.log('No PR found');
+          return null;
+        result-encoding: string
+
+    - name: Post Test Results as PR Comment
+      if: steps.find-pr.outputs.result != 'null'
+      uses: actions/github-script@v6
+      with:
+        script: |
+          const fs = require('fs');
+          const pr_number = parseInt(${{ steps.find-pr.outputs.result }});
+          const status = process.env.FAILED === 'true' ? '❌ FAILED' : '✅ PASSED';
+
+          let commentBody = `#### Test Results: ${status}\n**Run at:** ${process.env.TIMESTAMP}\n\n**Summary:**\n${process.env.SUMMARY}`;
+
+          // Add error output if it exists
+          if (fs.existsSync('raw_error.txt')) {
+            const errorOutput = fs.readFileSync('raw_error.txt', 'utf8');
+            commentBody += '\n\n**Error Output:**\n```\n' + errorOutput + '\n```';
+          }
+
+          github.rest.issues.createComment({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            issue_number: pr_number,
+            body: commentBody
+          });

package/.github/workflows/run-blits-tests.yml

@@ -1,7 +1,7 @@
 name: Run Blits Tests
 
 on:
-  pull_request_target:
+  pull_request:
     branches:
       - dev
       - master
@@ -9,13 +9,12 @@ on:
 jobs:
   run-blits-tests:
     runs-on: ubuntu-latest
+    outputs:
+      tests_failed: ${{ steps.analyze-results.outputs.result && fromJSON(steps.analyze-results.outputs.result).testsFailed }}
 
     steps:
     - name: Checkout Code
       uses: actions/checkout@v3
-      with:
-        ref: ${{ github.event.pull_request.head.ref }}
-        repository: ${{ github.event.pull_request.head.repo.full_name }}
 
     - name: Set up Node.js
       uses: actions/setup-node@v3
@@ -26,44 +25,92 @@ jobs:
       run: npm install
 
     - name: Run Tests
-      run: npm run test > test-report.txt
-      #To ensure subsequent steps run even if tests fail
-      continue-on-error: true
+      id: run-tests
+      run: npm run test > test-report.txt 2>&1 || echo "Command failed with exit code $?" >> test-report.txt
 
-    - name: Get Current Timestamp
-      id: timestamp
-      run: echo "timestamp=$(date)" >> $GITHUB_OUTPUT
+    - name: Analyze Test Results
+      id: analyze-results
+      uses: actions/github-script@v6
+      with:
+        result-encoding: json
+        script: |
+          const fs = require('fs');
+          const timestamp = new Date().toISOString();
 
-    - name: Extract Test Summary
-      id: extracted-test-summary
-      run: |
-        # Search for a line containing both "passed:" and "failed:"
-        summary=$(grep -E "passed:.*failed:" test-report.txt | head -n1)
+          const results = {
+            timestamp,
+            summary: '',
+            testsFailed: false,
+            error: null
+          };
 
-        # Extract the number of failed tests
-        failed=$(echo "$summary" | sed -E 's/.*failed:\s*([0-9]+).*/\1/')
+          // Check if test report exists and has content
+          if (!fs.existsSync('test-report.txt') || !fs.statSync('test-report.txt').size) {
+            results.summary = 'Test execution error: No test output generated.';
+            results.testsFailed = true;
+            return outputResults(results);
+          }
 
-        echo "summary=$summary" >> $GITHUB_OUTPUT
+          // Read test report
+          const testOutput = fs.readFileSync('test-report.txt', 'utf8');
 
-        # If the number of failed tests is greater than 1, exit with error.
-        if [ "$failed" -gt 0 ]; then
-            exit 1
-        fi
+          // Check for errors and test results
+          const hasError = testOutput.includes('Error');
+          const testSummaryMatch = testOutput.match(/passed:\s*(\d+)\s*failed:\s*(\d+)\s*of\s*(\d+)\s*tests/);
 
-    - name: Post Test Results as PR Comment
-      if: always()
-      uses: actions/github-script@v6
-      env:
-          SUMMARY: ${{ steps.extracted-test-summary.outputs.summary }}
-          TIMESTAMP: ${{ steps.timestamp.outputs.timestamp }}
-      with:
-        script: |
-            github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `**Test Results Summary:** (Ran at: ${process.env.TIMESTAMP})\n${process.env.SUMMARY}`
-            });
+          if (hasError && (!testSummaryMatch || testSummaryMatch[3] === '0')) {
+            // Error with no tests or zero tests
+            results.summary = 'Test execution encountered errors. No tests were run.';
+            results.testsFailed = true;
+            results.error = testOutput;
+          } else if (testSummaryMatch) {
+            // We have a test summary
+            const passed = parseInt(testSummaryMatch[1]);
+            const failed = parseInt(testSummaryMatch[2]);
+            const total = parseInt(testSummaryMatch[3]);
+
+            results.summary = testSummaryMatch[0];
+
+            if (failed > 0 || total === 0) {
+              results.testsFailed = true;
+
+              if (total === 0) {
+                results.summary = 'No tests were found to run. This is considered a failure.';
+              }
+            }
+          } else {
+            // No test summary found
+            results.summary = 'Test execution produced no valid test summary';
+            results.testsFailed = true;
+            results.error = testOutput;
+          }
+
+          return outputResults(results);
+
+          /**
+           * Outputs results and saves result files
+           */
+          function outputResults(results) {
+            // Create test results directory and files
+            try {
+              fs.mkdirSync('./test-results', { recursive: true });
+
+              // Write results files
+              fs.writeFileSync('./test-results/timestamp.txt', results.timestamp);
+              fs.writeFileSync('./test-results/summary.txt', results.summary);
+              fs.writeFileSync('./test-results/failed.txt', results.testsFailed.toString());
+
+              // Save error output if it exists
+              if (results.error) {
+                fs.writeFileSync('./test-results/error.txt', results.error);
+              }
+            } catch (err) {
+              console.error('Error saving test results:', err);
+              core.warning(`Error saving test results: ${err.message}`);
+            }
+
+            return results;
+          }
 
     - name: Upload Test Report Artifact
       if: always()
@@ -71,3 +118,15 @@ jobs:
       with:
         name: test-report
         path: test-report.txt
+
+    - name: Upload Test Results
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: test-results
+        path: ./test-results/
+
+    # Fail the workflow if tests failed
+    - name: Check Test Status
+      if: ${{ steps.analyze-results.outputs.result && fromJSON(steps.analyze-results.outputs.result).testsFailed }}
+      run: exit 1

package/.github/workflows/run-lint.yml

@@ -0,0 +1,118 @@
+name: Run ESLint
+
+on:
+  pull_request:
+    branches:
+      - dev
+      - master
+
+jobs:
+  run-lint:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v3
+      with:
+        # Needed to compare changes against base branch
+        fetch-depth: 0
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: 20.16.0
+
+    - name: Install Dependencies
+      run: npm install
+
+    - name: Get list of changed JS files
+      id: changed-files
+      run: |
+        # Get the list of changed .js files compared to the base branch
+        git diff --name-only --diff-filter=ACMRT origin/${{ github.base_ref }} HEAD | grep '\.js$' > js-changed-files.txt || true
+
+        if [ -s js-changed-files.txt ]; then
+          echo "has_js_changes=true" >> $GITHUB_OUTPUT
+          cat js-changed-files.txt | tr '\n' ' ' > js-changed-files-spaces.txt
+          echo "files=$(cat js-changed-files-spaces.txt)" >> $GITHUB_OUTPUT
+        else
+          echo "has_js_changes=false" >> $GITHUB_OUTPUT
+        fi
+
+    - name: Run ESLint on changed files
+      id: eslint
+      if: steps.changed-files.outputs.has_js_changes == 'true'
+      run: |
+        # Create directory for output
+        mkdir -p ./lint-results
+
+        # Run ESLint only on changed files with the project's config
+        # Filtering out warnings - only keep errors
+        npx eslint --config .eslintrc.cjs ${{ steps.changed-files.outputs.files }} -f json > ./lint-results/eslint-output.json || true
+
+        # Check if there are any errors in the ESLint output
+        if [ -s ./lint-results/eslint-output.json ]; then
+          error_count=$(node -e "
+            const results = require('./lint-results/eslint-output.json');
+            let errorCount = 0;
+            for (const file of results) {
+              errorCount += file.errorCount || 0;
+            }
+            console.log(errorCount);
+          ")
+
+          echo "errors_found=$error_count" >> $GITHUB_OUTPUT
+
+          if [ "$error_count" -gt 0 ]; then
+            # Create the formatted error report
+            echo '❌ **Linting errors found**' > ./lint-results/errors.md
+            echo '' >> ./lint-results/errors.md
+            echo 'These linting errors must be fixed before this PR can be merged:' >> ./lint-results/errors.md
+            echo '' >> ./lint-results/errors.md
+            echo '```' >> ./lint-results/errors.md
+
+            # Extract and format errors from the JSON
+            error_count=$(node -e "
+              const results = require('./lint-results/eslint-output.json');
+              let errorSummary = '';
+
+              for (const file of results) {
+                if (file.errorCount > 0) {
+                  const filePath = file.filePath.replace(process.env.GITHUB_WORKSPACE + '/', '');
+                  errorSummary += filePath + '\\n';
+
+                  for (const msg of file.messages) {
+                    if (msg.severity === 2) {
+                      errorSummary += '  Line ' + msg.line + ':' + msg.column + ': ' +
+                                     msg.message + ' (' + msg.ruleId + ')\\n';
+                    }
+                  }
+                  errorSummary += '\\n';
+                }
+              }
+
+              console.log(errorSummary.trim());
+            ")
+
+            echo "$error_count" >> ./lint-results/errors.md
+            echo '```' >> ./lint-results/errors.md
+            echo '' >> ./lint-results/errors.md
+            echo '_Run `npm run lint:fix` to automatically fix some of these issues._' >> ./lint-results/errors.md
+          fi
+        else
+          echo "errors_found=0" >> $GITHUB_OUTPUT
+        fi
+
+    - name: Upload Lint Results
+      if: steps.changed-files.outputs.has_js_changes == 'true'
+      uses: actions/upload-artifact@v4
+      with:
+        name: lint-results
+        path: ./lint-results/
+
+    # Fail the workflow if linting errors found
+    - name: Check Lint Status
+      if: steps.changed-files.outputs.has_js_changes == 'true' && steps.eslint.outputs.errors_found != '0'
+      run: exit 1

package/.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

package/.husky/pre-push

@@ -0,0 +1 @@
+node ./scripts/prepush.js

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+_11 apr 2025_
+
+## v1.27.0
+
+- Added pre push linting check
+- Updated Github workflow for tests
+- Added noop announcement for when announcer is disabled
+- Add ability to interrupt specific announcement messages
+
 _09 apr 2025_
 
 ## v1.26.1 / v1.26.2

package/docs/plugins/text-to-speech-announcer.md

@@ -81,6 +81,8 @@ Imagine an App with a row of tiles, it's possible that before the title of the r
 
 The `speak()`-method return a Promise that also contains a `cancel()` function. When called, it will cancel that specific message and remove it from the queue before it can be spoken out.
 
+Additionally if you want to _interrupt_ a specific messages as it's being spoken out as well and go straight to the next message in the queue (i.e. the newly focused item, for example). You can use the `stop()` message that is returned on the Promise returned by the `speak()`-method.
+
 ```js
 Blits.Component('MyTile', {
   //
@@ -96,7 +98,9 @@ Blits.Component('MyTile', {
       this.message = this.$announcer.speak(`This is tile ${this.title}`)
     },
     unfocus() {
-      // when unfocused cancel the message and remove it from the queue
+      // when unfocused interrupt the message if it's already being spoken out
+      this.message.stop()
+      // and cancel the message to remove it from the queue
       this.message.cancel()
     }
   }

package/index.d.ts

@@ -31,6 +31,11 @@ declare module '@lightningjs/blits' {
      * Does not interupt the message when it's already being announced.
      */
     cancel()
+    /**
+     * Interrupts a specific message as it is being spoken out by the Text to Speech
+     * engine.
+     */
+    stop()
   }
 
   export interface Announcer {
@@ -57,7 +62,7 @@ declare module '@lightningjs/blits' {
     /**
      * Clears out the announcement queue of messages.
      */
-    clears(): void;
+    clear(): void;
     /**
      * Enables the announcer.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightningjs/blits",
-  "version": "1.26.2",
+  "version": "1.27.0",
   "description": "Blits: The Lightning 3 App Development Framework",
   "bin": "bin/index.js",
   "exports": {
@@ -18,7 +18,8 @@
     "lint": "eslint '**/*.js'",
     "lint:fix": "eslint '**/*.js' --fix",
     "prepublishOnly": "node scripts/prepublishOnly.js",
-    "postpublish": "node scripts/postpublish.js"
+    "postpublish": "node scripts/postpublish.js",
+    "prepare": "husky"
   },
   "types": "./index.d.ts",
   "lint-staged": {
@@ -26,26 +27,20 @@
       "eslint --fix"
     ]
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
-  },
   "type": "module",
   "author": "Michiel van der Geest <hello@michielvandergeest.com>",
   "license": "Apache-2.0",
   "devDependencies": {
     "@babel/eslint-parser": "^7.26.5",
     "@babel/plugin-syntax-import-assertions": "^7.26.0",
-    "babel-eslint": "^10.1.0",
     "c8": "^8.0.1",
     "eslint": "^8.8.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^4.0.0",
     "global-jsdom": "24.0.0",
-    "husky": "^7.0.4",
+    "husky": "^9.1.7",
     "jsdom": "24.0.0",
-    "lint-staged": "^12.3.3",
+    "lint-staged": "^15.5.0",
     "prettier": "^2.5.1",
     "tap-diff": "^0.1.1",
     "tape": "^5.5.0"

package/scripts/prepush.js

@@ -0,0 +1,78 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2023 Comcast
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { execSync } from 'child_process'
+import { readFileSync } from 'fs'
+
+// Read the input provided by the pre-push hook
+const input = readFileSync(0, 'utf-8').trim().split(' ')
+if (input.length < 4) {
+  console.log('Insufficient input from pre-push hook. Skipping lint.')
+  process.exit(0)
+}
+
+const localSha = input[1] // The SHA being pushed
+const remoteSha = input[3] // The remote SHA, can be zeros for new branch
+
+// If remote is all zeros, it's a new branch
+const isNewBranch = remoteSha === '0000000000000000000000000000000000000000'
+
+let filesToLint
+
+try {
+  if (isNewBranch) {
+    // For a new branch, compare with dev
+    filesToLint = execSync(`git diff --name-only dev...${localSha} | grep '\\.js$'`, {
+      encoding: 'utf8',
+    })
+  } else {
+    // Only check files in the commits that are being pushed right now
+    filesToLint = execSync(`git diff --name-only ${remoteSha}..${localSha} | grep '\\.js$'`, {
+      encoding: 'utf8',
+    })
+  }
+} catch (error) {
+  // grep will exit with code 1 if it doesn't find anything
+  console.log('No JavaScript files changed. Nothing to lint.')
+  process.exit(0)
+}
+
+if (!filesToLint.trim()) {
+  console.log('No JavaScript files changed. Nothing to lint.')
+  process.exit(0)
+}
+
+const fileList = filesToLint.trim().split('\n')
+console.log(`Running ESLint on ${fileList.length} changed JavaScript files:\n`)
+console.log(filesToLint)
+
+try {
+  // Run ESLint on the changed files
+  execSync(`npx eslint ${fileList.join(' ')}`, { stdio: 'inherit' })
+  console.log('Linting passed successfully!\n')
+  process.exit(0)
+} catch (error) {
+  console.log('\n==========================================================================')
+  console.log('ESLint found issues in your code. Please fix them before pushing.')
+  console.log('You can run:\n')
+  console.log('npx eslint --fix "**/*.js"\n')
+  console.log('on the specific files to automatically fix some issues.')
+  console.log('==========================================================================\n')
+  process.exit(1)
+}

package/src/announcer/announcer.js

@@ -21,6 +21,15 @@ let active = false
 let count = 0
 const queue = []
 let isProcessing = false
+let currentId = null
+let debounce = null
+
+const noopAnnouncement = {
+  then() {},
+  done() {},
+  cancel() {},
+  stop() {},
+}
 
 const enable = () => {
   active = true
@@ -35,13 +44,13 @@ const toggle = (v) => {
 }
 
 const speak = (message, politeness = 'off') => {
-  if (active === false) return
+  if (active === false) return noopAnnouncement
 
   return addToQueue(message, politeness)
 }
 
 const pause = (delay) => {
-  if (active === false) return
+  if (active === false) return noopAnnouncement
 
   return addToQueue(undefined, undefined, delay)
 }
@@ -64,6 +73,15 @@ const addToQueue = (message, politeness, delay = false) => {
     resolveFn('canceled')
   }
 
+  // augment the promise with a stop function
+  done.stop = () => {
+    if (id === currentId) {
+      speechSynthesis.cancel()
+      isProcessing = false
+      resolveFn('interupted')
+    }
+  }
+
   // add message of pause
   if (delay === false) {
     politeness === 'assertive'
@@ -84,26 +102,37 @@ const processQueue = async () => {
   if (isProcessing === true || queue.length === 0) return
   isProcessing = true
 
-  const { message, resolveFn, delay } = queue.shift()
+  const { message, resolveFn, delay, id } = queue.shift()
+
+  currentId = id
 
   if (delay) {
     setTimeout(() => {
       isProcessing = false
+      currentId = null
       resolveFn('finished')
       processQueue()
     }, delay)
   } else {
-    speechSynthesis
-      .speak({ message })
-      .then(() => {
-        isProcessing = false
-        resolveFn('finished')
-        processQueue()
-      })
-      .catch((e) => {
-        isProcessing = false
-        resolveFn(e.error)
-      })
+    if (debounce !== null) clearTimeout(debounce)
+    // add some easing when speaking the messages to reduce stuttering
+    debounce = setTimeout(() => {
+      speechSynthesis
+        .speak({ message })
+        .then(() => {
+          isProcessing = false
+          currentId = null
+          resolveFn('finished')
+          processQueue()
+        })
+        .catch((e) => {
+          isProcessing = false
+          currentId = null
+          resolveFn(e.error)
+          processQueue()
+        })
+      debounce = null
+    }, 200)
   }
 }
 

package/src/components/RouterView.orig.js

@@ -35,7 +35,6 @@ export default () =>
         hashchangeHandler = () => Router.navigate.apply(this)
         Router.navigate.apply(this)
         window.addEventListener('hashchange', hashchangeHandler)
-
       },
       destroy() {
         window.removeEventListener('hashchange', hashchangeHandler, false)

package/src/lib/eventListeners.test.js

@@ -170,7 +170,11 @@ test('deregisterListener - only deregisters specified component listener', (t) =
   eventListener.deregisterListener(componentA, event)
 
   const result = eventListener.executeListeners(event)
-  t.equal(result, true, 'Should return true when listeners are still registered after deregistering one')
+  t.equal(
+    result,
+    true,
+    'Should return true when listeners are still registered after deregistering one'
+  )
   t.equal(callCount1, 0, 'Should not call deregistered callback')
   t.equal(callCount2, 1, 'Should call remaining registered callback')