Nobody Publish Monsters

    @phntms/ft-lib
    TypeScript icon, indicating that this package has built-in type declarations

    0.1.2 • Public • Published

    ft-lib

    NPM version Actions Status PR Welcome

    A collection of Javascript utils for shareable UI and tracking functionality across Phantom FT sites

    Introduction

    currently implemented:

    • FTTracking - Consolidated Origami and GA/GTM event tracking for page and interaction events.
    • consentMonitor - polls the FT consent cookies set by the approved FT Origami cookie banner to enable/disable the FT Permutive ad tracking
    • permutiveVideoUtils - formatted permutive video progress events
    • reactPlayerTracking - Video tracking for FT sites implementing videos with react-player
    • ytIframeEventHandler - Video tracking handler for FT sites with embedded Youtube Iframe API videos.

    Installation

    Install this package with npm.

    npm i @phntms/ft-lib

    Usage

    FTTracking

    Shared Origami and GA/GTM tracking implementation that can be used across all Phantom FT sites. Tracking meta data is provided by a config object when first initiated and on subsequent route changes (only required for SPA/NextJS sites). By default, the implementation will automatically handle FT tracking via data-gadl and data-o-event HTML attributes. The tracker instance should be added to the global window namespace if custom events are required. Note: By default the FTTracker instance will load the consentMonitor poller, so sites do not need to implement this separately.

    The constructor requires the config JSON object (TODO - schema) and optionally accepts an options object:

    Default options

      scrollTrackerSelector: "#o_tracker_scroll",  //top level DOM element selector for scroll tracking
      isCustomGTMEvent: true, //selects between GTM and UA(GTAG) event formats - TODO - handle automatically by detecting loaded GTM/UA?
    
    

    Config/Event format validator

    The site config JSON object passed in the constructor and all events handled by FTTracker are validated with Yup for a basic format check. This includes both the automatic data-o-event, data-gadl generated events and manually fired events with FTTracker.oEvent and FTTracker.gaEvent. A console error is thrown if validation fails. The validation rules can be found in /src/utils/yupValidator.ts

    Typical usage:

    import { FTTracking } from '@phntms/ft-lib'
    
    //For Wagtail sites, get server-rendered o-tracking-data
    const config = JSON.parse(document.getElementById('o-tracking-data').textContent)
    window.FTTracker = new FTTracking(config, { scrollTrackerSelector: '#content' })
    .
    .
    //if an event needs to be fired that can't be added using the preferred data-gadl and data-o-event attributes (i.e. custom players or form submits):
    window.FTTracker.oEvent({category: "audio", action: "progress", duration: duration, progress: {`${progress}%`}})
    window.FTTracker.gaEvent(`Audio`, {`${progress}% progress`}, <AUDIO or PAGE TITLE>)

    consentMonitor

    Adds an FT consent cookie poller to enable/disable Permutive consent (only useful if 'consentRequired' is set as an option in the site's Permutive script - see here There are optional constructor args for the hostname (defaults to window.location.hostname) and the dev environment host matches (defaults to ["localhost", "phq", "vercel.app"]) which are used to determine development environments in order to generate an FT banner event listener ((see here for a list of banner DOM events) to set session-level cookies for development environments

    import { consentMonitor } from "@phntms/ft-lib";
    
    new consentMonitor("FT.staging.testsite.com". ["localhost", "phq", "staging"]);

    permutiveVideoUtils

    emitPermutiveProgressEvents - used within a video player's progress event handler to fire Permutive video progress events at [0, 25, 50, 75, 100] percent progress. Optional 3rd arg to pass a window.interval instance to be cleared once progress is complete.

    import { permutiveVideoUtils } from "@phntms/ft-lib";
    
    const permutivevideoTracker = new permutiveVideoUtils("<FT-CAMPAIGN>","<VIDEO-TITLE>","<VIDEO-ID/URL>")  //Data will be site implementation specific
    
    player.on("progress", () => {   //event will be video player site implementation specific
       permutivevideoTracker.emitPermutiveProgressEvent(<DURATION>, <CURRENTTIME>, <OPTIONAL-WINDOW-INTERVAL>)
    });

    reactPlayerTracking

    Exports video event handlers that broadcast the required GA, oTracking and Permutive events.

    The constructor takes the parent site's FTTracking instance (typically set up as window.FTTracker) and video and site meta data (as required for the tracking data).

    Typical implementation:

    import { reactPlayerTracking } from "@phntms/ft-lib";
    
    const [videoTracker] = useState(
       new reactPlayerTracking(window.FTTracker, <VIDEO-TITLE>, <VIDEO-URL>),
    )
    
    <ReactPlayer
       onDuration={videoTracker.setDuration}
       onEnded={videoTracker.trackEnded}
       onPause={videoTracker.trackPause}
       onPlay={videoTracker.trackPlay}
       onProgress={videoTracker.trackProgress}
    >

    ytIframeTracking

    Exports a Youtube iframe event handler for sites using the Youtube Iframe API that broadcasts the required GA, oTracking and Permutive events. The Youtube iFrame can be either generated in the site's JS or template rendered.

    The constructor takes the parent site's FTTracking instance (typically set up as window.FTTracker).

    NOTE: For Typescript usage as below, the @types/youtube NPM package should be added to the parent project and the YT namespace added to tsconfig.json with the "types": ["youtube"] compiler option.

    Typical implementation:

    import { ytIframeTracking } from '@phntms/ft-lib';
    
    const VIDEO_IFRAME_ID = 'video-iframe';
    
    export class YoutubeIframeLoader {
      videoTracker: ytIframeTracking;
      player?: YT.Player;
    
      constructor() {
       this.videoTracker = new ytIframeTracking(window.FTTracker);
    
       window.onYouTubeIframeAPIReady =
        (event: YT.PlayerEvent) => {
          this.player = new YT.Player(VIDEO_IFRAME_ID, {
            events: {
              'onStateChange': (event) => this.onPlayerStateChange(event)
            }
          });
        };
    
       onPlayerStateChange(event: YT.PlayerEvent) {
        this.videoTracker.ytIframeEventHandler(event);
       }
      }
    }

    Install

    npm i @phntms/ft-lib

    DownloadsWeekly Downloads

    24

    Version

    0.1.2

    License

    MIT

    Unpacked Size

    223 kB

    Total Files

    88

    Last publish

    Collaborators

    • dhiaphntm
    • jpedersen
    • digitaljohn
    • paulomfj