analytics-sdk-generator/dist/TrackingPlan.js

Generates an SDK from an analytics descriptor file

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var EventTypes = __importStar(require("./EventTypes"));
var TypeMapper_1 = __importDefault(require("./TypeMapper"));
var Types_1 = require("./Types");
var TrackingPlan = /** @class */ (function () {
    function TrackingPlan(plan) {
        this.features = [];
        this.screens = [];
        this.tracks = [];
        this.defs = [];
        this.traits = [];
        this.parse(plan);
    }
    TrackingPlan.prototype.parse = function (plan) {
        this.parseTracks(plan['tracks']);
        this.parseScreens(plan['screens']);
        this.parseDefs(plan['$defs']);
        this.parseTraits(plan['traits']);
    };
    TrackingPlan.prototype.parseTraits = function (traits) {
        for (var traitName in traits) {
            this.traits.push(new Types_1.NamedType(traitName, TypeMapper_1.default.toSpecificType(traits[traitName]), traits[traitName].description));
        }
    };
    TrackingPlan.prototype.parseDefs = function (defs) {
        for (var defName in defs) {
            this.defs.push(new Types_1.NamedType(defName, TypeMapper_1.default.toSpecificType(defs[defName]), defs[defName].description));
        }
    };
    TrackingPlan.prototype.addFeaturesToEvent = function (definition, event, featureKey) {
        if ('features' in definition) {
            for (var _i = 0, _a = definition['features']; _i < _a.length; _i++) {
                var featureName = _a[_i];
                var feature = this.getFeature(featureName);
                feature[featureKey].push(event);
                event.features.push(feature);
            }
        }
    };
    TrackingPlan.prototype.addTracksToScreen = function (definition, screen) {
        if ('tracks' in definition) {
            for (var _i = 0, _a = definition['tracks']; _i < _a.length; _i++) {
                var trackName = _a[_i];
                var t = this.getTrack(trackName);
                screen.tracks.push(t.toScreenSpecific(screen));
                t.screens.push(screen);
            }
        }
    };
    TrackingPlan.prototype.parseScreen = function (screens, key) {
        var screen = new EventTypes.Screen(__assign(__assign({}, screens[key]), { key: key }));
        this.addFeaturesToEvent(screens[key], screen, 'screens');
        this.addTracksToScreen(screens[key], screen);
        return screen;
    };
    TrackingPlan.prototype.parseScreens = function (screens) {
        for (var key in screens) {
            this.screens.push(this.parseScreen(screens, key));
        }
    };
    TrackingPlan.prototype.parseTracks = function (tracks) {
        for (var key in tracks) {
            var track = new EventTypes.Track(__assign(__assign({}, tracks[key]), { key: key }));
            this.addFeaturesToEvent(tracks[key], track, 'tracks');
            this.tracks.push(track);
        }
    };
    TrackingPlan.prototype.getOrCreate = function (thing, key, name, newtype) {
        var matches = this[thing].filter(function (f) { return f[key] == name; });
        if (matches.length == 0) {
            if (newtype) {
                var newthing = new newtype(name);
                this[thing].push(newthing);
                return newthing;
            }
            else {
                throw new Error("Thing(" + thing + "/" + name + ") not found");
            }
        }
        else {
            return matches[0];
        }
    };
    TrackingPlan.prototype.getFeature = function (featureName) {
        return this.getOrCreate('features', 'name', featureName, EventTypes.Feature);
    };
    TrackingPlan.prototype.getTrack = function (trackName) {
        return this.getOrCreate('tracks', 'key', trackName, undefined);
    };
    TrackingPlan.prototype.getScreen = function (screenName) {
        return this.getOrCreate('screens', 'key', screenName, undefined);
    };
    return TrackingPlan;
}());
exports.default = TrackingPlan;
//# sourceMappingURL=TrackingPlan.js.map