@fitbit/sdk/lib/ProjectConfiguration.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validate = exports.validateStorageGroup = exports.validateDefaultLanguage = exports.validateAppUUID = exports.validateSupportedLocales = exports.validateLocaleDisplayNames = exports.validateLocaleDisplayName = exports.validateBuildTarget = exports.validateRequestedPermissions = exports.validateWipeColor = exports.validateProjectDisplayName = exports.validateDisplayName = exports.validateAppType = exports.normalizeProjectConfig = exports.normalizeLocales = exports.getAllPermissionTypes = exports.Permission = exports.Locales = exports.MAX_DISPLAY_NAME_LENGTH = exports.MAX_LENGTH_APP_CLUSTER_ID = exports.VALID_APP_TYPES = exports.AppType = void 0;
const tslib_1 = require("tslib");
const humanize_list_1 = tslib_1.__importDefault(require("humanize-list"));
const validator_1 = tslib_1.__importDefault(require("validator"));
const lodash_1 = tslib_1.__importDefault(require("lodash"));
const semver_1 = tslib_1.__importDefault(require("semver"));
const buildTargets_1 = tslib_1.__importDefault(require("./buildTargets"));
const DiagnosticList_1 = tslib_1.__importDefault(require("./DiagnosticList"));
const languageTag_1 = require("./languageTag");
const sdkVersion_1 = tslib_1.__importDefault(require("./sdkVersion"));
const knownBuildTargets = Object.keys(buildTargets_1.default);
var AppType;
(function (AppType) {
    AppType["APP"] = "app";
    AppType["CLOCKFACE"] = "clockface";
})(AppType = exports.AppType || (exports.AppType = {}));
exports.VALID_APP_TYPES = Object.values(AppType);
exports.MAX_LENGTH_APP_CLUSTER_ID = 64;
exports.MAX_DISPLAY_NAME_LENGTH = 30;
var Locales;
(function (Locales) {
    Locales["en-US"] = "English (US)";
    Locales["de-DE"] = "German";
    Locales["es-ES"] = "Spanish";
    Locales["fr-FR"] = "French";
    Locales["it-IT"] = "Italian";
    Locales["ja-JP"] = "Japanese";
    Locales["ko-KR"] = "Korean";
    Locales["nl-NL"] = "Dutch";
    Locales["sv-SE"] = "Swedish";
    Locales["zh-CN"] = "Chinese (Simplified)";
    Locales["zh-TW"] = "Chinese (Traditional)";
    Locales["pt-BR"] = "Portuguese (Brazillian)";
    Locales["id-ID"] = "Indonesian (Bahasa)";
    Locales["ro-RO"] = "Romanian";
    Locales["ru-RU"] = "Russian";
    Locales["pl-PL"] = "Polish";
    Locales["cs-CZ"] = "Czech";
})(Locales = exports.Locales || (exports.Locales = {}));
const languageTags = Object.keys(Locales);
var Permission;
(function (Permission) {
    Permission["ACCESS_ACTIVITY"] = "access_activity";
    Permission["ACCESS_AOD"] = "access_aod";
    Permission["ACCESS_APP_CLUSTER_STORAGE"] = "access_app_cluster_storage";
    Permission["ACCESS_CALENDAR"] = "access_calendar";
    Permission["ACCESS_EXERCISE"] = "access_exercise";
    Permission["ACCESS_HEART_RATE"] = "access_heart_rate";
    Permission["ACCESS_INTERNET"] = "access_internet";
    Permission["ACCESS_LOCATION"] = "access_location";
    Permission["ACCESS_SECURE_EXCHANGE"] = "access_secure_exchange";
    Permission["ACCESS_USER_PROFILE"] = "access_user_profile";
    Permission["FITBIT_TOKEN"] = "fitbit_token";
    Permission["RUN_BACKGROUND"] = "run_background";
    Permission["EXTERNAL_APP_COMMUNICATION"] = "external_app_communication";
    Permission["MOBILE_NOTIFICATIONS"] = "mobile_notifications";
})(Permission = exports.Permission || (exports.Permission = {}));
const permissionTypes = [
    {
        key: Permission.ACCESS_ACTIVITY,
        name: 'Activity',
        description: 'Read user activities for today (distance, calories, steps, elevation and active minutes), and daily goals',
    },
    {
        key: Permission.ACCESS_USER_PROFILE,
        name: 'User Profile',
        description: 'Read non-identifiable personal information (gender, age, height, weight, resting HR, basal metabolic rate, stride, HR zones)',
    },
    {
        key: Permission.ACCESS_HEART_RATE,
        name: 'Heart Rate',
        description: 'Application may read the heart-rate sensor in real-time',
    },
    {
        key: Permission.ACCESS_LOCATION,
        name: 'Location',
        description: 'Application and companion may use GPS',
    },
    {
        key: Permission.ACCESS_INTERNET,
        name: 'Internet',
        description: 'Companion may communicate with the Internet using your phone data connection',
    },
    {
        key: Permission.RUN_BACKGROUND,
        name: 'Run in background',
        description: 'Companion may run even when the application is not actively in use',
    },
    {
        key: Permission.ACCESS_EXERCISE,
        name: 'Exercise Tracking',
        description: 'Application may track an exercise',
        sdkVersion: '>=3.0.0',
    },
    {
        key: Permission.ACCESS_APP_CLUSTER_STORAGE,
        name: 'App Cluster Storage',
        description: 'Application may access storage shared by other applications from the same developer',
        sdkVersion: '>=4.0.0',
    },
    {
        key: Permission.ACCESS_CALENDAR,
        name: 'Calendars',
        description: 'Application may access calendar data stored on the mobile device',
        sdkVersion: '>=4.1.0',
    },
];
const restrictedPermissionTypes = [
    {
        key: Permission.FITBIT_TOKEN,
        name: '[Restricted] Fitbit Token',
        description: 'Access Fitbit API token',
    },
    {
        key: Permission.EXTERNAL_APP_COMMUNICATION,
        name: '[Restricted] External Application Communication',
        description: 'Allows communication between external mobile applications and companion',
    },
    {
        key: Permission.ACCESS_SECURE_EXCHANGE,
        name: '[Restricted] Secure Exchange',
        description: 'Allows securing any data and verifying that data was secured',
    },
    {
        key: Permission.ACCESS_AOD,
        name: '[Restricted] Always-on Display',
        description: 'Application may stay active whilst always-on display mode is active',
        sdkVersion: '>=4.1.0',
    },
    {
        key: Permission.MOBILE_NOTIFICATIONS,
        name: '[Restricted] Mobile Notifications',
        description: 'Application may display notifications on the mobile device',
        sdkVersion: '>=4.1.0',
    },
];
function getAllPermissionTypes(options) {
    const { enableProposedAPI, includeRestrictedPermissions } = Object.assign({ enableProposedAPI: false, includeRestrictedPermissions: true }, options);
    return [
        ...permissionTypes,
        ...(includeRestrictedPermissions ? restrictedPermissionTypes : []),
    ].filter((permission) => !permission.sdkVersion ||
        semver_1.default.satisfies(sdkVersion_1.default(), permission.sdkVersion) ||
        enableProposedAPI);
}
exports.getAllPermissionTypes = getAllPermissionTypes;
function constrainedSetDiagnostics({ actualValues, knownValues, valueTypeNoun, notFoundIsFatal = false, }) {
    const unknownValues = lodash_1.default.without(actualValues, ...knownValues);
    const diagnostics = new DiagnosticList_1.default();
    if (unknownValues.length > 0) {
        const unknownValueStrings = unknownValues.filter(lodash_1.default.isString);
        const unknownValueOther = lodash_1.default
            .without(unknownValues, ...unknownValueStrings)
            .map(String);
        if (unknownValueStrings.length) {
            const errStr = `One or more ${valueTypeNoun} was invalid: ${unknownValueStrings.join(', ')}`;
            if (notFoundIsFatal)
                diagnostics.pushFatalError(errStr);
            else
                diagnostics.pushWarning(errStr);
        }
        if (unknownValueOther.length) {
            diagnostics.pushFatalError(`One or more ${valueTypeNoun} was not a string: ${unknownValueOther.join(', ')}`);
        }
    }
    const duplicatedValues = lodash_1.default
        .uniq(actualValues)
        .filter((value) => actualValues.indexOf(value) !== actualValues.lastIndexOf(value));
    if (duplicatedValues.length > 0) {
        diagnostics.pushWarning(`One or more ${valueTypeNoun} was specified multiple times: ${duplicatedValues.join(', ')}`);
    }
    return diagnostics;
}
function normalizeLanguageTag(languageTag) {
    const match = /^([a-z]{2})(-[a-z]{2})?$/i.exec(languageTag);
    if (match === null)
        return languageTag;
    const [, language, region] = match;
    return language.toLowerCase() + (region || '').toUpperCase();
}
function normalizeLocales(locales) {
    const localeMapping = lodash_1.default.mapKeys(Object.keys(Locales), (tag) => tag.split('-')[0]);
    const normalizedLocales = {};
    for (const [locale, localeConfig] of Object.entries(locales)) {
        const mappedLocale = localeMapping[locale];
        if (mappedLocale === undefined) {
            normalizedLocales[normalizeLanguageTag(locale)] = localeConfig;
            continue;
        }
        if (locales[mappedLocale] !== undefined) {
            continue;
        }
        normalizedLocales[mappedLocale] = localeConfig;
    }
    return normalizedLocales;
}
exports.normalizeLocales = normalizeLocales;
function normalizeProjectConfig(config, defaults) {
    if (!lodash_1.default.isPlainObject(config)) {
        throw new TypeError('Project configuration root must be an object');
    }
    const mergedConfig = Object.assign(Object.assign({ appUUID: '', appType: AppType.APP, appDisplayName: '', iconFile: 'resources/icon.png', wipeColor: '', requestedPermissions: [], buildTargets: [], i18n: {}, defaultLanguage: 'en-US' }, defaults), config.fitbit);
    const { requestedPermissions } = mergedConfig;
    if (!Array.isArray(requestedPermissions)) {
        throw new TypeError(`fitbit.requestedPermissions must be an array, not ${typeof requestedPermissions}`);
    }
    mergedConfig.i18n = normalizeLocales(mergedConfig.i18n);
    return mergedConfig;
}
exports.normalizeProjectConfig = normalizeProjectConfig;
function validateAppType(config) {
    const diagnostics = new DiagnosticList_1.default();
    if (exports.VALID_APP_TYPES.indexOf(config.appType) === -1) {
        const appTypeNames = humanize_list_1.default(exports.VALID_APP_TYPES, { conjunction: 'or' });
        diagnostics.pushFatalError(`App type '${config.appType}' is invalid, expected ${appTypeNames}`);
    }
    return diagnostics;
}
exports.validateAppType = validateAppType;
function validateDisplayName(name) {
    if (name.length === 0) {
        return 'Display name must not be blank';
    }
    if (name.length > exports.MAX_DISPLAY_NAME_LENGTH) {
        return `Display name must not exceed ${exports.MAX_DISPLAY_NAME_LENGTH} characters`;
    }
    return true;
}
exports.validateDisplayName = validateDisplayName;
function validateProjectDisplayName(config) {
    const diagnostics = new DiagnosticList_1.default();
    const result = validateDisplayName(config.appDisplayName);
    if (result !== true) {
        diagnostics.pushFatalError(result);
    }
    return diagnostics;
}
exports.validateProjectDisplayName = validateProjectDisplayName;
function validateWipeColor(config) {
    const diagnostics = new DiagnosticList_1.default();
    if (config.appType !== AppType.CLOCKFACE &&
        !validator_1.default.isHexColor(config.wipeColor)) {
        diagnostics.pushFatalError('Wipe color must be a valid hex color');
    }
    return diagnostics;
}
exports.validateWipeColor = validateWipeColor;
function validateRequestedPermissions({ enableProposedAPI, requestedPermissions, }) {
    return constrainedSetDiagnostics({
        actualValues: requestedPermissions,
        knownValues: getAllPermissionTypes({
            enableProposedAPI: !!enableProposedAPI,
        }).map((permission) => permission.key),
        valueTypeNoun: 'requested permissions',
        notFoundIsFatal: false,
    });
}
exports.validateRequestedPermissions = validateRequestedPermissions;
function validateBuildTarget({ buildTargets }, { hasNativeComponents }) {
    const diagnostics = constrainedSetDiagnostics({
        actualValues: buildTargets,
        knownValues: knownBuildTargets,
        valueTypeNoun: 'build targets',
        notFoundIsFatal: true,
    });
    if ((buildTargets === undefined || buildTargets.length === 0) &&
        !hasNativeComponents) {
        diagnostics.pushFatalError('At least one build target must be enabled');
    }
    return diagnostics;
}
exports.validateBuildTarget = validateBuildTarget;
function validateLocaleDisplayName({ i18n }, localeKey) {
    const diagnostics = new DiagnosticList_1.default();
    const locale = i18n[localeKey];
    if (!locale)
        return diagnostics;
    if (!locale.name || locale.name.length === 0) {
        diagnostics.pushFatalError(`Localized display name for ${Locales[localeKey]} must not be blank`);
    }
    if (locale.name.length > exports.MAX_DISPLAY_NAME_LENGTH) {
        diagnostics.pushFatalError(`Localized display name for ${Locales[localeKey]} must not exceed ${exports.MAX_DISPLAY_NAME_LENGTH} characters`);
    }
    return diagnostics;
}
exports.validateLocaleDisplayName = validateLocaleDisplayName;
function validateLocaleDisplayNames(config) {
    const diagnostics = new DiagnosticList_1.default();
    for (const localeKey of Object.keys(Locales)) {
        diagnostics.extend(validateLocaleDisplayName(config, localeKey));
    }
    return diagnostics;
}
exports.validateLocaleDisplayNames = validateLocaleDisplayNames;
function validateSupportedLocales({ i18n }) {
    const diagnostics = new DiagnosticList_1.default();
    const unknownLocales = lodash_1.default.without(Object.keys(i18n), ...Object.keys(Locales));
    if (unknownLocales.length > 0) {
        diagnostics.pushWarning(`Invalid locales: ${unknownLocales.join(', ')}`);
    }
    return diagnostics;
}
exports.validateSupportedLocales = validateSupportedLocales;
function validateAppUUID({ appUUID }) {
    const diagnostics = new DiagnosticList_1.default();
    if (!validator_1.default.isUUID(String(appUUID))) {
        diagnostics.pushFatalError('appUUID must be a valid UUID, run "npx fitbit-build generate-appid" to fix');
    }
    return diagnostics;
}
exports.validateAppUUID = validateAppUUID;
function validateDefaultLanguage(config) {
    const diagnostics = new DiagnosticList_1.default();
    if (!languageTag_1.validateLanguageTag(config.defaultLanguage)) {
        diagnostics.pushFatalError(`Default language is an invalid language tag: ${config.defaultLanguage}. Must be ${humanize_list_1.default(languageTags, { conjunction: 'or' })}.`);
    }
    return diagnostics;
}
exports.validateDefaultLanguage = validateDefaultLanguage;
function validateStorageGroup(config) {
    const diagnostics = new DiagnosticList_1.default();
    const hasRequestedPermission = getAllPermissionTypes({
        enableProposedAPI: !!config.enableProposedAPI,
    })
        .map((permission) => permission.key)
        .filter((permission) => (config.requestedPermissions || []).includes(permission))
        .includes(Permission.ACCESS_APP_CLUSTER_STORAGE);
    if (hasRequestedPermission) {
        if (config.appClusterID === undefined) {
            diagnostics.pushFatalError('App Cluster ID must be set when the App Cluster Storage permission is requested');
        }
        else if (config.appClusterID.length < 1 ||
            config.appClusterID.length > exports.MAX_LENGTH_APP_CLUSTER_ID) {
            diagnostics.pushFatalError('App Cluster ID must be between 1-64 characters');
        }
        else if (!/^([a-z0-9]+)(\.[a-z0-9]+)*$/.test(config.appClusterID)) {
            diagnostics.pushFatalError('App Cluster ID may only contain alphanumeric characters separated by periods, eg: my.app.123');
        }
        if (config.developerID === undefined) {
            diagnostics.pushFatalError('Developer ID must be set when the App Cluster Storage permission is requested');
        }
        else if (!validator_1.default.isUUID(String(config.developerID))) {
            diagnostics.pushFatalError('Developer ID must be a valid UUID');
        }
    }
    else if (config.appClusterID !== undefined ||
        config.developerID !== undefined) {
        diagnostics.pushFatalError('App Cluster Storage permission must be requested to set App Cluster ID and Developer ID fields');
    }
    return diagnostics;
}
exports.validateStorageGroup = validateStorageGroup;
function validate(config, options) {
    const { hasNativeComponents } = Object.assign({ hasNativeComponents: false }, options);
    const diagnostics = new DiagnosticList_1.default();
    [
        validateAppUUID,
        validateProjectDisplayName,
        validateAppType,
        validateWipeColor,
        validateRequestedPermissions,
        validateSupportedLocales,
        validateLocaleDisplayNames,
        validateDefaultLanguage,
        validateStorageGroup,
    ].forEach((validator) => diagnostics.extend(validator(config)));
    diagnostics.extend(validateBuildTarget(config, { hasNativeComponents }));
    return diagnostics;
}
exports.validate = validate;