@playkit-js/taxonomy-transcript/src/providers/data-provider.ts

Custom transcript plugin that displays taxonomy information in addition to the transcript

type Player = KalturaPlayerTypes.Player;
type Logger = KalturaPlayerTypes.Logger;
import { DataLoader } from '../providers/data-loader';
import { VerificationStatus } from '../types/verification-status';
import type { TaxonomyTranscriptConfig } from '../types/taxonomy-transcript-config';
import type { KalturaMediaEntry, KalturaBaseEntryListResponse } from '../types/APIObjects';
import type { CuePoint } from '@playkit-js/kaltura-player-js';

interface Params {
  config: TaxonomyTranscriptConfig;
  logger: Logger;
  player: Player;
  entryId: string;
}

export class DataProvider {
  private entryId: string;
  private config: TaxonomyTranscriptConfig;
  private player: Player;
  private logger: Logger;
  private data: KalturaBaseEntryListResponse | undefined;

  constructor({ config, logger, player, entryId }: Params) {
    this.config = config;
    this.logger = logger;
    this.player = player;
    this.entryId = entryId;
  }

  public fetchData(): void {
    this.player.provider
      .doRequest([{ loader: DataLoader, params: { entryId: this.entryId, responseProfileSystemName: this.config.responseProfileSystemName } }])
      .then((response: Map<string, any>) => {
        if (!response.has(DataLoader.id)) {
          return;
        }

        if (this.isBaseEntry(response.get(DataLoader.id).response[0].data)) {
          this.data = response.get(DataLoader.id).response[0].data;
        }
      })
      .catch((e: unknown) => {
        this.logger.error(`An error occurred: ${e}`);
      });
  }

  public getCaptionsCuePoints(): CuePoint[] {
    this.logger.debug('Getting text track (captions) cue-points');
    const cuePoints = this.player.cuePointManager.getAllCuePoints().filter((cuePoint: CuePoint) => {
      return cuePoint.metadata.cuePointType === 'kalturaCaption';
    });

    return cuePoints;
  }

  public getVerificationStatus(): VerificationStatus {
    const entry = this.data?.objects[0];
    if (!entry) {
      this.logger.warn('Entry not found');
      return VerificationStatus.Empty;
    }

    const transcriptAsset = entry.relatedObjects?.transcriptAsset?.objects[0];
    if (!transcriptAsset) {
      this.logger.warn('Transcript asset not found');
      return VerificationStatus.Empty;
    }

    return transcriptAsset.humanVerified ? VerificationStatus.Verified : VerificationStatus.Automatic;
  }

  public getMentionedTerms(): Record<string, number> {
    const entry = this.data?.objects[0];
    if (!entry) {
      return {};
    }

    const termsMap: Record<string, number> = {};

    entry.relatedObjects?.mentionedTerm?.objects.forEach((object) => {
      const term = object.text;
      if (!term) {
        return;
      }

      if (!termsMap[term]) {
        termsMap[term] = 1;
        return;
      }

      termsMap[term]++;
    });

    return termsMap;
  }

  private isBaseEntry(data: unknown): data is KalturaMediaEntry {
    if (data === null) {
      return false;
    }

    return typeof data === 'object' && 'objectType' in data && data.objectType === 'KalturaBaseEntryListResponse';
  }
}