@fullstory/browser 1.7.1 → 2.0.0-beta.0

package/dist/index.js

@@ -1,178 +1,158 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var snippet = require('@fullstory/snippet');
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-
-  return keys;
-}
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-
-  return target;
-}
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
-var fs = function fs() {
-  return window[window._fs_namespace];
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
 };
 
-var ensureSnippetLoaded = function ensureSnippetLoaded() {
-  var snippetLoaded = !!fs();
-
-  if (!snippetLoaded) {
-    throw Error('FullStory is not loaded, please ensure the init function is invoked before calling FullStory API functions');
-  }
+var getFullStory = function () {
+    if (window._fs_namespace) {
+        return window[window._fs_namespace];
+    }
+    return undefined;
 };
-
-var hasFullStoryWithFunction = function hasFullStoryWithFunction() {
-  ensureSnippetLoaded();
-
-  for (var _len = arguments.length, testNames = new Array(_len), _key = 0; _key < _len; _key++) {
-    testNames[_key] = arguments[_key];
-  }
-
-  return testNames.every(function (current) {
-    return fs()[current];
-  });
+var ensureSnippetLoaded = function () {
+    var fs = getFullStory();
+    if (!fs) {
+        throw Error('FullStory is not loaded, please ensure the init function is invoked before calling FullStory API functions');
+    }
+    return fs;
 };
-
-var guard = function guard(name) {
-  return function () {
-    if (window._fs_dev_mode) {
-      var message = "FullStory is in dev mode and is not recording: ".concat(name, " method not executed");
-      console.warn(message);
-      return message;
+var _init = function (inputOptions, readyCallback) {
+    // Make a copy so we can modify `options` if desired.
+    var options = __assign({}, inputOptions);
+    if (getFullStory()) {
+        console.warn('The FullStory snippet has already been defined elsewhere (likely in the <head> element)');
+        return;
     }
-
-    if (hasFullStoryWithFunction(name)) {
-      var _fs;
-
-      return (_fs = fs())[name].apply(_fs, arguments);
+    // see README for details on the recordCrossDomainIFrames option
+    if (options.recordCrossDomainIFrames) {
+        window._fs_run_in_iframe = true;
     }
-
-    console.warn("FS.".concat(name, " not ready"));
-    return null;
-  };
-};
-
-var event = guard('event');
-var log = guard('log');
-var getCurrentSessionURL = guard('getCurrentSessionURL');
-var identify = guard('identify');
-var setUserVars = guard('setUserVars');
-var consent = guard('consent');
-var shutdown = guard('shutdown');
-var restart = guard('restart');
-var anonymize = guard('anonymize');
-var setVars = guard('setVars');
-
-var _init = function _init(inputOptions, readyCallback) {
-  var options = _objectSpread2({}, inputOptions);
-
-  if (fs()) {
-    console.warn('The FullStory snippet has already been defined elsewhere (likely in the <head> element)');
-    return;
-  }
-
-  if (options.recordCrossDomainIFrames) {
-    window._fs_run_in_iframe = true;
-  }
-
-  if (options.recordOnlyThisIFrame) {
-    window._fs_is_outer_script = true;
-  }
-
-  if (options.cookieDomain) {
-    window._fs_cookie_domain = options.cookieDomain;
-  }
-
-  if (options.debug === true) {
-    if (!options.script) {
-      options.script = 'edge.fullstory.com/s/fs-debug.js';
-    } else {
-      console.warn('Ignoring `debug = true` because `script` is set');
+    // record the contents of this iFrame when embedded in a parent site
+    if (options.recordOnlyThisIFrame) {
+        window._fs_is_outer_script = true;
+    }
+    // Set cookie domain if it was specified.
+    if (options.cookieDomain) {
+        window._fs_cookie_domain = options.cookieDomain;
+    }
+    if (options.debug === true) {
+        if (!options.script) {
+            options.script = 'edge.fullstory.com/s/fs-debug.js';
+        }
+        else {
+            console.warn('Ignoring `debug = true` because `script` is set');
+        }
+    }
+    snippet.initFS(options);
+    var fs = getFullStory();
+    if (!fs) {
+        console.warn('Failed to initialize FS snippet');
+        return;
+    }
+    if (readyCallback) {
+        fs('observe', { type: 'start', callback: readyCallback });
+    }
+    if (options.devMode === true) {
+        var message = 'FullStory was initialized in devMode and will stop recording';
+        fs('trackEvent', {
+            name: 'FullStory Dev Mode',
+            properties: {
+                message_str: message,
+            }
+        });
+        fs('shutdown');
+        window._fs_dev_mode = true;
+        console.warn(message);
     }
-  }
-
-  snippet.initFS(options);
-
-  if (readyCallback) {
-    fs()('observe', {
-      type: 'start',
-      callback: readyCallback
-    });
-  }
-
-  if (options.devMode === true) {
-    var message = 'FullStory was initialized in devMode and will stop recording';
-    event('FullStory Dev Mode', {
-      message_str: message
-    });
-    shutdown();
-    window._fs_dev_mode = true;
-    console.warn(message);
-  }
 };
-
-var initOnce = function initOnce(fn, message) {
-  return function () {
+var initOnce = function (message) { return function (inputOptions, readyCallback) {
     if (window._fs_initialized) {
-      if (message) console.warn(message);
-      return;
+        if (message)
+            console.warn(message);
+        return;
     }
-
-    fn.apply(void 0, arguments);
+    _init(inputOptions, readyCallback);
     window._fs_initialized = true;
-  };
+}; };
+var init = initOnce('FullStory init has already been called once, additional invocations are ignored');
+// normalize undefined into boolean
+var isInitialized = function () { return !!window._fs_initialized; };
+var hasFullStoryWithFunction = function () {
+    var testNames = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        testNames[_i] = arguments[_i];
+    }
+    var fs = ensureSnippetLoaded();
+    return testNames.every(function (current) { return fs[current]; });
 };
-
-var init = initOnce(_init, 'FullStory init has already been called once, additional invocations are ignored');
-var isInitialized = function isInitialized() {
-  return !!window._fs_initialized;
+var guard = function (name) { return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    if (window._fs_dev_mode) {
+        var message = "FullStory is in dev mode and is not recording: ".concat(name, " method not executed");
+        console.warn(message);
+        return message;
+    }
+    var fs = getFullStory();
+    if (hasFullStoryWithFunction(name) && fs) {
+        return fs[name].apply(fs, args);
+    }
+    console.warn("FS.".concat(name, " not ready"));
+    return null;
+}; };
+var buildFullStoryShim = function () {
+    var FS = function (operation, options, source) {
+        var fs = ensureSnippetLoaded();
+        if (window._fs_dev_mode) {
+            var message = 'FullStory is in dev mode and is not recording: method not executed';
+            console.warn(message);
+            return undefined;
+        }
+        return fs(operation, options, source);
+    };
+    FS.anonymize = guard('anonymize');
+    FS.consent = guard('consent');
+    FS.disableConsole = guard('disableConsole');
+    FS.enableConsole = guard('enableConsole');
+    FS.event = guard('event');
+    FS.getCurrentSessionURL = guard('getCurrentSessionURL');
+    FS.identify = guard('identify');
+    FS.log = guard('log');
+    FS.restart = guard('restart');
+    FS.setUserVars = guard('setUserVars');
+    FS.setVars = guard('setVars');
+    FS.shutdown = guard('shutdown');
+    return FS;
 };
+var FullStory = buildFullStoryShim();
 
-exports.anonymize = anonymize;
-exports.consent = consent;
-exports.event = event;
-exports.getCurrentSessionURL = getCurrentSessionURL;
-exports.identify = identify;
+exports.FullStory = FullStory;
 exports.init = init;
 exports.isInitialized = isInitialized;
-exports.log = log;
-exports.restart = restart;
-exports.setUserVars = setUserVars;
-exports.setVars = setVars;
-exports.shutdown = shutdown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fullstory/browser",
-  "version": "1.7.1",
+  "version": "2.0.0-beta.0",
   "description": "The official FullStory browser SDK",
   "repository": "git://github.com/fullstorydev/fullstory-browser-sdk.git",
   "homepage": "https://github.com/fullstorydev/fullstory-browser-sdk",
@@ -11,10 +11,10 @@
   "types": "./dist/index.d.ts",
   "scripts": {
     "clean": "rimraf dist",
-    "test": "npm run lint && npm run test:karma",
-    "test:karma": "karma start --single-run --browsers ChromeHeadless karma.conf.js",
-    "lint": "eslint src test",
-    "build": "tsc src/index.d.ts && rollup -c"
+    "pretest": "tsc --project tsconfig.test.json",
+    "test": "npm run lint && karma start --single-run --browsers ChromeHeadless karma.conf.js",
+    "lint": "eslint src",
+    "build": "rollup -c"
   },
   "files": [
     "dist",
@@ -26,14 +26,19 @@
     "sdk"
   ],
   "dependencies": {
-    "@fullstory/snippet": "1.3.1"
+    "@fullstory/snippet": "2.0.0-beta.2"
   },
   "devDependencies": {
     "@babel/core": "^7.8.7",
     "@babel/eslint-parser": "^7.16.5",
     "@babel/preset-env": "^7.10.4",
     "@babel/register": "^7.8.6",
-    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-typescript": "^11.1.0",
+    "@types/chai": "^4.3.4",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^18.15.11",
+    "@typescript-eslint/eslint-plugin": "^5.58.0",
+    "@typescript-eslint/parser": "^5.58.0",
     "chai": "^4.1.2",
     "eslint": "^8.6.0",
     "eslint-config-airbnb": "^19.0.4",
@@ -48,9 +53,9 @@
     "karma-webpack": "^5.0.0",
     "mocha": "^9.2.0",
     "rimraf": "^2.7.1",
-    "rollup": "^1.32.1",
-    "rollup-plugin-copy": "^3.3.0",
-    "typescript": "^3.8.3",
+    "rollup": "^3.21.0",
+    "tslib": "^2.5.0",
+    "typescript": "^4.2.4",
     "webpack": "^5.76.1"
   }
 }

package/src/index.test.ts

@@ -0,0 +1,172 @@
+import { assert, expect } from 'chai';
+import {
+  FullStory as FS,
+  init,
+  isInitialized,
+  SnippetOptions,
+} from '.';
+
+const testOrg = '123';
+
+beforeEach(() => {
+  if (window[window._fs_namespace ?? '']) {
+    delete window._fs_initialized;
+    delete window._fs_dev_mode;
+    delete window[window._fs_namespace ?? ''];
+    delete window._fs_namespace;
+  }
+});
+
+describe('init', () => {
+  it('should throw error if not initialized with an orgId', () => {
+    expect(() => { init({} as SnippetOptions); }).to.throw();
+  });
+
+  it('should throw error if API called before init', () => {
+    try {
+      FS('log', { msg: 'my log' });
+      expect(false).to.be('this should have thrown');
+    } catch (error) {
+      expect((error as Error).message).to.match(/FullStory is not loaded/);
+    }
+    init({ orgId: testOrg });
+    expect(() => { FS('log', { msg: 'my log' }); }).to.not.throw();
+  });
+
+  it('should add _fs_org value to window object', () => {
+    init({ orgId: testOrg });
+    expect(window._fs_org).to.equal(testOrg);
+  });
+
+  it('should add _fs_run_in_iframe value to window object', () => {
+    init({
+      orgId: testOrg,
+      recordCrossDomainIFrames: true,
+    });
+    expect(window._fs_run_in_iframe).to.equal(true);
+  });
+
+  it('should add _fs_is_outer_script value to window object', () => {
+    init({
+      orgId: testOrg,
+      recordOnlyThisIFrame: true,
+    });
+    expect(window._fs_is_outer_script).to.equal(true);
+  });
+
+  it('should add _fs_dev_mode value to window when initialzed with devMode', () => {
+    init({
+      orgId: testOrg,
+      devMode: true,
+    });
+
+    expect(window._fs_dev_mode).to.equal(true);
+  });
+
+  it('should return whether initialized', () => {
+    let isInit = isInitialized();
+    expect(isInit).to.equal(false);
+
+    init({
+      orgId: testOrg,
+    });
+
+    isInit = isInitialized();
+    expect(isInit).to.equal(true);
+  });
+
+  it('should load fs-debug.js when debug is set', () => {
+    init({
+      orgId: testOrg,
+      debug: true,
+    });
+
+    expect(window._fs_script).to.match(/fs-debug.js$/);
+  });
+});
+
+describe('devMode', () => {
+  let consoleWarnedMessage;
+  const oldConsoleWarn = console.warn;
+  beforeEach(() => {
+    console.warn = (msg) => { consoleWarnedMessage = msg; };
+  });
+
+  afterEach(() => {
+    console.warn = oldConsoleWarn;
+    consoleWarnedMessage = undefined;
+  });
+
+  it('should return a message for functions invoked when in devMode', () => {
+    expect(consoleWarnedMessage).to.equal(undefined);
+    init({
+      orgId: testOrg,
+      devMode: true,
+    });
+
+    expect(consoleWarnedMessage).to.match(/FullStory was initialized in devMode/);
+
+    FS('log', { msg: 'hello world' });
+
+    expect(consoleWarnedMessage).to.match(/FullStory is in dev mode/);
+  });
+});
+
+describe('getCurrentSessionURL', () => {
+  it('should return null before fs.js is fully bootstrapped', () => {
+    init({ orgId: testOrg });
+    // in theory, this is a race condition - assuming that fs.js
+    // can't load by the time the following statement is executed
+    const url = FS('getSession');
+    assert.equal(
+      url,
+      null,
+      'FullStory.getCurrentSessionURL() should return null if executed before fs.js is fully bootstrapped'
+    );
+  });
+});
+
+describe('typescript safety', () => {
+  it('provides type assistance matching the api', () => {
+    // Just a quick non-exhaustive check that types are working as expected.
+    // The "@ts-expect-error" declaration will fail if the types do NOT throw
+    // an error.
+    init({ orgId: testOrg });
+
+    // Passes TypeScript check
+    FS('getSession', { format: 'url.now' });
+
+    // Does not pass (improper format)
+    // @ts-expect-error (for testing purposes)
+    FS('getSession', { format: '😏' });
+
+    // Does not pass (invalid action)
+    // @ts-expect-error (for testing purposes)
+    FS('🦄');
+
+    // Passes TypeScript check
+    FS('observe', { type: 'start', callback: () => console.log('STARTED') });
+
+    // Does not pass (improper type)
+    // @ts-expect-error (for testing purposes)
+    FS('observe', { type: '🦂', callback: () => console.log('STARTED') });
+
+    // LEGACY:
+    // Passes TypeScript check
+    FS.setVars('user', { email: 'e@mail.com' });
+
+    // Does not pass (improper VarScope)
+    // @ts-expect-error (for testing purposes)
+    FS.setVars('🤯', { email: 'e@mail.com' });
+
+    // Passes TypeScript check
+    FS.event('Order Complete', { product_id: 'asdf' });
+
+    // Does not pass (eventName must be string)
+    // @ts-expect-error (for testing purposes)
+    FS.event(42, { product_id: 'asdf' });
+
+    // Assertion for posterity's sake...
+    expect(true).to.equal(true);
+  });
+});