bitmovin-player-ui 3.102.0 → 3.102.1-beta.1

package/.github/actions/setup-dependencies/action.yml

@@ -0,0 +1,15 @@
+name: 'Setup Dependencies'
+description: 'Sets up Node.js, caches node modules, and installs dependencies'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Set up node.js
+      uses: actions/setup-node@v5
+      with:
+        node-version-file: .nvmrc
+        cache: 'npm'
+
+    - name: Install dependencies
+      run: npm ci
+      shell: bash

package/.github/scripts/calculateVersionNumber.js

@@ -0,0 +1,61 @@
+const semver = require('semver');
+
+/**
+ * Calculates the full version number based on release type and input version
+ * 
+ * @param {object} core - GitHub Actions core object for logging
+ * @param {string} inputVersionNumber - Base version number (e.g., "3.102.1")
+ * @param {string} releaseType - Type of release (alpha, beta, rc, final)
+ * @param {string} latestTag - Latest existing tag for this version and release type - optional
+ * @returns {object} - Returns object with version_number, major_version, and tag_name
+ */
+function calculateVersionNumber(core, inputVersionNumber, releaseType, latestTag = '') {
+  const isValid = semver.valid(inputVersionNumber);
+  if (!isValid) {
+    throw new Error(`Invalid version number: ${inputVersionNumber}`);
+  }
+  
+  let fullVersion;
+  if (releaseType === 'final') {
+    fullVersion = inputVersionNumber;
+  } else {
+    // Use long prerelease identifiers directly (alpha, beta, rc)
+    const preReleaseTag = releaseType;
+    if (!['alpha', 'beta', 'rc'].includes(preReleaseTag)) {
+      throw new Error(`Invalid release type: ${releaseType}`);
+    }
+
+    let nextNumber = 1;
+    if (latestTag) {
+      const match = latestTag.match(new RegExp(`^v${inputVersionNumber.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-${preReleaseTag}\\.(\\d+)$`));
+      if (match) {
+        nextNumber = parseInt(match[1]) + 1;
+      }
+    }
+    
+    fullVersion = `${inputVersionNumber}-${preReleaseTag}.${nextNumber}`;
+    core.info(`Pre-release tag: ${preReleaseTag}, Latest tag: ${latestTag || 'none'}, next number: ${nextNumber}`);
+  }
+  
+  const isFullVersionValid = semver.valid(fullVersion);
+  if (!isFullVersionValid) {
+    throw new Error(`Generated invalid version: ${fullVersion}`);
+  }
+  
+  const majorVersion = semver.major(fullVersion);
+  const tagName = `v${fullVersion}`;
+  
+  core.info(`Input version: ${inputVersionNumber}`);
+  core.info(`Release type: ${releaseType}`);
+  core.info(`Full version: ${fullVersion}`);
+  core.info(`Major version: ${majorVersion}`);
+  core.info(`Tag name: ${tagName}`);
+  
+  return {
+    version_number: fullVersion,
+    major_version: majorVersion,
+    tag_name: tagName
+  };
+}
+
+module.exports.calculateVersionNumber = calculateVersionNumber;

package/.github/scripts/detectReleaseLevel.js

@@ -0,0 +1,46 @@
+const fs = require('fs');
+
+/**
+ * Detects the release level (minor or patch) based on changelog content
+ * 
+ * @param {object} core - GitHub Actions core object for logging
+ * @param {string} changelogPath - Path to the changelog file (defaults to './CHANGELOG.md')
+ * @returns {string} - Returns 'minor' or 'patch'
+ */
+function detectReleaseLevel(core, changelogPath = './CHANGELOG.md') {
+  const changelogContent = fs.readFileSync(changelogPath, { encoding: 'utf8', flag: 'r' });
+  
+  const unreleasedMatch = changelogContent.match(/## \[?unreleased\]?/i);
+  if (!unreleasedMatch) {
+    throw new Error('No unreleased section found in CHANGELOG.md');
+  }
+  
+  const unreleasedStart = unreleasedMatch.index + unreleasedMatch[0].length;
+  const nextSectionMatch = changelogContent.substring(unreleasedStart).match(/^## /m);
+  const unreleasedEnd = nextSectionMatch ? unreleasedStart + nextSectionMatch.index : changelogContent.length;
+  const unreleasedContent = changelogContent.substring(unreleasedStart, unreleasedEnd);
+  
+  core.info('Unreleased section content:');
+  core.info(unreleasedContent);
+  
+  const hasAdded = /### added/i.test(unreleasedContent);
+  const hasChanged = /### changed/i.test(unreleasedContent);
+  const hasRemoved = /### removed/i.test(unreleasedContent);
+  const hasFixed = /### fixed/i.test(unreleasedContent);
+  
+  let releaseLevel;
+  if (hasAdded || hasChanged || hasRemoved) {
+    releaseLevel = 'minor';
+    core.info('Found Added, Changed, or Removed sections - will create minor release');
+  } else if (hasFixed) {
+    releaseLevel = 'patch';
+    core.info('Found only Fixed sections - will create patch release');
+  } else {
+    throw new Error('No valid changelog entries found in unreleased section');
+  }
+  
+  core.info(`Release level: ${releaseLevel}`);
+  return releaseLevel;
+}
+
+module.exports.detectReleaseLevel = detectReleaseLevel;

package/.github/scripts/notifySlackTeam.js

@@ -1,10 +1,11 @@
 const fs = require('fs');
 const https = require('https');
 
-const jobStatus = process.argv[2];
-const changelogPath = process.argv[3];
-const slackWebhookUrl = process.argv[4];
-const runId = process.argv[5];
+const versionNumber = process.argv[2];
+const jobStatus = process.argv[3];
+const changelogPath = process.argv[4];
+const slackWebhookUrl = process.argv[5];
+const runId = process.argv[6];
 
 const failureSlackChannelId = 'CGRK9DV7H';
 const successSlackChannelId = 'C0LJ16JBS';
@@ -15,16 +16,9 @@ fs.readFile(changelogPath, 'utf8', (err, fileContent) => {
   }
 
   const changelogContent = parseChangelogEntry(fileContent);
-  const releaseVersion = parseReleaseVersion(fileContent);
-  sendSlackMessage(releaseVersion, changelogContent);
+  sendSlackMessage(versionNumber, changelogContent);
 });
 
-function parseReleaseVersion(fileContent) {
-  const regex = /##\s\[(\d+\.\d+.\d+)\]/;
-  const releaseVersion = fileContent.match(regex);
-
-  return releaseVersion[1];
-}
 
 function parseChangelogEntry(fileContent) {
   // The regex looks for the first paragraph starting with "###" until it finds
@@ -39,20 +33,53 @@ function parseChangelogEntry(fileContent) {
 }
 
 function sendSlackMessage(releaseVersion, changelogContent) {
-  let message;
-  let slackChannelId;
+  const slackChannelId = jobStatus === 'success' ? successSlackChannelId : failureSlackChannelId;
+  const generalPayload = {
+    channel: slackChannelId
+  };
+
+  let payload;
   if (jobStatus === 'success') {
-    slackChannelId = successSlackChannelId
-    message = `Changelog v${releaseVersion}\n${changelogContent}`
+    payload = {
+      ...generalPayload,
+      text: `New Bitmovin Player UI version is released!`,
+      attachments: [
+        {
+          title: `CHANGELOG v${releaseVersion}`,
+          color: '#0e7aff',
+          fallback: 'Changelog of the newest release should be displayed here',
+          text: changelogContent,
+          fields: [
+            {
+              title: 'Version',
+              value: `v${releaseVersion}`,
+              short: true,
+            },
+            {
+              title: 'Channel',
+              value: releaseVersion.includes('-') ? 'pre-release' : 'release',
+              short: true,
+            },
+          ],
+        },
+      ],
+    }
   } else {
-    slackChannelId = failureSlackChannelId
-    message = `Release v${releaseVersion} failed.\nPlease check https://github.com/bitmovin/bitmovin-player-ui/actions/runs/${runId}`
+    payload = {
+      ...generalPayload,
+      text: `<!subteam^S06RHTF937F> Release *v${releaseVersion}* failed.`,
+      attachments: [
+        {
+          title: `Release Failure`,
+          color: '#ff0000',
+          fallback: 'Release failed',
+          text: `Please check the <https://github.com/bitmovin/bitmovin-player-ui/actions/runs/${runId}|failed run>`,
+        },
+      ],
+    }
   }
 
-  const sampleData = JSON.stringify({
-    "channel": slackChannelId,
-    "message": message
-  });
+  const sampleData = JSON.stringify(payload);
   const options = {
     method: 'POST',
     headers: {

package/.github/workflows/ci.yml

@@ -5,51 +5,51 @@ on:
     branches:
       - '**'
 
-  workflow_dispatch:
-
   workflow_call:
 
+concurrency:
+  group: ${{ github.event_name == 'workflow_call' && format('release-ci-{0}', github.run_id) || format('ci-{0}', github.ref) }}
+  cancel-in-progress: true
+
 jobs:
-  test_and_build:
+  test:
+    name: Test
     runs-on: ubuntu-latest
 
     steps:
-        # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Set up node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: .nvmrc
-
-      - name: Cache node modules
-        id: cache-nodemodules
-        uses: actions/cache@v4
-        env:
-          cache-name: cache-node-modules
-        with:
-          path: node_modules
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}
-
-      - name: Install dependencies
-        if: steps.cache-nodemodules.outputs.cache-hit != 'true'
-        run: npm ci
+      - name: Setup dependencies
+        uses: ./.github/actions/setup-dependencies
 
       - name: Test
         run: npm test
 
-      - name: Build and prepare for a potential 'npm publish'
-        run: gulp npm-prepare
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup dependencies
+        uses: ./.github/actions/setup-dependencies
+
+      - name: Build
+        run: npx gulp build
+
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
 
-      - name: Package artifact for upload
-        run: tar -czvf artifact.tar.gz dist
-        shell: bash
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
 
-      - uses: actions/upload-artifact@v4
-        with:
-          path: |
-            ${{ github.workspace }}/artifact.tar.gz
-          if-no-files-found: error
-          retention-days: 1
+      - name: Setup dependencies
+        uses: ./.github/actions/setup-dependencies
 
+      - name: Lint
+        run: npx gulp lint

package/.github/workflows/release.yml

@@ -1,84 +1,238 @@
 name: Release
-
-on: 
-  push:
-    tags:
-      - '!player/'
-      - 'v*'
+run-name: Release ${{ inputs.version_number }} ${{ inputs.release_type }}${{ inputs.dry_run && ' (dry run)' || '' }}
+
+on:
+  # For manually triggered workflows
+  workflow_dispatch:
+    inputs:
+      version_number:
+        description: "Version number of the release (no `v` prefix and no `-rc.`, `-beta.`, `-alpha.` suffix)"
+        type: string
+        required: true
+      release_type:
+        description: Select the type of the release
+        type: choice
+        options:
+          - alpha
+          - beta
+          - rc
+          - final
+        required: true
+      dry_run:
+        description: 'Run in dry run mode (skip commits, publishing, docs, and notifications)'
+        type: boolean
+        default: false
+
+  # For being called by other workflows
+  workflow_call:
+    inputs:
+      version_number:
+        description: "Version number of the release (no `v` prefix and no `-rc.`, `-beta.`, `-alpha.` suffix)"
+        type: string
+        required: true
+      release_type:
+        description: Select the type of the release
+        type: string
+        required: true
+      branch_name:
+        description: Branch from which the release should be built. Useful when another workflow calls this one.
+        type: string
+        required: true
+      dry_run:
+        description: 'Run in dry run mode (skip commits, publishing, docs, and notifications)'
+        type: boolean
+        default: false
+    secrets:
+      NPM_AUTH_TOKEN:
+        description: 'NPM authentication token for publishing'
+        required: true
+      GCS_CREDENTIALS:
+        description: 'Google Cloud Storage credentials for uploading docs'
+        required: true
+      SLACK_WEBHOOK_URL:
+        description: 'Slack webhook URL for notifications'
+        required: true
+      RELEASE_DEPLOY_KEY:
+        description: 'SSH deploy key with write access to the repository'
+        required: true
+
+concurrency:
+  group: release-${{ inputs.version_number }}-${{ inputs.release_type }}
+  cancel-in-progress: true
 
 jobs:
-  test_and_build:
-    uses: ./.github/workflows/ci.yml
-
-  download_and_publish:
-    needs: test_and_build
+  version_bump:
+    name: Version Bump
     runs-on: ubuntu-latest
-
+    outputs:
+      major_version: ${{ steps.version_number.outputs.major_version }}
+      version_number: ${{ steps.version_number.outputs.version_number }}
+      tag_name: ${{ steps.version_number.outputs.tag_name }}
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
-          ref: develop
-
-      - name: Install dependencies
-        run: npm ci
+          ssh-key: ${{ secrets.RELEASE_DEPLOY_KEY }}
+          ref: ${{ inputs.branch_name || github.ref }}
+          # Fetch existing tags because we need to create a new one
+          # fetch-tags: true # do not use, currently broken: https://github.com/actions/checkout/issues/1781
+          fetch-depth: 0 # remove this line when `fetch-tags: true` is fixed
+
+      - name: Setup dependencies
+        uses: ./.github/actions/setup-dependencies
+
+      - name: Get latest pre-release tag
+        id: latest_tag
+        if: inputs.release_type != 'final'
+        run: |
+          preReleaseTag="${{ inputs.release_type == 'final' && '' || inputs.release_type }}"
+          latest_tag=$(git tag --list "v${{ inputs.version_number }}-$preReleaseTag.*" | sort -V -r | head -n1 || echo "")
+          echo "latest_tag=$latest_tag" >> $GITHUB_OUTPUT
+
+      - name: Calculate version number
+        uses: actions/github-script@v6
+        id: version_number
+        with:
+          script: |
+            const { calculateVersionNumber } = require('./.github/scripts/calculateVersionNumber.js');
+            
+            const inputVersionNumber = '${{ inputs.version_number }}';
+            const releaseType = '${{ inputs.release_type }}';
+            const latestTag = '${{ steps.latest_tag.outputs.latest_tag }}';
+            
+            try {
+              const result = calculateVersionNumber(core, inputVersionNumber, releaseType, latestTag);
+              
+              core.setOutput('version_number', result.version_number);
+              core.setOutput('major_version', result.major_version);
+              core.setOutput('tag_name', result.tag_name);
+            } catch (error) {
+              core.setFailed(error.message);
+            }
+
+      - name: Bump version in package.json
+        run: |
+          npm version "${{ steps.version_number.outputs.version_number }}" --no-git-tag-version
+        shell: bash
 
-      - name: Read package.json version
+      - name: Update changelog
+        if: inputs.release_type == 'final'
         uses: actions/github-script@v6
-        id: extract-version
         with:
           script: |
-            const { version } = require('./package.json')
-            core.setOutput('packageJsonVersion', version)
+            const fs = require('fs');
+            const { updateChangeLog } = require('./.github/scripts/updateChangelog.js');
+            
+            const versionNumber = '${{ steps.version_number.outputs.version_number }}';
+            const releaseDate = new Date().toISOString().split('T')[0];
+            
+            core.info(`Updating changelog with version ${versionNumber} and date ${releaseDate}`);
+            
+            const changelogContent = fs.readFileSync('./CHANGELOG.md', { encoding: 'utf8', flag: 'r' });
+            const updatedChangelog = updateChangeLog(changelogContent, versionNumber, releaseDate);
+            
+            fs.writeFileSync('./CHANGELOG.md', updatedChangelog, 'utf-8');
+            core.info('Changelog updated successfully');
+
+      - name: Commit and tag the changes
+        if: inputs.dry_run != true
+        run: |
+          git config --global user.name 'Automated Release'
+          git config --global user.email 'release-automation@bitmovin.com'
+          git add package.json CHANGELOG.md
+          git commit -m "Bump version to ${{ steps.version_number.outputs.version_number }}"
+          git tag "${{ steps.version_number.outputs.tag_name }}"
+          git push origin ${{ inputs.branch_name || github.ref_name }}
+          git push origin "${{ steps.version_number.outputs.tag_name }}"
+
+  test:
+    needs: version_bump
+    name: Test, Build and Lint
+    uses: ./.github/workflows/ci.yml
 
-      - uses: actions/download-artifact@v4
+  release:
+    name: Publish Release
+    needs: [test, version_bump]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
         with:
-          path: .
+          ref: ${{ inputs.dry_run == true && github.ref || needs.version_bump.outputs.tag_name }}
+
+      - name: Setup dependencies
+        uses: ./.github/actions/setup-dependencies
 
-      - name: Unpackage artifact files
-        run: tar -xzvf artifact/artifact.tar.gz -C .
+      - name: Build Release
+        run: npx gulp npm-prepare
         shell: bash
 
-      - name: Publish
-        run: ./publish.sh
+      - name: Publish to NPM
+        run: ./publish.sh --version "${{ needs.version_bump.outputs.version_number }}" ${{ inputs.dry_run == true && '--dry-run' || '' }}
         shell: bash
         env:
-          NPM_DRY_RUN: false
           NPM_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }}
 
+  upload_docs:
+    name: Build and upload Documentation
+    needs: [test, version_bump, release]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.dry_run == true && github.ref || needs.version_bump.outputs.tag_name }}
+
+      - name: Setup dependencies
+        uses: ./.github/actions/setup-dependencies
+
       - name: Build documentation
         run: npx typedoc
         shell: bash
 
       - name: Authenticate
+        if: inputs.dry_run != true
         uses: 'google-github-actions/auth@v2'
         with:
           credentials_json: ${{ secrets.GCS_CREDENTIALS }}
 
       - name: Upload docs
+        if: inputs.dry_run != true
         uses: 'google-github-actions/upload-cloud-storage@v2'
         with:
           path: './docs/'
-          destination: "${{ secrets.GCS_BUCKET }}/player/ui/${{ steps.extract-version.outputs.packageJsonVersion }}"
+          destination: "${{ secrets.GCS_BUCKET }}/player/ui/${{ needs.version_bump.outputs.version_number }}"
 
       - name: Upload docs for major version
+        if: inputs.dry_run != true && inputs.release_type == 'final'
         uses: 'google-github-actions/upload-cloud-storage@v2'
         with:
           path: './docs/'
-          destination: "${{ secrets.GCS_BUCKET }}/player/ui/3"
+          destination: "${{ secrets.GCS_BUCKET }}/player/ui/${{ needs.version_bump.outputs.major_version }}"
+
+  notify_success:
+    name: Notify Success
+    needs: [test, version_bump, release, upload_docs]
+    runs-on: ubuntu-latest
+    if: inputs.dry_run != true
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.version_bump.outputs.tag_name }}
 
       - name: Notify team
-        run: node .github/scripts/notifySlackTeam.js 'success' 'CHANGELOG.md' ${{ secrets.RELEASE_SUCCESS_SLACK_WEBHOOK }}
+        run: node .github/scripts/notifySlackTeam.js ${{ needs.version_bump.outputs.version_number }} 'success' 'CHANGELOG.md' ${{ secrets.SLACK_WEBHOOK_URL }}
 
   handle_failure:
+    name: Handle Failure
     runs-on: ubuntu-latest
-    needs: [test_and_build, download_and_publish]
-    if: ${{ always() && (needs.download_and_publish.result == 'failure' || needs.test_and_build.result == 'failure') }}
+    needs: [test, version_bump, release, upload_docs, notify_success]
+    if: ${{ always() && inputs.dry_run != true && (needs.test.result == 'failure' || needs.version_bump.result == 'failure' || needs.release.result == 'failure' || needs.upload_docs.result == 'failure' || needs.notify_success.result == 'failure') }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
         with:
-          ref: develop
+          ref: ${{ needs.version_bump.outputs.tag_name }}
 
       - name: Notify team
-        run: node .github/scripts/notifySlackTeam.js 'failure' 'CHANGELOG.md' ${{ secrets.RELEASE_FAILURE_SLACK_WEBHOOK }} ${{ github.run_id }}
+        run: node .github/scripts/notifySlackTeam.js ${{ needs.version_bump.outputs.version_number }} 'failure' 'CHANGELOG.md' ${{ secrets.SLACK_WEBHOOK_URL }} ${{ github.run_id }}