diff options
Diffstat (limited to 'shared/metrics-8/node_modules/@amp-metrics/ae-client-kit-core/dist')
| -rw-r--r-- | shared/metrics-8/node_modules/@amp-metrics/ae-client-kit-core/dist/ae-client-kit-core.esm.js | 901 |
1 files changed, 901 insertions, 0 deletions
diff --git a/shared/metrics-8/node_modules/@amp-metrics/ae-client-kit-core/dist/ae-client-kit-core.esm.js b/shared/metrics-8/node_modules/@amp-metrics/ae-client-kit-core/dist/ae-client-kit-core.esm.js new file mode 100644 index 0000000..c5828f0 --- /dev/null +++ b/shared/metrics-8/node_modules/@amp-metrics/ae-client-kit-core/dist/ae-client-kit-core.esm.js @@ -0,0 +1,901 @@ +import { reflect, string, storage } from '@amp-metrics/mt-metricskit-utils-private'; + +/* + * src/helpers/constants.js + * ae-client-kit-core + * + * Copyright © 2019 Apple Inc. All rights reserved. + * + */ + +var _allBaseFieldNames; +var _environmentBaseFieldNames; + +function requiredEnvironmentBaseFieldNames() { + return [ + 'app', + 'appVersion', + 'hardwareFamily', + 'hardwareModel', + 'os', + 'osBuildNumber', + 'osLanguages', + 'osVersion', + 'resourceRevNum', + 'screenHeight', + 'screenWidth', + 'userAgent' + ]; +} + +function optionalEnvironmentBaseFieldNames() { + return ['delegateApp', 'hardwareBrand', 'storeFrontCountryCode', 'storeFrontHeader', 'storeFrontLanguage']; +} + +function otherBaseFieldNames() { + return [ + 'baseVersion', + 'clientEventId', + 'connection', + 'eventTime', + 'eventType', + 'eventVersion', + 'timezoneOffset', + 'xpPostFrequency', + 'xpSendMethod' + ]; +} + +function environmentBaseFieldNames() { + if (!_environmentBaseFieldNames) { + _environmentBaseFieldNames = requiredEnvironmentBaseFieldNames().concat(optionalEnvironmentBaseFieldNames()); + } + + return _environmentBaseFieldNames; +} + +function allBaseFieldNames() { + if (!_allBaseFieldNames) { + _allBaseFieldNames = environmentBaseFieldNames().concat(otherBaseFieldNames()); + } + + return _allBaseFieldNames; +} + +/* + * src/event_handlers/Base.js + * ae-client-kit-core + * + * Copyright © 2018 Apple Inc. All rights reserved. + * + */ + +var attachDelegate = reflect.attachDelegate; +var cryptoRandomBase62String = string.cryptoRandomBase62String; +var exceptionString = string.exceptionString; + +var _prototypeInitialized; + +/** + * Creates and returns an object (key/value data map (dictionary)) containing all of the "base" fields common to all metrics events. + * To override any functionality in this class, use the "setDelegate() method in order to override the specific functions that need customization. + * Kits can also extend this class and additional methods specific to their event model. + * @example + * // extend kit-core Base class + * var MetricsKitBase = function MetricsKitBase() { + * kitCore.eventHandlers.Base.apply(this, arguments); // invoke Base constructor + * }; + * MetricsKitBase.prototype = new kitCore.eventHandlers.Base(); + * MetricsKitBase.prototype.constructor = MetricsKitBase; + * + * // set Kit-specific methods + * MetricsKitBase.prototype.environment = function() { return metricsKit.system.environment; } + * MetricsKitBase.prototype.eventRecorder = function() { return metricsKit.system.eventRecorder; } + * MetricsKitBase.prototype.metricsData = function(pageId, pageType, pageContext, callerSuppliedFieldsMapsN) { ... } + * MetricsKitBase.prototype.processMetricsData = function( ... ) { ... } + * + * // extend kit-core known fields + * MetricsKitBase.prototype.knownFields = function knownFields() { + * var parentKnownFields = Object.getPrototypeOf(MetricsKitBase.prototype).knownFields(); + * return parentKnownFields.concat(['dsId', 'anotherUserExperienceOnlyField']); + * }; + * + * // add Kit-specific accessor functions + * MetricsKitBase.prototype.dsId = function dsId() { return this.environment().dsId(); }; + * MetricsKitBase.prototype.anotherUserExperienceOnlyField = function() { ... }; + * + * // create a Kit-specific class instance + * metricsKit.eventHandlers.base = new MetricsKitBase(metricsKit); + * @param {MetricsKit/PerfKit/VPAFKit} kit + * @delegatable + * @constructor + */ +function Base(processor) { + if (!reflect.isDefinedNonNull(processor)) { + throw new Error('A processor instance is required for creating BaseEventHandler.'); + } + // @private + this._processor = processor; + + if (!_prototypeInitialized) { + _prototypeInitialized = true; + environmentBaseFieldNames().forEach(function (fieldName) { + Base.prototype[fieldName] = function (callerSuppliedEventFields) { + var returnValue; + + if (callerSuppliedEventFields && callerSuppliedEventFields.hasOwnProperty(fieldName)) { + returnValue = callerSuppliedEventFields[fieldName]; + } else { + returnValue = this.environment()[fieldName](); + } + + return returnValue; + }; + }); + } +} + +Base._className = 'eventHandlers.base'; + +/** + * Allows replacement of one or more of this class instance's functions + * Any method on the passed-in object which matches a method that this class has will be called instead of the built-in class method. + * To replace *all* methods of his class, simply have your delegate implement all the methods of this class + * Your delegate can be a true object instance, an anonymous object, or a class object. + * Your delegate is free to have as many additional non-matching methods as it likes (these methods will not be copied to the target object). + * It can even act as a delegate for multiple MetricsKit objects, though that is not recommended. + * + * "setDelegate()" may be called repeatedly, with the functions in the most-recently set delegates replacing any functions matching those in the earlier delegates, as well as any as-yet unreplaced functions. + * This allows callers to replace some number of methods that need custom implementations. + * If, for example, a client wants to use the standard logger implementation with the exception of, say, the "debug" method, they can + * call "setDelegate()" with their own delegate containing only a single method of "debug" as the delegate, which would leave all the other methods intact. + * + * NOTE: The delegate function will have a property called origFunction representing the original function that it replaced. + * This allows the delegate to, essentially, call "super" before or after it does some work. + * If a replaced method is overridden again with a subsequent "setDelegate()" call, the "origFunction" property will be the previous delegate's function. + * @example: + * To override one or more methods, in place: + * base.setDelegate({ app: function() { return 'myApp'; }); + * To override one or more methods with a separate object: + * base.setDelegate(customBaseDelegate); + * (where "customBaseDelegate" might be defined elsewhere as, e.g.: + * var customBaseDelegate = { app: function() { return Device.appIdentifier; }; + * appVersion: function() { return Device.appVersion; } }; + * To override one or more methods with an instantiated object from a class definition: + * base.setDelegate(new CustomBaseDelegate()); + * (where "CustomBaseDelegate" might be defined elsewhere as, e.g.: + * function CustomBaseDelegate() {} + * CustomBaseDelegate.prototype.app = function app() { return Device.appIdentifier; }; + * CustomBaseDelegate.prototype.appVersion = function appVersion() { return Device.appVersion; }; + * To override one or more methods with a class object (with "static" methods): + * base.setDelegate(CustomBaseDelegate); + * (where "CustomBaseDelegate" might be defined elsewhere as, e.g.: + * function CustomBaseDelegate() {} + * CustomBaseDelegate.app = function app() { return Device.appIdentifier; }; + * CustomBaseDelegate.appVersion = function appVersion() { return Device.appVersion; }; + * @param {Object} delegate Object or Class with delegate method(s) to be called instead of default (built-in) methods. + * @returns {Boolean} true if one or more methods on the delegate object match one or more methods on the default object, + * otherwise returns false. + */ +Base.prototype.setDelegate = function setDelegate(delegate) { + return attachDelegate(this, delegate); +}; + +/** + * The active environment class + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @see src/system/Environment + * @return {Environment} + * @overridable + */ +Base.prototype.environment = function environment() { + // Don't wrap the throw in a helper function or the backtrace won't be as nice. + throw exceptionString(Base._className, 'environment'); +}; + +/** + * The active eventRecorder + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @return {Object} an event recorder that implements a sendMethod() function + * @overridable + */ +Base.prototype.eventRecorder = function eventRecorder() { + // Don't wrap the throw in a helper function or the backtrace won't be as nice. + throw exceptionString(Base._className, 'eventRecorder'); +}; + +/** + * Creates a simple map object (dictionary) with all the "base" fields required by AMP Analytics + * Some fields can be derived by this class itself. + * Some fields need to be provided by callers. + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @returns key/value pairs of all "base" fields required by AMP Analytics. + * WARNING: May return "null" if metrics are disabled via the metrics.disabled config source value, or on error. + * @overridable + * + * TODO: consider adding default implementation for shared Kit use + */ +Base.prototype.metricsData = function metricsData() { + // Don't wrap the throw in a helper function or the backtrace won't be as nice. + throw exceptionString(Base._className, 'metricsData'); +}; + +/** + * All of the various eventHandlers invoke this method to generate their metrics data + * The data is a simple map object (dictionary) with all the fields required by AMP Analytics for that event + * Some fields can be derived by this class itself. + * This function typically expects to be called with the correct context + * (e.g. base.processMetricsData.apply(this, arguments)) + * @returns {Object} key/value pairs of all fields required by AMP Analytics. + * WARNING: May return "null" if metrics and/or the specific eventType for this handler is disabled, or on error. + * + * TODO: consider adding default implementation for shared Kit use + */ +Base.prototype.processMetricsData = function processMetricsData() { + // Don't wrap the throw in a helper function or the backtrace won't be as nice. + throw exceptionString(Base._className, 'processMetricsData'); +}; + +/** + * @return {Array} all the fields that base eventHandlers know about + */ +Base.prototype.knownFields = function knownFields() { + return allBaseFieldNames(); +}; + +/** + * ********************* ACCESSOR FUNCTIONS ********************* + * We create accessor functions for every data field because: + * 1. Cleans/simplifies all methods that use it. + * 2. Facilitates writing test case shims + * 3. Allows specific feature suppliers to be overridden (via setDelegate())) + */ + +/** + * The app identifier of the binary app + * @param {Map} callerSuppliedEventFields + * @returns {String} The app identifier of the binary app + * @example "com.apple.appstore" or "com.apple.gamecenter" + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.app = function app(callerSuppliedEventFields) { }; + +/** + * The version number of this application + * @example "1.0", "5.43", etc. + * @param {Map} callerSuppliedEventFields + * @returns {String} the version number of this application + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.appVersion = function appVersion(callerSuppliedEventFields) { }; + +/** + * The version of the set of base data to be sent up + * @returns {number} the version of the set of base data to be sent up + * @overridable + */ +Base.prototype.baseVersion = function baseVersion() { + return 1; +}; + +/** + * A unique identifier for each event + * @return {String} + * @overridable + */ +Base.prototype.clientEventId = function clientEventId(callerSuppliedEventFields) { + return (callerSuppliedEventFields && callerSuppliedEventFields.clientEventId) || cryptoRandomBase62String(true); +}; + +/** + * Type of internet connection. + * Only applicable to devices + * Beware that users on WiFi may actually be receiving 3G speeds (i.e. if device is tethered to a portable hotspot.) + * @example "WiFi, "3G, etc. + * @param {Map} callerSuppliedEventFields + * @returns {String} type of internet connection + * @overridable + */ +Base.prototype.connection = function connection(callerSuppliedEventFields) { + return (callerSuppliedEventFields && callerSuppliedEventFields.connection) || this.environment().connectionType(); +}; + +/** + * The identifier of the process generating the event, if different from “app”, or blank otherwise. + * @example 'web-experience-app' + * @returns {String} + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.delegateApp = function delegateApp(callerSuppliedEventFields) { }; + +/** + * The id of this user ("directory service id"). + * This id will get mapped to a consumerId on the server. + * @example 659261189 + * @param {Map} callerSuppliedEventFields + * @returns {String} + * @overridable + */ +Base.prototype.dsId = function dsId(callerSuppliedEventFields) { + return (callerSuppliedEventFields && callerSuppliedEventFields.dsId) || this.environment().dsId(); +}; + +/** + * The time (UTC) in milliseconds at which this event happened. + * This field is central to determining the sequence of user events + * Use online epoch converter to test your values. + * @example 1437356433388 (http://www.epochconverter.com converts that to: July 19, 2015 at 6:40:33 PM PDT GMT-7:00 DST) + * @param {Map} callerSuppliedEventFields + * @returns {number} the time (UTC) in milliseconds at which this event happened + * @overridable + */ +Base.prototype.eventTime = function eventTime(callerSuppliedEventFields) { + return (callerSuppliedEventFields && callerSuppliedEventFields.eventTime) || Date.now(); +}; + +/** + * The version of the set of data to be sent up + * @return {Number} + * @overridable + */ +Base.prototype.eventVersion = function eventVersion(callerSuppliedEventFields) { + return (callerSuppliedEventFields && callerSuppliedEventFields.eventVersion) || null; +}; + +/** + * The hardware brand of the device. Not required for Apple devices. + * @example "Samsung", "LG", "Google" + * @param {Map} callerSuppliedEventFields + * @returns {String} + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.hardwareBrand = function hardwareBrand(callerSuppliedEventFields) { }; + +/** + * The hardware family of the device + * @example "iPhone", "Macbook Pro" + * @param {Map} callerSuppliedEventFields + * @returns {String} + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.hardwareFamily = function hardwareFamily(callerSuppliedEventFields) { }; + +/** + * The model of the device + * @example "iPhone10,2", "MacbookPro11,5" + * @returns {String} + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.hardwareModel = function hardwareModel(callerSuppliedEventFields) { }; + +/** + * The name of the OS + * @example "ios", "macos", "windows" + * @param {Map} callerSuppliedEventFields + * @returns {String} + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.os = function os(callerSuppliedEventFields) { }; + +/** + * The build number of the OS + * @example "15D60", "17E192" + * @param {Map} callerSuppliedEventFields + * @returns {String} + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.osBuildNumber = function osBuildNumber(callerSuppliedEventFields) { }; + +/** + * A string array of language IDs, ordered in descending preference + * @example ["en-US", "fr-CA"] + * @param {Map} callerSuppliedEventFields + * @returns {Array} + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.osLanguages = function osLanguages(callerSuppliedEventFields) { }; + +/** + * The full OS version number + * In ITML, the value can be retrieved via Device.systemVersion + * @example "8.2.1" (iOS) "10.10.3" (Desktop) + * @param {Map} callerSuppliedEventFields + * @returns {String} the full OS version number + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.osVersion = function osVersion(callerSuppliedEventFields) { }; + +/** + * The HTML resources revision number + * @example 2C97 or 8.4.0.0.103 + * @param {Map} callerSuppliedEventFields + * @returns {String} the HTML resources revision number + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.resourceRevNum = function resourceRevNum(callerSuppliedEventFields) { }; + +/** + * The client screen height in pixels + * @example 568 + * @param {Map} callerSuppliedEventFields + * @returns {number} the client screen height in pixels + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.screenHeight = function screenHeight(callerSuppliedEventFields) { }; + +/** + * The client screen width in pixels + * @example 320 + * @param {Map} callerSuppliedEventFields + * @returns {number} the client screen width in pixels + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.screenWidth = function screenWidth(callerSuppliedEventFields) { }; + +/** + * ISO 3166 Country Code. Apps that cannot provide a storeFrontHeader should provide a storeFrontCountryCode instead + * @example US + * @param {Map} callerSuppliedEventFields + * @returns {String} the store front country code + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.storeFrontCountryCode = function storeFrontCountryCode(callerSuppliedEventFields) { }; + +/** + * The value contained in the X-Apple-Store-Front header value at the time the event is being created. + * @example K143441-1,29 ab:rSwnYxS0 + * @param {Map} callerSuppliedEventFields + * @returns {String} the value contained in the X-Apple-Store-Front header value at the time the event is being created + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.storeFrontHeader = function storeFrontHeader(callerSuppliedEventFields) { }; + +/** + * The difference, in minutes, between GMT (UTC) and timezone of event origin ("local time). + * This means that the offset is positive if the local timezone is behind UTC and negative if it is ahead. + * Daylight saving time prevents this value from being a constant, even for a given locale + * @example 420 (PST, not -420) or -600 (Australian Eastern Standard Time, UTC+10) + * @param {Map} callerSuppliedEventFields + * @returns {number} the difference, in minutes, between GMT (UTC) and timezone of event origin ("local time). + * @overridable + */ +Base.prototype.timezoneOffset = function timezoneOffset(callerSuppliedEventFields) { + return (callerSuppliedEventFields && callerSuppliedEventFields.timezoneOffset) || new Date().getTimezoneOffset(); +}; + +/** + * The client’s user agent string. If the "app field is not provided, "userAgent may be used to derive the value of the "app field + * @example AppStore/2.0 iOS/8.3 model/iPhone7,2 build/12F70 (6; dt:106) + * @param {Map} callerSuppliedEventFields + * @returns {String} the client’s user agent string. If the "app field is not provided, "userAgent may be used to derive the value of the "app field + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Base.prototype.userAgent = function userAgent(callerSuppliedEventFields) { }; + +/** + * How often, in milliseconds, batches of events should get sent to the server. + * This field should be based on the client's most recent config value of "postFrequency". + * This is valuable for problem analysis because it indicates if and how clients are honoring the "postFrequency" value + * they were supplied with. + * This cannot be a "passthrough" field, because it can change (via new config) during program execution, so the value + * in effect at event creation time is what is needed. + * @example 60000 + * @param {Map} callerSuppliedEventFields + * @returns {number} how often, in milliseconds, batches of events should get sent to the server + * @overridable + */ +Base.prototype.xpPostFrequency = function xpPostFrequency(callerSuppliedEventFields) { + return ( + (callerSuppliedEventFields && callerSuppliedEventFields.xpPostFrequency) || + this._processor.config.value('postFrequency') + ); +}; + +/** + * The methodology being used by the eventRecorder to send batches of events to the server + * This field should be hardcoded in the client based on what method it is using to encode and send its events to Figaro. + * The three typical values are: + * "itms" - use this value when/if JavaScript code enqueues events for sending via the "itms.recordEvent()" method in ITML. + * "itunes" - use this value when/if JavaScript code enqueues events by calling the "iTunes.recordEvent()" method in Desktop Store apps. + * "javascript" - use this value when/if JavaScript code enqueues events for sending via the JavaScript eventQueue management. This is typically only used by older clients which don't have the built-in functionality of itms or iTunes available to them. + * @example "itms", "itunes", "javascript" + * @param {Map} callerSuppliedEventFields + * @returns {String} the methodology being used by the eventRecorder to send batches of events to the server + * @overridable + */ +Base.prototype.xpSendMethod = function (callerSuppliedEventFields) { + return (callerSuppliedEventFields && callerSuppliedEventFields.xpSendMethod) || this.eventRecorder().sendMethod(); +}; + +/* + * src/event_handlers/index.js + * ae-client-kit-core + * + * Copyright © 2018 Apple Inc. All rights reserved. + * + */ + +var eventHandlers = { + Base: Base +}; + +/* + * src/system/Environment.js + * ae-client-kit-core + * + * Copyright © 2018 Apple Inc. All rights reserved. + * + */ + +var attachDelegate$1 = reflect.attachDelegate; +var exceptionString$1 = string.exceptionString; +var localStorageObject = storage.localStorageObject; +var sessionStorageObject = storage.sessionStorageObject; + +var _prototypeInitialized$1; + +/** + * Provides a set of environment-specific (platform-specific) functions which can be individually overridden for the needs + * of the particular environment, or replaced en masse by providing a single replacement environment delegate object. + * Kits can extend this class and additional methods specific to their event model. + * @example + * // MetricsKit code + * + * // extend kit-core Environment class + * var MetricsKitEnvironment = function MetricsKitEnvironment() { + * kitCore.system.Environment.apply(this, arguments); // invoke Environment constructor + * }; + * MetricsKitEnvironment.prototype = new kitCore.system.Environment(); + * MetricsKitEnvironment.prototype.constructor = MetricsKitEnvironment; + * + * // add Kit-specific functions + * MetricsKitEnvironment.prototype.dsId = function dsId() { + * throw this._exceptionString(_utils.reflect.functionName()); + * }; + * MetricsKitEnvironment.prototype.anotherUserExperienceOnlyField = function() { ... }; + * + * // create a Kit-specific class instance + * metricsKit.system.environment = new MetricsKitEnvironment(); + * + * // client app code remains unchanged: + * var customEnvironmentDelegate = { + * app: function() { return 'myAppName'; }, + * appVersion: function() { ... } // etc. + * }; + * + * metricsKit.system.environment.setDelegate(customEnvironmentDelegate); + * + * @constructor + */ +function Environment() { + // consider moving this code into a separate init method + if (!_prototypeInitialized$1) { + _prototypeInitialized$1 = true; + requiredEnvironmentBaseFieldNames().forEach(function (fieldName) { + Environment.prototype[fieldName] = function () { + throw exceptionString$1(Environment._className, fieldName); + }; + }); + + optionalEnvironmentBaseFieldNames().forEach(function (fieldName) { + Environment.prototype[fieldName] = function () {}; + }); + } +} + +Environment._className = 'system.environment'; + +/** + * Allows replacement of one or more of this class instance's functions + * Any method on the passed-in object which matches a method that this class has will be called instead of the built-in class method. + * To replace *all* methods of his class, simply have your delegate implement all the methods of this class + * Your delegate can be a true object instance, an anonymous object, or a class object. + * Your delegate is free to have as many additional non-matching methods as it likes (these methods will not be copied to the target object). + * It can even act as a delegate for multiple MetricsKit objects, though that is not recommended. + * + * "setDelegate()" may be called repeatedly, with the functions in the most-recently set delegates replacing any functions matching those in the earlier delegates, as well as any as-yet unreplaced functions. + * This allows callers to replace some number of methods that need custom implementations. + * If, for example, a client wants to use the standard logger implementation with the exception of, say, the "debug" method, they can + * call "setDelegate()" with their own delegate containing only a single method of "debug" as the delegate, which would leave all the other methods intact. + * + * NOTE: The delegate function will have a property called origFunction representing the original function that it replaced. + * This allows the delegate to, essentially, call "super" before or after it does some work. + * If a replaced method is overridden again with a subsequent "setDelegate()" call, the "origFunction" property will be the previous delegate's function. + * @example: + * To override one or more methods, in place: + * environment.setDelegate({ app: function() { return 'myApp'; }); + * To override one or more methods with a separate object: + * environment.setDelegate(customEnvironmentDelegate); + * (where "customEnvironmentDelegate" might be defined elsewhere as, e.g.: + * var customEnvironmentDelegate = { app: function() { return Device.appIdentifier; }, + * appVersion: function() { return Device.appVersion; } }; + * To override one or more methods with an instantiated object from a class definition: + * environment.setDelegate(new CustomEnvironmentDelegate()); + * (where "CustomEnvironmentDelegate" might be defined elsewhere as, e.g.: + * function CustomEnvironmentDelegate() {} + * CustomEnvironmentDelegate.prototype.app = function app() { return Device.appIdentifier; }; + * CustomEnvironmentDelegate.prototype.appVersion = function appVersion() { return Device.appVersion; }; + * To override one or more methods with a class object (with "static" methods): + * environment.setDelegate(CustomEnvironmentDelegate); + * (where "CustomEnvironmentDelegate" might be defined elsewhere as, e.g.: + * function CustomEnvironmentDelegate() {} + * CustomEnvironmentDelegate.app = function app() { return Device.appIdentifier; }; + * CustomEnvironmentDelegate.appVersion = function appVersion() { return Device.appVersion; }; + * @param {Object} delegate Object or Class with delegate method(s) to be called instead of default (built-in) methods. + * @returns {Boolean} true if one or more methods on the delegate object match one or more methods on the default object, + * otherwise returns false. + */ +Environment.prototype.setDelegate = function setDelegate(delegate) { + return attachDelegate$1(this, delegate); +}; + +/** + * The app identifier of the binary app + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example "com.apple.appstore" or "com.apple.gamecenter" + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.app = function app() { }; + +/** + * The version number of this application + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example "1.0", "5.43", etc. + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.appVersion = function appVersion() { }; + +/** + * Type of internet connection. + * Only applicable to devices + * Beware that users on WiFi may actually be receiving 3G speeds (i.e. if device is tethered to a portable hotspot.) + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example "WiFi, "3G, etc. + * @returns {String} + */ +Environment.prototype.connectionType = function connectionType() { + // Don't wrap the throw in a helper function or the backtrace won't be as nice. + // TODO: use a constant instead of a hardcoded string + throw exceptionString$1(Environment._className, 'connectionType'); +}; + +/** + * The identifier of the process generating the event, if different from “app”, or blank otherwise. + * NO DEFAULT IMPLEMENTATION... HOWEVER: these fields are not required, so an exception will not be thrown if they + * are omitted. + * @example 'web-experience-app' + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.delegateApp = function delegateApp(callerSuppliedEventFields) { }; + +/** + * The id of this user ("directory service id"). + * This id will get mapped to a consumerId on the server. + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example 659261189 + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +Environment.prototype.dsId = function dsId() { + // Don't throw an exception to avoid breaking minor version backwards compatibility. + // Consider adding an exception in the next major version. +}; + +/** + * The hardware brand of the device. Not required for Apple devices. + * NO DEFAULT IMPLEMENTATION... HOWEVER: these fields are not required, so an exception will not be thrown if they + * are omitted. + * @example "Samsung", "LG", "Google" + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.hardwareBrand = function hardwareBrand() { }; + +/** + * The hardware family of the device + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example "iPhone", "Macbook Pro" + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.hardwareFamily = function hardwareFamily() { }; + +/** + * The model of the device + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example "iPhone10,2", "MacbookPro11,5" + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.hardwareModel = function hardwareModel() { }; + +/** + * The name of the OS + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example "ios", "macos", "windows" + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.os = function os() { }; + +/** + * The build number of the OS + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example "15D60", "17E192" + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.osBuildNumber = function osBuildNumber() { }; + +/** + * A string array of language IDs, ordered in descending preference + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example ["en-US", "fr-CA"] + * @returns {Array} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.osLanguages = function osLanguages() { }; + +/** + * The full OS version number + * In ITML, the value can be retrieved via Device.systemVersion + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example "8.2.1" (iOS) "10.10.3" (Desktop) + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.osVersion = function osVersion() { }; + +/** + * HTML resources revision number + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example 2C97 or 8.4.0.0.103 + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.resourceRevNum = function resourceRevNum() { }; + +/** + * Client screen height in pixels + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example 568 + * @returns {number} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.screenHeight = function screenHeight() { }; + +/** + * Client screen width in pixels + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example 320 + * @returns {number} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.screenWidth = function screenWidth() { }; + +/** + * ISO 3166 Country Code. Apps that cannot provide a storeFrontHeader should provide a storeFrontCountryCode instead + * NO DEFAULT IMPLEMENTATION... Either this method or storeFrontHeader must be replaced. + * are omitted. + * @example US + * @param {Map} callerSuppliedEventFields + * @returns {String} the store front country code + * @overridable + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.storeFrontCountryCode = function storeFrontCountryCode(callerSuppliedEventFields) { }; + +/** + * The value contained in the X-Apple-Store-Front header value at the time the event is being created. + * NO DEFAULT IMPLEMENTATION... Either this method or storeFrontHeader must be replaced. + * @example K143441-1,29 ab:rSwnYxS0 + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.storeFrontHeader = function storeFrontHeader() { }; + +/** + * Client’s user agent string. If the "app field is not provided, "userAgent may be used to derive the value of the "app field + * NO DEFAULT IMPLEMENTATION... THIS METHOD MUST BE REPLACED + * @example AppStore/2.0 iOS/8.3 model/iPhone7,2 build/12F70 (6; dt:106) + * @returns {String} + */ +// This prototype method is created dynamically upon instance initialization +// Environment.prototype.userAgent = function userAgent() { }; + +/** + * Some clients have platform-specific implementations of these objects (e.g. iTunes.sessionStorage), + * so we cover them in case they need to be overridden. + */ +Environment.prototype.localStorageObject = localStorageObject; +Environment.prototype.sessionStorageObject = sessionStorageObject; + +/** + * Fetching identifier entity from AMS Metrics Identifier API + * @param {String} idNamespace - The id namespace that is defined under 'metricsIdentifier' in the bag + * @param {'userid' | 'clientid'} idType - The identifier type (userid or clientid) + * @param {Boolean} crossDeviceSync - The boolean flag to indicate whether the identifier is synced across devices + * @returns {Promise} + * @overridable + */ +Environment.prototype.platformIdentifier = function platformIdentifier() {}; + +/* + * src/system/index.js + * ae-client-kit-core + * + * Copyright © 2018 Apple Inc. All rights reserved. + * + */ + +var system = { + Environment: Environment +}; + +/* + * src/helpers/MetricsData.js + * ae-client-kit-core + * + * Copyright © 2018 Apple Inc. All rights reserved. + * + */ + +/** + * Creates and returns a MetricsData instance with APIs to store event data and create and send events to AMP Analytics + * @delegatable + * @constructor + * @return {MetricsData} + */ +function MetricsData() { + // @private + this._eventData = {}; // this data may be unclean; it should be cleaned before being enqueued as an event +} + +/** + ************************************ PUBLIC METHODS/IVARS ************************************ + */ + +/** + * Add event data to this metricsData object + * This data may be unclean; it should be cleaned before being enqueued as an event + * @param {Object<varargs>} callerSuppliedEventFieldsMapN a variable number of Object arguments from 0-N, + * each containing key/value pairs representing event fields to include when sending the event. + * Later objects take precedence over earlier ones, overriding any field value that may have already been there. + * @overridable + */ +MetricsData.prototype.updateData = function updateData(/* callerSuppliedEventFieldsMapN(varargs) */) { + reflect.extend.apply(null, [this._eventData].concat(Array.prototype.slice.call(arguments))); +}; + +/* + * src/helpers/index.js + * ae-client-kit-core + * + * Copyright © 2018 Apple Inc. All rights reserved. + * + */ + +var helpers = { + MetricsData: MetricsData +}; + +export { eventHandlers, helpers, system }; |