diff options
Diffstat (limited to 'node_modules/@jet-app/app-store/tmp/src/foundation')
55 files changed, 8266 insertions, 0 deletions
diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/amp-localization/amp-localization.js b/node_modules/@jet-app/app-store/tmp/src/foundation/amp-localization/amp-localization.js new file mode 100644 index 0000000..df04983 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/amp-localization/amp-localization.js @@ -0,0 +1,371 @@ +/** + * A type encapsulating localization logic for strings + * returned by localization server. + * + * Replacement for 'its' namespace from @onyx/localization package. + */ +export class AmpLocalization { + constructor() { + // region Properties + /** + * Localization JSON dictionary loaded from localization file. + */ + this.locData = {}; + /** + * The 2-letter code for current device language. + */ + this.language = "en"; + // endregion + } + // endregion + // region API + /** + * Updates the localization data for the device. + * @param localizations A JSON dictionary representing the localized strings. + * @param language Language code for current device language. + */ + updateLocalizationData(localizations, language) { + this.locData = localizations; + this.language = language; + } + /** + * Localizes a string replacing placehoders in key with values in the parameters dictionary + * @param key The loc key to look up + * @param params Parameters to replace in the loc string + * @return The localized string + */ + localize(key, params) { + let value = this.locData[key]; + if (value === undefined || typeof value !== "string") { + value = key; + } + if (params) { + value = this.replaceTokens(value, params); + } + value = this.replaceMarkupTokens(value, params); + return value; + } + /** + * Localize with appropriate plural form based on the count. + * + * Some languages have more plural forms than others. + * The full set of categories is "zero", "one", "two", "few", "many", and "other". + * + * The base loc key is used for "other" (the default). + * Otherwise the category is appended to the base loc key with a "." separator. + * + * http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html + * http://cldr.unicode.org/index/cldr-spec/plural-rules#TOC-Determining-Plural-Categories + * http://unicode.org/repos/cldr/trunk/specs/ldml/tr35-numbers.html#Language_Plural_Rules + * + * English loc keys + * key = "@@count@@ dogs"; // default, aka "plural" + * key.zero = "no dogs"; // used when count is 0 + * key.one = "@@count@@ dog"; // used when count is 1, aka "singular" + * + * @param key base loc key + * @param count number used to determine the plural form + * @param params (optional) substitution keys and values, "count" will be added if it's not already present + * @return localized string + */ + localizeWithCount(objectGraph, key, count, params) { + let keyToUse = null; + let pluralFormKey; + let category; + if (count === 0) { + // Special case zero for all languages so we can have strings like + // "you have no messages" instead of "you have 0 messages". + pluralFormKey = `${key}.zero`; + if (this.isLocalized(objectGraph, pluralFormKey)) { + keyToUse = pluralFormKey; + } + } + if (keyToUse === null) { + keyToUse = key; + category = this.pluralCategory(objectGraph, count); + if (category !== "other") { + pluralFormKey = `${key}.${category}`; + if (this.isLocalized(objectGraph, pluralFormKey)) { + keyToUse = pluralFormKey; + } + } + } + if (!params) { + params = {}; + } + // @@count@@ is the standard, but @@number@@ is frequently used too. + if (params.count === undefined) { + params.count = this.formatNumber(count.toString()); + } + if (params.number === undefined) { + params.number = this.formatNumber(count.toString()); + } + return this.localize(keyToUse !== null && keyToUse !== void 0 ? keyToUse : key, params); + } + // endregion + // region Private Methods + replaceTokens(text, values) { + Object.entries(values).forEach(([key, value]) => { + const subKey = "@@" + key + "@@"; + text = this.replaceSubstring(text, subKey, value); + }); + return text; + } + replaceMarkupTokens(text, values) { + if (text.indexOf("##") <= -1) { + return text; + } + // Resolve token properties. + let markupParams; + if (values) { + // Create a copy to avoid mutating defaults. + markupParams = { ...AmpLocalization.MARKUP_PARAMS }; + Object.entries(values).forEach(([key, value]) => { + markupParams[key] = value; + }); + } + else { + markupParams = AmpLocalization.MARKUP_PARAMS; + } + Object.entries(markupParams).forEach(([key, value]) => { + const token = "##" + key + "##"; + text = text.replace(new RegExp(token, "gi"), value); + }); + // Replace any remaining standard markup tags like <br> etc. + text = text.replace(/##([^##]+)##/gi, "<$1>"); + return text; + } + /** + * Searches "str" for "substr" and replaces each occurrence with "replacement" + * @param str input string + * @param substr the string to search for in the input string + * @param replacement value to use for the replacement + * + * JavaScript String.replace has a misfeature where "$" in the replacement is always interpreted as a meta char, + * i.e. you have to use "$$" in the replacement to get a single "$" in the resulting string + * which lead to <rdar://problem/16848063> tv episode title containing "$&" not displaying correctly + * Using split and join is faster than substituting $$ for $ in the replacement. + */ + replaceSubstring(str, substr, replacement) { + return str.split(substr).join(replacement); + } + formatNumber(value) { + let decimalSeparator = this.locData["_decimalSeparator"]; + if (decimalSeparator === undefined || typeof decimalSeparator !== "string") { + decimalSeparator = "."; + } + let thousandsSeparator = this.locData["_thousandsSeparator"]; + if (thousandsSeparator === undefined || typeof thousandsSeparator !== "string") { + thousandsSeparator = "."; + } + const parts = parseFloat(value).toString().split("."); + const chars = parts[0].split(""); + for (let i = chars.length - 3; i > 0; i -= 3) { + chars.splice(i, 0, thousandsSeparator); + } + parts[0] = chars.join(""); + return parts.join(decimalSeparator); + } + /** + * Check whether the given key is localized or not. + * @param key The key to check. + */ + isLocalized(objectGraph, key) { + const value = this.locData[key]; + if (value === undefined || typeof value !== "string") { + return false; + } + else if (key.indexOf(".") === -1) { + // Simple localization keys such as "OK". + return true; + } + else if (value === key || (value.indexOf("**") === 0 && value.lastIndexOf("**") === value.length - 2)) { + objectGraph.console.error("Unlocalized key in keys dictionary", key); + return false; + } + return true; + } + /** + * Returns localization plural category for given number. + * @param num The number to return plural category for. + * @returns Plural category for specified number or "other" + * if there's no plural category function available for current language. + * + * @see: + * - http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html + * - http://cldr.unicode.org/index/cldr-spec/plural-rules#TOC-Determining-Plural-Categories + * - http://unicode.org/repos/cldr/trunk/specs/ldml/tr35-numbers.html#Language_Plural_Rules + */ + pluralCategory(objectGraph, num) { + const categoryFn = AmpLocalization.pluralCategoryFnByLanguage[this.language]; + if (categoryFn !== undefined) { + return categoryFn(num); + } + else { + objectGraph.console.warn("Missing plural category function for: " + this.language); + return "other"; + } + } +} +/** + * Markup parameters used for replacing markup tokens in text. + */ +AmpLocalization.MARKUP_PARAMS = { nbsp: " ", gt: ">", lt: "<", copy: "\u00a9" }; +// endregion +// regions Plurals +AmpLocalization.pluralCategoryDefault = function (num) { + return "other"; +}; +AmpLocalization.pluralCategoryOne = function (num) { + if (num === 1) { + return "one"; + } + return "other"; +}; +AmpLocalization.pluralCategoryArabic = function (num) { + const n = num >> 0; + if (n !== num) { + // non integer + return "other"; + } + if (n === 0) { + return "zero"; + } + if (n === 1) { + return "one"; + } + if (n === 2) { + return "two"; + } + const m100 = n % 100; + if (m100 >= 11) { + // n mod 100 in 11..99 + return "many"; + } + if (m100 >= 3) { + // n mod 100 in 3..10 + return "few"; + } + return "other"; +}; +AmpLocalization.pluralCategoryFrench = function (num) { + // Do not check for integer, French includes fractional values! + if (num < 2 && num >= 0) { + return "one"; + } + return "other"; +}; +AmpLocalization.pluralCategoryHebrew = function (num) { + const n = num >> 0; + if (n !== num) { + // non integer + return "other"; + } + if (n === 1) { + return "one"; + } + if (n === 2) { + return "two"; + } + const m10 = n % 10; + if (m10 === 0 && n > 10) { + // n mod 10 is 0 and n != 0..10 + return "many"; + } + return "other"; +}; +AmpLocalization.pluralCategoryPolish = function (num) { + const n = num >> 0; + if (n !== num) { + // non integer + return "other"; + } + if (n === 1) { + return "one"; + } + const m10 = n % 10; + if (m10 <= 4 && m10 >= 2) { + const m100 = n % 100; + if (m100 > 14 || m100 < 12) { + // n mod 10 in 2..4 and n mod 100 not in 12..14 + return "few"; + } + } + return "many"; +}; +AmpLocalization.pluralCategoryRomanian = function (num) { + const n = num >> 0; + if (n !== num) { + // non integer + return "few"; + } + if (n === 0) { + return "few"; + } + if (n === 1) { + return "one"; + } + const m100 = num % 100; + if (m100 <= 19 && m100 >= 1) { + // n mod 100 in 1..19 + return "few"; + } + return "other"; +}; +AmpLocalization.pluralCategoryRussian = function (num) { + const n = num >> 0; + if (n !== num) { + // non integer + return "other"; + } + const m10 = n % 10; + if (m10 >= 5 || m10 === 0) { + // n mod 10 is 0 or n mod 10 in 5..9 + return "many"; + } + const m100 = n % 100; + if (m100 <= 14 && m100 >= 11) { + // n mod 100 in 11..14 + return "many"; + } + if (m10 === 1) { + // n mod 10 is 1 and n mod 100 is not 11 + return "one"; + } + // n mod 10 in 2..4 and n mod 100 not in 12..14 + return "few"; +}; +/** + * Mapping language code to plural category function. + */ +AmpLocalization.pluralCategoryFnByLanguage = { + zh: AmpLocalization.pluralCategoryDefault, + id: AmpLocalization.pluralCategoryDefault, + ja: AmpLocalization.pluralCategoryDefault, + ko: AmpLocalization.pluralCategoryDefault, + ms: AmpLocalization.pluralCategoryDefault, + th: AmpLocalization.pluralCategoryDefault, + vi: AmpLocalization.pluralCategoryDefault, + en: AmpLocalization.pluralCategoryOne, + ca: AmpLocalization.pluralCategoryOne, + da: AmpLocalization.pluralCategoryOne, + nl: AmpLocalization.pluralCategoryOne, + de: AmpLocalization.pluralCategoryOne, + el: AmpLocalization.pluralCategoryOne, + fi: AmpLocalization.pluralCategoryOne, + hu: AmpLocalization.pluralCategoryOne, + it: AmpLocalization.pluralCategoryOne, + nb: AmpLocalization.pluralCategoryOne, + no: AmpLocalization.pluralCategoryOne, + pt: AmpLocalization.pluralCategoryOne, + es: AmpLocalization.pluralCategoryOne, + sv: AmpLocalization.pluralCategoryOne, + tr: AmpLocalization.pluralCategoryOne, + ar: AmpLocalization.pluralCategoryArabic, + fr: AmpLocalization.pluralCategoryFrench, + iw: AmpLocalization.pluralCategoryHebrew, + pl: AmpLocalization.pluralCategoryPolish, + ro: AmpLocalization.pluralCategoryRomanian, + ru: AmpLocalization.pluralCategoryRussian, // Russian +}; +//# sourceMappingURL=amp-localization.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/active-intent.js b/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/active-intent.js new file mode 100644 index 0000000..5270dd4 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/active-intent.js @@ -0,0 +1,121 @@ +import { isSome } from "@jet/environment/types/optional"; +import { makeMetatype } from "@jet/environment/util/metatype"; +import { unreachable } from "../util/errors"; +export const ActiveIntentMetaType = makeMetatype("app-store:active-intent"); +/** + * Executes {@linkcode callback} with an {@linkcode AppStoreObjectGraph} that has been prepared with an + * {@linkcode ActiveIntent} dependency + * + * This will allow code running within {@linkcode callback} to access meta-data about the active + * {@linkcode Intent} without needing that information to be passed through every layer of the code + */ +export function withActiveIntent(objectGraph, intent, callback) { + const objectGraphWithActiveIntent = objectGraph.addingActiveIntent({ + previewPlatform: intent.platform, + }); + return callback(objectGraphWithActiveIntent); +} +/** + * Ephemeral storage of `Intent`-specific details that need to be accessible + * throughout the process of building that `Intent`'s result + */ +export class ActiveIntent { + constructor(implementation) { + this.implementation = implementation; + this.inferredPreviewPlatform = undefined; + } + /** + * Explicitly set a {@linkcode PreviewPlatform} for the active intent + * + * This might be a value derrived from an API response, in cases where the original `Intent` + * was not specific about which platform to display + */ + setInferredPreviewPlatform(platform) { + this.inferredPreviewPlatform = platform; + } + /** + * The {@linkcode PreviewPlatform} value of the current {@linkcode Intent} + */ + get previewPlatform() { + var _a; + return (_a = this.inferredPreviewPlatform) !== null && _a !== void 0 ? _a : this.implementation.previewPlatform; + } + /** + * The {@linkcode Platform} equivalent of the active {@linkcode PreviewPlatform} + * + * This translates the user-facing {@linkcode PreviewPlatform} into the "internal" + * Media API {@linkcode Platform} + */ + get platform() { + if (isSome(this.previewPlatform)) { + switch (this.previewPlatform) { + case "ipad": + case "iphone": + case "mac": + case "watch": + return this.previewPlatform; + case "tv": + return "appletv"; + case "vision": + return "realityDevice"; + default: + unreachable(this.previewPlatform); + } + } + return undefined; + } + /** + * The {@linkcode AttributePlatform} equivalent of the active {@linkcode PreviewPlatform} + * + * This translates the user-facing {@linkcode PreviewPlatform} into the "internal" + * {@linkcode AttributePlatform} + */ + get attributePlatform() { + if (isSome(this.previewPlatform)) { + switch (this.previewPlatform) { + case "iphone": + case "ipad": + return "ios"; + case "mac": + return "osx"; + case "tv": + return "appletvos"; + case "vision": + return "xros"; + case "watch": + return "watch"; + default: + unreachable(this.previewPlatform); + } + } + return undefined; + } + /** + * The {@linkcode AppPlatform} equivalent of the active {@linkcode PreviewPlatform} + * + * This translates the user-facing {@linkcode PreviewPlatform} into the "internal" + * {@linkcode AppPlatform} + */ + get appPlatform() { + if (isSome(this.previewPlatform)) { + switch (this.previewPlatform) { + case "ipad": + return "pad"; + case "iphone": + return "phone"; + case "mac": + return "mac"; + case "tv": + return "tv"; + case "vision": + return "vision"; + case "watch": + return "watch"; + default: + unreachable(this.previewPlatform); + } + } + return undefined; + } +} +//# sourceMappingURL=active-intent.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/locale/locale-from-bag.js b/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/locale/locale-from-bag.js new file mode 100644 index 0000000..7790008 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/locale/locale-from-bag.js @@ -0,0 +1,41 @@ +export class LocaleFromBag { + constructor(objectGraph) { + this.objectGraph = objectGraph; + } + /** + * The current {@link NormalizedStorefront | storefront} for the client + * + * This reads directly from the `Bag`, as that is the source of truth + * for locale information in the "native" clients + */ + get activeStorefront() { + // The type-cast here reflects the implicit assumption that any values + // belonging to the `Bag` have already been normalized + return this.objectGraph.bag.mediaCountryCode; + } + /** + * The current {@link NormalizedLanguage | language} for the client + * + * This reads directly from the `Bag`, as that is the source of truth + * for locale information in the "native" clients + */ + get activeLanguage() { + // The type-cast here reflects the implicit assumption that any values + // belonging to the `Bag` have already been normalized + return this.objectGraph.bag.language; + } + setActiveLocale(_locale) { + // Intentional no-op; "native" clients that use the `Bag` as the source + // of "locale" information do not allow for mutation of the "locale" + } + normalize(_unnormalizedLocale) { + return { + storefront: this.activeStorefront, + language: this.activeLanguage, + }; + } + deriveLocaleForUrl(locale) { + return locale; + } +} +//# sourceMappingURL=locale-from-bag.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/locale/locale.js b/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/locale/locale.js new file mode 100644 index 0000000..d00bacc --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/locale/locale.js @@ -0,0 +1,3 @@ +import { makeMetatype } from "@jet/environment/util/metatype"; +export const LocaleMetaType = makeMetatype("app-store:locale"); +//# sourceMappingURL=locale.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/seo.js b/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/seo.js new file mode 100644 index 0000000..9def945 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/dependencies/seo.js @@ -0,0 +1,3 @@ +import { makeMetatype } from "@jet/environment/util/metatype"; +export const SEOMetaType = makeMetatype("app-store:seo"); +//# sourceMappingURL=seo.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/app-store-experiments.js b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/app-store-experiments.js new file mode 100644 index 0000000..e073481 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/app-store-experiments.js @@ -0,0 +1,7 @@ +import { ExperimentCache } from "./experiment-cache"; +export function currentTreatmentIdForArea(objectGraph, experimentAreaId) { + var _a; + const experimentCache = objectGraph.optional(ExperimentCache.metatype); + return (_a = experimentCache === null || experimentCache === void 0 ? void 0 : experimentCache.currentTreatmentForExperiment(experimentAreaId)) === null || _a === void 0 ? void 0 : _a.identifier; +} +//# sourceMappingURL=app-store-experiments.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/experiment-area-id.js b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/experiment-area-id.js new file mode 100644 index 0000000..435c196 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/experiment-area-id.js @@ -0,0 +1,10 @@ +export var ExperimentAreaId; +(function (ExperimentAreaId) { + ExperimentAreaId["ArcadeDownloadPackOnboarding"] = "Tf5Kjqz"; + ExperimentAreaId["CondensedTodayAds"] = "tBc9hUt"; + ExperimentAreaId["ProductPagePreloading"] = "m0henFo"; + ExperimentAreaId["ProductPageVariants"] = "fNPb5Km"; + ExperimentAreaId["ProductPageYMALRowCount"] = "isj11bm"; + ExperimentAreaId["SearchLandingPage"] = "WqjkRLH"; +})(ExperimentAreaId || (ExperimentAreaId = {})); +//# sourceMappingURL=experiment-area-id.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/experiment-cache.js b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/experiment-cache.js new file mode 100644 index 0000000..c0384ea --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/experiment-cache.js @@ -0,0 +1,63 @@ +import { makeMetatype } from "@jet/environment/util/metatype"; +import { ExperimentAreaId } from "./experiment-area-id"; +export class ExperimentCache { + constructor() { + this.cachedTreatments = {}; + this.cachedRawTreatments = {}; + } + async loadTreatments(objectGraph) { + const experimentAreas = this.experimentAreasForPlatform(objectGraph); + if (experimentAreas.length > 0) { + try { + this.cachedRawTreatments = await objectGraph.treatmentStore.treatmentsForAreas(experimentAreas); + for (const [experimentAreaId, treatment] of Object.entries(this.cachedRawTreatments)) { + /// AMS Adds some debug metadata after the treatment identifier in internal builds we do not want this + /// for app store usage + const rawIdentifier = treatment.identifier; + this.cachedTreatments[experimentAreaId] = { + ...treatment, + identifier: rawIdentifier.split(":")[0], + }; + } + } + catch (error) { + objectGraph.console.error("Failed to load treatments", error); + } + } + } + currentTreatmentForExperiment(experimentAreaId) { + return this.cachedTreatments[experimentAreaId]; + } + createAb2Data() { + const ab2Data = []; + for (const [experimentAreaId, treatment] of Object.entries(this.cachedRawTreatments)) { + ab2Data.push({ + areaId: experimentAreaId, + bucket: -2, + treatmentId: treatment.identifier, + }); + } + return ab2Data; + } + experimentAreasForPlatform(objectGraph) { + const experimentAreas = []; + switch (objectGraph.client.deviceType) { + case "phone": + case "pad": + experimentAreas.push(...[ + ExperimentAreaId.ArcadeDownloadPackOnboarding, + ExperimentAreaId.CondensedTodayAds, + ExperimentAreaId.ProductPagePreloading, + ExperimentAreaId.ProductPageVariants, + ExperimentAreaId.ProductPageYMALRowCount, + ExperimentAreaId.SearchLandingPage, + ]); + break; + default: + break; + } + return experimentAreas; + } +} +ExperimentCache.metatype = makeMetatype("app-store:experimentCache"); +//# sourceMappingURL=experiment-cache.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/product-page-experiments.js b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/product-page-experiments.js new file mode 100644 index 0000000..7af0b43 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/product-page-experiments.js @@ -0,0 +1,21 @@ +import * as appStoreExperiments from "./app-store-experiments"; +import { ExperimentAreaId } from "./experiment-area-id"; +export function shouldSkipProductPagePreload(objectGraph) { + const treatmentId = appStoreExperiments.currentTreatmentIdForArea(objectGraph, ExperimentAreaId.ProductPagePreloading); + return treatmentId === "3NepyQj01" /* ProductPagePreloadingExperimentTypes.SkipPreload */; +} +// --- Product Page Variants -- +/// Returns the treatment group id based on xp_ab value as string. +export function productVariantTreatmentId(objectGraph) { + return appStoreExperiments.currentTreatmentIdForArea(objectGraph, ExperimentAreaId.ProductPageVariants); +} +/** + * The number of rows that the YMAL shelf should use. + * @param objectGraph The object graph. + * @returns A number representing the number of rows in the YMAL shelf. + */ +export function ymalShelfNumberOfRows(objectGraph) { + const treatmentId = appStoreExperiments.currentTreatmentIdForArea(objectGraph, ExperimentAreaId.ProductPageYMALRowCount); + return treatmentId === "2S6U3Dq01" /* ProductPageYMALShelfRowNumberExperimentTypes.ThreeRow */ ? 3 : 2; +} +//# sourceMappingURL=product-page-experiments.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/search-results-experiments.js b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/search-results-experiments.js new file mode 100644 index 0000000..54654ee --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/search-results-experiments.js @@ -0,0 +1,10 @@ +import * as serverData from "../../foundation/json-parsing/server-data"; +/** + * Returns the current treatment for editorial collections based on the meta blob. + * @param meta Meta blob in initial response. + */ +export function currentEditorialCollectionTreatment(objectGraph, meta) { + const showGridCard = serverData.asBooleanOrFalse(meta, "experiments.showGridCard"); + return showGridCard ? 0 /* EditorialCollectionExperimentType.Card */ : 1 /* EditorialCollectionExperimentType.Swoosh */; +} +//# sourceMappingURL=search-results-experiments.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/today-ad-experiments.js b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/today-ad-experiments.js new file mode 100644 index 0000000..52468f9 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/experimentation/today-ad-experiments.js @@ -0,0 +1,15 @@ +import * as appStoreExperiments from "./app-store-experiments"; +import { ExperimentAreaId } from "./experiment-area-id"; +/** + * Check whether the condensed treatment should be applied to the Today ad. + * @param objectGraph The object graph. + * @returns A boolean indicating if the treatment should be applied. + */ +export function shouldTodayAdBeCondensed(objectGraph) { + if (!objectGraph.client.isPhone) { + return false; + } + const treatmentId = appStoreExperiments.currentTreatmentIdForArea(objectGraph, ExperimentAreaId.CondensedTodayAds); + return treatmentId === "5pdfhju01" /* TodayAdCondensedDisplayExperimentTypes.Condensed */; +} +//# sourceMappingURL=today-ad-experiments.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/json-parsing/derived-data.js b/node_modules/@jet-app/app-store/tmp/src/foundation/json-parsing/derived-data.js new file mode 100644 index 0000000..fdf1f4e --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/json-parsing/derived-data.js @@ -0,0 +1,37 @@ +import * as validation from "@jet/environment/json/validation"; +import * as serverData from "./server-data"; +const DERIVED_CACHE_KEY = "_jet-internal:derived-data"; +export function value(data, key, generator) { + if (!data) { + return null; + } + return validation.context(key, () => { + let computedDataStore = data[DERIVED_CACHE_KEY]; + let returnValue = null; + if (!computedDataStore) { + computedDataStore = {}; + data[DERIVED_CACHE_KEY] = computedDataStore; + returnValue = generateValue(computedDataStore, key, generator); + } + else { + returnValue = serverData.traverse(computedDataStore, key); + if (!returnValue) { + returnValue = generateValue(computedDataStore, key, generator); + } + } + return returnValue; + }); +} +/** + * Computes an unknown value and saves it back into computedDataStore + * @param {JSONData} computedDataStore The dictionary in which to store the data + * @param {string} key The key to store it with + * @param {() => T} generator A function that will generate the value + * @returns {T} The value that was generated + */ +function generateValue(computedDataStore, key, generator) { + const generatedValue = generator(); + computedDataStore[key] = generatedValue; + return generatedValue; +} +//# sourceMappingURL=derived-data.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/json-parsing/server-data.js b/node_modules/@jet-app/app-store/tmp/src/foundation/json-parsing/server-data.js new file mode 100644 index 0000000..2ff6394 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/json-parsing/server-data.js @@ -0,0 +1,464 @@ +// +// server-data.ts +// AppStoreKit +// +// Created by Kevin MacWhinnie on 8/17/16. +// Copyright (c) 2016 Apple Inc. All rights reserved. +// +import * as validation from "@jet/environment/json/validation"; +import { isNothing } from "@jet/environment/types/optional"; +/** + * Returns the string representation of a given object path. + * @param path The object path to coerce to a string. + * @returns A string representation of `path`. + */ +export function objectPathToString(path) { + if (isNull(path)) { + return null; + } + else if (Array.isArray(path)) { + return path.join("."); + } + else { + return path; + } +} +const PARSED_PATH_CACHE = {}; +/** + * Traverse a nested JSON object structure, short-circuiting + * when finding `undefined` or `null` values. Usage: + * + * const object = {x: {y: {z: 42}}}; + * const meaningOfLife = serverData.traverse(object, 'x.y.z'); + * + * @param object The JSON object to traverse. + * @param path The path to search. If falsy, `object` will be returned without being traversed. + * @param defaultValue The object to return if the path search fails. + * @return The value at `path` if found; default value otherwise. + */ +export function traverse(object, path, defaultValue) { + if (object === undefined || object === null) { + return defaultValue; + } + if (!path) { + return object; + } + let components; + if (typeof path === "string") { + components = PARSED_PATH_CACHE[path]; + if (!components) { + // Fast Path: If the path contains only a single component, we can skip + // all of the work below here and speed up storefronts that + // don't have JIT compilation enabled. + if (!path.includes(".")) { + const value = object[path]; + if (value !== undefined && value !== null) { + return value; + } + else { + return defaultValue; + } + } + components = path.split("."); + PARSED_PATH_CACHE[path] = components; + } + } + else { + components = path; + } + let current = object; + for (const component of components) { + current = current[component]; + if (current === undefined || current === null) { + return defaultValue; + } + } + return current; +} +// endregion +// region Nullability +/** + * Returns a bool indicating whether or not a given object null or undefined. + * @param object The object to test. + * @return true if the object is null or undefined; false otherwise. + */ +export function isNull(object) { + return object === null || object === undefined; +} +/** + * Returns a bool indicating whether or not a given object is null or empty. + * @param object The object to test + * @return true if object is null or empty; false otherwise. + */ +export function isNullOrEmpty(object) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return isNull(object) || Object.keys(object).length === 0; +} +/** + * Returns a bool indicating whether or not a given object is non-null. + * @param object The object to test. + * @return true if the object is not null or undefined; false otherwise. + */ +export function isDefinedNonNull(object) { + return typeof object !== "undefined" && object !== null; +} +/** + * Returns a bool indicating whether or not a given object is non-null or empty. + * @param object The object to test. + * @return true if the object is not null or undefined and not empty; false otherwise. + */ +export function isDefinedNonNullNonEmpty(object) { + if (isNothing(object)) { + return false; + } + if (typeof object === "string") { + return object.length > 0; + } + else if (Array.isArray(object)) { + return object.length > 0; + } + else { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return Object.keys(object).length !== 0; + } +} +/** + * Returns a bool indicating whether or not a given object is non-null or empty. + * @param object The object to test. + * @return true if the object is not null or undefined and not empty; false otherwise. + */ +export function isSetDefinedNonNullNonEmpty(object) { + return isDefinedNonNull(object) && object.size > 0; +} +/** + * Checks if the passed string or number is a number + * + * @param value The value to check + * @return True if the value is an number, false if not + */ +export function isNumber(value) { + if (isNull(value)) { + return false; + } + let valueToCheck; + if (typeof value === "string") { + valueToCheck = parseInt(value); + } + else { + valueToCheck = value; + } + return !Number.isNaN(valueToCheck); +} +/** + * Checks if the value is a string + * + * @param value The value to check + * @return True if the value is a string, false if not + */ +export function isString(value) { + if (isNothing(value)) { + return false; + } + return typeof value === "string"; +} +/** + * Returns a bool indicating whether or not a given object is defined but empty. + * @param object The object to test. + * @return true if the object is not null and empty; false otherwise. + */ +export function isArrayDefinedNonNullAndEmpty(object) { + return isDefinedNonNull(object) && object.length === 0; +} +// endregion +// region Defaulting Casts +/** + * Check that a given object is an array, substituting an empty array if not. + * @param object The object to coerce. + * @param path The path to traverse on `object` to find an array. + * Omit this parameter if `object` is itself an array. + * @returns An untyped array. + */ +export function asArrayOrEmpty(object, path) { + var _a; + return (_a = asArray(object, path, [])) !== null && _a !== void 0 ? _a : []; +} +/** + * Check that a given object is a boolean, substituting the value `false` if not. + * @param object The object to coerce. + * @param path The path to traverse on `object` to find a boolean. + * Omit this parameter if `object` is itself a boolean. + * @returns A boolean from `object`, or defaults to `false`. + */ +export function asBooleanOrFalse(object, path) { + return asBooleanWithDefault(object, false, path); +} +/** + * Check that a given object is a boolean, substituting the value `false` if not. + * @param object The object to coerce. + * @param path The path to traverse on `object` to find a boolean. + * Omit this parameter if `object` is itself a boolean. + * @returns A boolean from `object`, or the provided default. + */ +export function asBooleanWithDefault(object, defaultValue, path) { + const target = traverse(object, path, null); + if (typeof target === "boolean") { + return target; + } + else { + if (!isNull(target)) { + validation.context("asBooleanWithDefault", () => { + validation.unexpectedType("defaultValue", "boolean", target, objectPathToString(path)); + }); + } + return defaultValue; + } +} +/** + * Safely coerce an object into a string. + * @param object The object to coerce. + * @param path The path to traverse on `object` to find a string. + * Omit this parameter if `object` is itself a string. + * @param policy The validation policy to use when resolving this value + * @returns A string from `object`, or `null` if `object` is null. + */ +export function asString(object, path, policy = "coercible") { + const target = traverse(object, path, null); + if (isNull(target)) { + return target; + } + else if (typeof target === "string") { + return target; + } + else { + // We don't consider arbitrary objects as convertable to strings even through they will result in some value + const coercedValue = typeof target === "object" ? null : String(target); + switch (policy) { + case "strict": { + validation.context("asString", () => { + validation.unexpectedType("coercedValue", "string", target, objectPathToString(path)); + }); + break; + } + case "coercible": { + if (isNull(coercedValue)) { + validation.context("asString", () => { + validation.unexpectedType("coercedValue", "string", target, objectPathToString(path)); + }); + } + break; + } + case "none": + default: { + break; + } + } + return coercedValue; + } +} +/** + * Safely coerce an object into a number. + * @param object The object to coerce. + * @param path The path to traverse on `object` to find a number. + * Omit this parameter if `object` is itself a number. + * @param policy The validation policy to use when resolving this value + * @returns A number from `object`, or `null` if `object` is null. + */ +export function asNumber(object, path, policy = "coercible") { + const target = traverse(object, path, null); + if (isNull(target) || typeof target === "number") { + return target; + } + else { + const coercedValue = Number(target); + switch (policy) { + case "strict": { + validation.context("asNumber", () => { + validation.unexpectedType("coercedValue", "number", target, objectPathToString(path)); + }); + break; + } + case "coercible": { + if (isNaN(coercedValue)) { + validation.context("asNumber", () => { + validation.unexpectedType("coercedValue", "number", target, objectPathToString(path)); + }); + return null; + } + break; + } + case "none": + default: { + break; + } + } + return coercedValue; + } +} +/** + * Safely coerce an object into a dictionary. + * @param object The object to coerce. + * @param path The path to traverse on `object` to find the dictionary. + * Omit this parameter if `object` is itself a dictionary. + * @param defaultValue The object to return if the path search fails. + * @returns A sub-dictionary from `object`, or `null` if `object` is null. + */ +export function asDictionary(object, path, defaultValue) { + const target = traverse(object, path, null); + if (target instanceof Object && !Array.isArray(target)) { + // Note: It's too expensive to actually validate this is a dictionary of { string : Type } at run time + return target; + } + else { + if (!isNull(target)) { + validation.context("asDictionary", () => { + validation.unexpectedType("defaultValue", "object", target, objectPathToString(path)); + }); + } + if (isDefinedNonNull(defaultValue)) { + return defaultValue; + } + return null; + } +} +/** + * Coerce an object into an array + * @param object The object to coerce. + * @param path The path to traverse on `object` to find an array. + * Omit this parameter if `object` is itself an array. + * @returns An untyped array. + */ +export function asArray(object, path, defaultValue) { + const target = traverse(object, path, null); + if (Array.isArray(target)) { + // Note: This is kind of a nasty cast, but I don't think we want to validate that everything is of type T + return target; + } + else { + if (!isNull(target)) { + validation.context("asArray", () => { + validation.unexpectedType("defaultValue", "array", target, objectPathToString(path)); + }); + } + if (isDefinedNonNull(defaultValue)) { + return defaultValue; + } + return null; + } +} +/** + * Safely coerce an object into a given interface. + * @param object The object to coerce. + * @param path The path to traverse on `object` to find a string. + * Omit this parameter if `object` is itself a string. + * @param defaultValue The object to return if the path search fails. + * @returns A sub-dictionary from `object`, or `null` if `object` is null. + */ +export function asInterface(object, path, defaultValue) { + return asDictionary(object, path, defaultValue); +} +/** + * Coerce an object into a boolean. + * @param object The object to coerce. + * @param path The path to traverse on `object` to find a boolean. + * Omit this parameter if `object` is itself a boolean. + * @param policy The validation policy to use when resolving this value + * @returns A boolean from `object`, or `null` if `object` is null. + * @note This is distinct from `asBooleanOrFalse` in that it doesn't default to false, + * and it tries to convert string boolean values into actual boolean types + */ +export function asBoolean(object, path, policy = "coercible") { + const target = traverse(object, path, null); + // Value was null + if (isNull(target)) { + return null; + } + // Value was boolean. + if (typeof target === "boolean") { + return target; + } + // Value was string. + if (typeof target === "string") { + if (target === "true") { + return true; + } + else if (target === "false") { + return false; + } + } + // Else coerce. + const coercedValue = Boolean(target); + switch (policy) { + case "strict": { + validation.context("asBoolean", () => { + validation.unexpectedType("coercedValue", "number", target, objectPathToString(path)); + }); + break; + } + case "coercible": { + if (isNull(coercedValue)) { + validation.context("asBoolean", () => { + validation.unexpectedType("coercedValue", "number", target, objectPathToString(path)); + }); + return null; + } + break; + } + case "none": + default: { + break; + } + } + return coercedValue; +} +/** + * Attempts to coerce the passed value to a JSONValue + * + * Note: due to performance concerns this does not perform a deep inspection of Objects or Arrays. + * + * @param value The value to coerce + * @return A JSONValue or null if value is not a valid JSONValue type + */ +export function asJSONValue(value) { + if (value === null || value === undefined) { + return null; + } + switch (typeof value) { + case "string": + case "number": + case "boolean": + return value; + case "object": + // Note: It's too expensive to actually validate this is an array of JSONValues at run time + if (Array.isArray(value)) { + return value; + } + // Note: It's too expensive to actually validate this is a dictionary of { string : JSONValue } at run time + return value; + default: + validation.context("asJSONValue", () => { + validation.unexpectedType("defaultValue", "JSONValue", typeof value); + }); + return null; + } +} +/** + * Attempts to coerce the passed value to JSONData + * + * @param value The value to coerce + * @return A JSONData or null if the value is not a valid JSONData object + */ +export function asJSONData(value) { + if (value === null || value === undefined) { + return null; + } + if (value instanceof Object && !Array.isArray(value)) { + // Note: It's too expensive to actually validate this is a dictionary of { string : Type } at run time + return value; + } + validation.context("asJSONValue", () => { + validation.unexpectedType("defaultValue", "object", typeof value); + }); + return null; +} +// endregion +//# sourceMappingURL=server-data.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/media/associations.js b/node_modules/@jet-app/app-store/tmp/src/foundation/media/associations.js new file mode 100644 index 0000000..7e2b088 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/media/associations.js @@ -0,0 +1,17 @@ +import * as serverData from "../json-parsing/server-data"; +/** + * @param data The media api data to find teh card in + * @returns The editorial-card data for this media api item, this will return the first associated card + */ +export function editorialCardsFromData(data) { + const editorialCards = serverData.asArrayOrEmpty(data, "meta.associations.editorial-cards.data"); + return editorialCards; +} +/** + * @param data The media api data to find teh card in + * @returns The editorial-card data for this media api item, this will return the first associated card + */ +export function editorialCardFromData(data) { + return serverData.asInterface(editorialCardsFromData(data)[0]); +} +//# sourceMappingURL=associations.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/media/attributes.js b/node_modules/@jet-app/app-store/tmp/src/foundation/media/attributes.js new file mode 100644 index 0000000..992a56e --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/media/attributes.js @@ -0,0 +1,149 @@ +import { isNothing } from "@jet/environment/types/optional"; +import * as serverData from "../json-parsing/server-data"; +// region Generic Attribute retrieval +// region Attribute retrieval +/** + * Retrieve the specified attribute from the data, coercing it to a JSONData dictionary + * + * @param data The data from which to retrieve the attribute. + * @param attributePath The path of the attribute. + * @param defaultValue The object to return if the path search fails. + * @returns The dictionary of data + */ +export function attributeAsDictionary(data, attributePath, defaultValue) { + if (isNothing(data)) { + return null; + } + return serverData.asDictionary(data.attributes, attributePath, defaultValue); +} +/** + * Retrieve the specified attribute from the data, coercing it to an Interface + * + * @param data The data from which to retrieve the attribute. + * @param attributePath The path of the attribute. + * @param defaultValue The object to return if the path search fails. + * @returns The dictionary of data as an interface + */ +export function attributeAsInterface(data, attributePath, defaultValue) { + return attributeAsDictionary(data, attributePath, defaultValue); +} +/** + * Retrieve the specified attribute from the data as an array, coercing to a JSONValue array + * + * @param data The data from which to retrieve the attribute. + * @param attributePath The path of the attribute. + * @returns {any[]} The attribute value as an array. + */ +export function attributeAsArray(data, attributePath) { + if (serverData.isNull(data)) { + return []; + } + return serverData.asArray(data.attributes, attributePath); +} +/** + * Retrieve the specified attribute from the data as an array, coercing to an empty array if the object is not an array. + * + * @param data The data from which to retrieve the attribute. + * @param attributePath The path of the attribute. + * @returns {any[]} The attribute value as an array. + */ +export function attributeAsArrayOrEmpty(data, attributePath) { + var _a; + return (_a = attributeAsArray(data, attributePath)) !== null && _a !== void 0 ? _a : []; +} +/** + * Retrieve the specified attribute from the data as a string. + * + * @param data The data from which to retrieve the attribute. + * @param attributePath The object path for the attribute. + * @param policy The validation policy to use when resolving this value. + * @returns {string} The attribute value as a string. + */ +export function attributeAsString(data, attributePath, policy = "coercible") { + if (serverData.isNull(data)) { + return null; + } + return serverData.asString(data.attributes, attributePath, policy); +} +/** + * Retrieve the specified attribute from the data as a boolean. + * + * @param data The data from which to retrieve the attribute. + * @param attributePath The path of the attribute. + * @param policy The validation policy to use when resolving this value. + * @returns {boolean} The attribute value as a boolean. + */ +export function attributeAsBoolean(data, attributePath, policy = "coercible") { + if (serverData.isNull(data)) { + return null; + } + return serverData.asBoolean(data.attributes, attributePath, policy); +} +/** + * Retrieve the specified attribute from the data as a boolean, which will be `false` if the attribute does not exist. + * + * @param data The data from which to retrieve the attribute. + * @param attributePath The path of the attribute. + * @returns {boolean} The attribute value as a boolean, coercing to `false` if the value is not present.. + */ +export function attributeAsBooleanOrFalse(data, attributePath) { + if (serverData.isNull(data)) { + return false; + } + return serverData.asBooleanOrFalse(data.attributes, attributePath); +} +/** + * Retrieve the specified attribute from the data as a number. + * + * @param data The data from which to retrieve the attribute. + * @param attributePath The path of the attribute. + * @param policy The validation policy to use when resolving this value. + * @returns {boolean} The attribute value as a number. + */ +export function attributeAsNumber(data, attributePath, policy = "coercible") { + if (serverData.isNull(data)) { + return null; + } + return serverData.asNumber(data.attributes, attributePath, policy); +} +export function hasAttributes(data) { + return !serverData.isNull(serverData.asDictionary(data, "attributes")); +} +/** + * The canonical way to detect if an item from Media API is hydrated or not. + * + * @param data The data from which to retrieve the attributes. + */ +export function isNotHydrated(data) { + return !hasAttributes(data); +} +// region Custom Attributes +/** + * Performs conversion for a custom variant of given attribute, if any are available. + * @param attribute Attribute to get custom attribute key for, if any. + */ +export function attributeKeyAsCustomAttributeKey(attribute) { + return customAttributeMapping[attribute]; +} +/** + * Whether or not given custom attributes key allows fallback to default page with AB testing treatment within a nondefault page. + * This is to allow AB testing to affect only icons within custom product pages. + */ +export function attributeAllowsNonDefaultTreatmentInNonDefaultPage(customAttribute) { + return customAttribute === "customArtwork" || customAttribute === "customIconArtwork"; // Only the icon artwork. +} +/** + * Defines mapping of attribute to custom attribute. + */ +const customAttributeMapping = { + artwork: "customArtwork", + iconArtwork: "customIconArtwork", + screenshotsByType: "customScreenshotsByType", + promotionalText: "customPromotionalText", + videoPreviewsByType: "customVideoPreviewsByType", + customScreenshotsByTypeForAd: "customScreenshotsByTypeForAd", + customVideoPreviewsByTypeForAd: "customVideoPreviewsByTypeForAd", + customDeepLink: "customDeepLink", +}; +// endregion +//# sourceMappingURL=attributes.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/media/data-fetching.js b/node_modules/@jet-app/app-store/tmp/src/foundation/media/data-fetching.js new file mode 100644 index 0000000..445f42f --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/media/data-fetching.js @@ -0,0 +1,631 @@ +import { isNothing, isSome } from "@jet/environment/types/optional"; +import * as serverData from "../json-parsing/server-data"; +import * as client from "../wrappers/client"; +export function allPlatforms(objectGraph, platformsToExclude) { + const platforms = new Set(); + platforms.add("iphone"); + platforms.add("ipad"); + platforms.add("appletv"); + platforms.add("mac"); + platforms.add("watch"); + if (objectGraph.client.isVision || objectGraph.bag.enableVisionPlatform) { + platforms.add("realityDevice"); + } + if (isSome(platformsToExclude)) { + for (const platform of platformsToExclude) { + platforms.delete(platform); + } + } + return Array.from(platforms); +} +export function defaultPlatformForClient(objectGraph) { + if (objectGraph.client.isCompanionVisionApp) { + // The Vision companion app always prefers visionOS assets + return "realityDevice"; + } + switch (objectGraph.client.deviceType) { + case "phone": + return "iphone"; + case "pad": + return "ipad"; + case "tv": + return "appletv"; + case "mac": + return "mac"; + case "watch": + return "watch"; + case "vision": + return "realityDevice"; + case "web": + return "web"; + default: + return null; + } +} +/** + * Returns the layout size controlling the number of rows to display. + * @param {AppStoreObjectGraph} objectGraph Object graph to get the client device type. + * @returns {number} Layout size. + */ +export function defaultLayoutSize(objectGraph) { + return objectGraph.client.isPhone ? 2 : 1; +} +/** + * Returns the sparse count controlling the number of shelves to hydrate. + * @param {AppStoreObjectGraph} objectGraph Object graph to get the client device type. + * @returns {number} Sparse count. + */ +export function defaultSparseCountForClient(objectGraph) { + switch (objectGraph.client.deviceType) { + case "phone": + return 4; + case "pad": + return 5; + case "tv": + return 6; + case "mac": + return 5; + case "watch": + return 10; + default: + return null; + } +} +/** + * Returns the sparse limit controlling the number of items to hydrate per shelve. + * @param {AppStoreObjectGraph} objectGraph Object graph to get the client device type. + * @returns {number} Sparse limit. + */ +export function defaultSparseLimitForClient(objectGraph) { + switch (objectGraph.client.deviceType) { + case "phone": + return 9; + case "pad": + return 12; + case "tv": + return 15; + case "mac": + return 15; + case "watch": + return 3; + case "web": + return 12; + default: + return null; + } +} +/** + * Get the list of all platforms excluding the current platform + * @returns {Platform[]} + */ +export function defaultAdditionalPlatformsForClient(objectGraph) { + switch (objectGraph.host.clientIdentifier) { + case "com.apple.TVAppStore.AppStoreTopShelfExtension": + case "com.apple.Arcade.ArcadeTopShelfExtension": + case "com.apple.AppStore.Widgets": + // Skip additional platforms for top shelf extension due to memory constraint. + return []; + default: { + const currentPlatform = defaultPlatformForClient(objectGraph); + return allPlatforms(objectGraph, isSome(currentPlatform) ? new Set([currentPlatform]) : undefined); + } + } +} +/** + * Get the product page reviews limit for a client. + * @returns {number} The limit to use. + */ +export function defaultProductPageReviewsLimitForClient(objectGraph) { + switch (objectGraph.client.deviceType) { + case "phone": + return 6; + case "pad": + return 10; + case "mac": + return 12; + case "vision": + return 10; + default: + return 8; + } +} +/// Returns the context param to use for a given grouping request. +/// This is leveraged for switching grouping tab root in specific configurations. +export function defaultGroupingContextForClient(objectGraph) { + let context = null; + if (objectGraph.host.clientIdentifier === client.messagesIdentifier) { + // Messages Grouping (iOS) + context = "messages"; + } + else if (objectGraph.host.clientIdentifier === client.watchIdentifier) { + // Bridge App Store (iOS) + context = "watch"; + } + else if (objectGraph.client.isWatch && objectGraph.client.isTinkerWatch) { + // Tinker App Store (watchOS) + context = "tinker"; + } + return context; +} +// Nothing on the App Store is rated 1000+, so a value this high essentially +// indicates that content restrictions are disabled. +export const ageRestrictionsDisabledThreshold = 1000; +export class Request { + constructor(objectGraph, param, enableMixedCatalog, supplementaryMetadataAssociations) { + var _a; + /// The resource types used in a mixed contents call + this.contentsResourceTypes = new Set(); + /// The ID(s) associated with the resource type + this.ids = new Set(); + /// IDs associated with specific resource types, used for mixed catalog requests + this.idsByResourceType = new Map(); + /// The original ordering of the ids in this reqeust if there is a mixed catalog request + this.originalOrdering = []; + this.relationshipIncludes = new Set(); + // Contents of `extend` param + this.attributeIncludes = new Set(); + this.platform = null; + /// The paths to additional metadata that need to be fetched for mixed media requests + this.supplementaryMetadataAssociations = []; + this.additionalPlatforms = new Set(); + this.additionalQuery = {}; + this.relationshipLimits = {}; + this.searchTerm = null; + this.searchTypes = []; + /// Whether we are searching watch or messages store. + this.context = null; + /// Whether or not to use custom extend attributes, instead of using `attributeIncludes` as-is. + this.useCustomAttributes = false; + /// An optional country code override for constructing the URL. Used in very specific regulatory scenarios where the bag country code cannot be relied upon. + this.countryCodeOverride = undefined; + this.objectGraph = objectGraph; + this.platform = defaultPlatformForClient(objectGraph); + this.isMixedMediaRequest = enableMixedCatalog !== null && enableMixedCatalog !== void 0 ? enableMixedCatalog : false; + this.supplementaryMetadataAssociations = supplementaryMetadataAssociations !== null && supplementaryMetadataAssociations !== void 0 ? supplementaryMetadataAssociations : []; + this.includeAppBinaryTraitsAttribute = objectGraph.client.isiOS; + // By default, the `platform` for web defaults to whatever the `activeIntent` is (e.g. "mac"), + // but this can be overridden when calling `setPreviewPlatform` with the request, which + // will set the `platform` to `web` and `previewPlatform` will be the `activeIntent` platform. + if ((_a = objectGraph.activeIntent) === null || _a === void 0 ? void 0 : _a.platform) { + this.platform = objectGraph.activeIntent.platform; + } + if (serverData.isNullOrEmpty(param)) { + return; + } + if (typeof param === "string") { + this.href = param; + } + else if (Array.isArray(param)) { + this.withDataItems(param, supplementaryMetadataAssociations, enableMixedCatalog); + } + } + /** + * Adds a data object to an idsByResourceType mapping. + * @param data The data object + * @returns An updated {resource-type: IDs} map, which includes the data object + */ + addDataToIDsByResourceType(data) { + const resourceType = data.type; + const id = data.id; + let ids = this.idsByResourceType.get(resourceType); + if (isNothing(ids)) { + ids = new Set(); + } + ids.add(id); + this.idsByResourceType.set(resourceType, ids); + } + forType(type) { + this.resourceType = type; + return this; + } + /** + * This method is used to add data items to the request. It is used to build the request for the mixed catalog / catalog + * + * @param dataItems The data items to add to the request + * @param supplementaryMetadataAssociations The metadata paths to add to the request + * @param enableMixedCatalog Whether to allow mixed catalog requests + * @returns The modified Request + */ + withDataItems(dataItems, supplementaryMetadataAssociations, enableMixedCatalog) { + if (dataItems.length === 0) { + return this; + } + this.isMixedMediaRequest = this.isMixedMediaRequest || (enableMixedCatalog !== null && enableMixedCatalog !== void 0 ? enableMixedCatalog : false); + for (const data of dataItems) { + // Track all IDs in a single set, for the case where we use the contents endpoint. + this.ids.add(data.id); + // Track all IDs by resource type, for either the case where we ultimately have just + // one resource type, or where we used the mixed catalog endpoint. + this.addDataToIDsByResourceType(data); + // If we have any additional metadata paths that need fetching, we now add them + // as additional resource types for the mixed catalog endpoint. + if (isSome(enableMixedCatalog) && + enableMixedCatalog && + isSome(supplementaryMetadataAssociations) && + supplementaryMetadataAssociations.length > 0) { + for (const association of supplementaryMetadataAssociations) { + const metadataItems = extractMetaAssociationFromData(association, data); + if (isSome(metadataItems) && metadataItems.length > 0) { + metadataItems.forEach((metadataItem) => { + this.addDataToIDsByResourceType(metadataItem); + }); + } + } + } + } + // Now that we have collated all IDs and resource types, we can assign them to different + // properties depending on the number of resource types we need. + if (this.idsByResourceType.size === 1) { + // We only have one list of IDs for a single resource type, so we just take the first one + this.resourceType = this.idsByResourceType.keys().next().value; + this.isMixedMediaRequest = false; + } + else if (this.idsByResourceType.size > 1 && !this.isMixedMediaRequest) { + this.resourceType = "contents"; + this.contentsResourceTypes = new Set(Array.from(this.idsByResourceType.keys())); + } + this.originalOrdering.push(...[...dataItems]); + return this; + } + /** + * Add a single id to this request, this should only be used when fetching a single resource + * @param id The single ID to add to the request + * @param type The type of the resource + * @returns The modified Request + */ + withIdOfType(id, type) { + return this.withDataItems([{ id, type }]); + } + /** + * Add a list of ids to this request, this will add these ids to the mapping of resource types + * @param ids The IDs to add to the request + * @param type The type of the resource + * @returns The modified Request + */ + withIdsOfType(ids, type) { + return this.withDataItems(ids.map((id) => ({ id, type }))); + } + includingRelationships(relationships) { + for (const relationship of relationships) { + this.relationshipIncludes.add(relationship); + } + return this; + } + includingScopedRelationships(scopedDataType, relationshipsToAdd) { + // Lazy init top-level property + if (!this.scopedRelationshipIncludes) { + this.scopedRelationshipIncludes = new Map(); + } + // Retrieve existing scoped relationship. Lazy init if needed. + let scopedRelationship = this.scopedRelationshipIncludes.get(scopedDataType); + if (!scopedRelationship) { + scopedRelationship = new Set(); + } + // Update + for (const newRelationship of relationshipsToAdd) { + scopedRelationship.add(newRelationship); + } + this.scopedRelationshipIncludes.set(scopedDataType, scopedRelationship); + return this; + } + includingMetaKeys(scopedDataType, keysToAdd) { + // Lazy init top-level property + if (!this.metaIncludes) { + this.metaIncludes = new Map(); + } + // Retrieve existing inclusion. Lazy init if needed. + let scopedMeta = this.metaIncludes.get(scopedDataType); + if (!scopedMeta) { + scopedMeta = new Set(); + } + // Update + for (const newKey of keysToAdd) { + scopedMeta.add(newKey); + } + this.metaIncludes.set(scopedDataType, scopedMeta); + return this; + } + includingViews(viewsToAdd) { + // Lazy init top-level property + if (!this.viewsIncludes) { + this.viewsIncludes = new Set(); + } + for (const view of viewsToAdd) { + this.viewsIncludes.add(view); + } + return this; + } + includingKindsKeys(scopedDataType, keysToAdd) { + // Lazy init top-level property + if (!this.kindIncludes) { + this.kindIncludes = new Map(); + } + // Retrieve existing inclusion. Lazy init if needed. + let scopedMeta = this.kindIncludes.get(scopedDataType); + if (!scopedMeta) { + scopedMeta = new Set(); + } + // Update + for (const newKey of keysToAdd) { + scopedMeta.add(newKey); + } + this.kindIncludes.set(scopedDataType, scopedMeta); + return this; + } + includingAssociateKeys(scopedDataType, keysToAdd) { + // Lazy init top-level property + if (!this.associateIncludes) { + this.associateIncludes = new Map(); + } + // Retrieve existing inclusion. Lazy init if needed. + let scopedAssociate = this.associateIncludes.get(scopedDataType); + if (!scopedAssociate) { + scopedAssociate = new Set(); + } + // Update + for (const newKey of keysToAdd) { + scopedAssociate.add(newKey); + } + this.associateIncludes.set(scopedDataType, scopedAssociate); + return this; + } + /** + * Include the relationships needed for an upsell. + * @param requiresScopedInclude A flag indicating whether the include should be "scoped". This will need to be the + * case when the relationships we are including is on a request for a separate primary resource type. For example, + * if we are looking to have the upsell relationship included in an EI (Today card, for example), this needs to be + * scoped. However, if we are fetching a grouping directly and need the upsell included, this should *not* be scoped. + */ + includingRelationshipsForUpsell(requiresScopedRelationshipInclude) { + const relationship = "marketing-items"; + if (requiresScopedRelationshipInclude) { + // Lazy init top-level property + if (!this.scopedRelationshipIncludes) { + this.scopedRelationshipIncludes = new Map(); + } + // Retrieve existing scoped relationship. Lazy init if needed. + let scopedRelationship = this.scopedRelationshipIncludes.get("editorial-items"); + if (!scopedRelationship) { + scopedRelationship = new Set(); + } + // Update + scopedRelationship.add(relationship); + this.scopedRelationshipIncludes.set("editorial-items", scopedRelationship); + } + else { + this.relationshipIncludes.add(relationship); + } + // In order to get metrics metadata stiched in to the marketing item relationship, we have to include it in our + // request. + if (relationship === "marketing-items") { + if (!this.metaIncludes) { + this.metaIncludes = new Map(); + } + // Retrieve existing inclusion. Lazy init if needed. + let scopedMeta = this.metaIncludes.get("marketing-items"); + if (!scopedMeta) { + scopedMeta = new Set(); + } + scopedMeta.add("metrics"); + this.metaIncludes.set("marketing-items", scopedMeta); + } + return this; + } + includingAttributes(attributes) { + for (const attribute of attributes) { + this.attributeIncludes.add(attribute); + } + return this; + } + includingScopedAttributes(resourceType, attributesToAdd) { + // Lazy init top-level property + if (!this.scopedAttributeIncludes) { + this.scopedAttributeIncludes = new Map(); + } + // Retrieve existing scoped relationship. Lazy init if needed. + let attributesForResourceType = this.scopedAttributeIncludes.get(resourceType); + if (!attributesForResourceType) { + attributesForResourceType = new Set(); + } + // Update + for (const attribute of attributesToAdd) { + attributesForResourceType.add(attribute); + } + this.scopedAttributeIncludes.set(resourceType, attributesForResourceType); + return this; + } + /** + * Adds an age restriction to the request. ManagedConfiguration provides + * this value on the client, which maps to JRPurpleRating.clientIdentifier. + * + * @returns {Request} The updated request + */ + includingAgeRestrictions() { + const maxAppContentRating = this.objectGraph.client.maxAppContentRating; + if (maxAppContentRating < ageRestrictionsDisabledThreshold) { + this.ageRestriction = maxAppContentRating; + } + return this; + } + includingAdditionalPlatforms(additionalPlatforms) { + for (const platform of additionalPlatforms) { + this.additionalPlatforms.add(platform); + } + return this; + } + includingScopedAvailableIn(resourceType, valuesToAdd) { + // Lazy init top-level property + if (!this.scopedAvailableInIncludes) { + this.scopedAvailableInIncludes = new Map(); + } + // Retrieve existing scoped relationship. Lazy init if needed. + let valuesForResourceType = this.scopedAvailableInIncludes.get(resourceType); + if (!valuesForResourceType) { + valuesForResourceType = new Set(); + } + // Update + for (const value of valuesToAdd) { + valuesForResourceType.add(value); + } + this.scopedAvailableInIncludes.set(resourceType, valuesForResourceType); + return this; + } + /** + * Include the sparse limit needed for a specific resource type. + * @param {media.Type} resourceType Resource type to use for the sparse limit. + * @param {number} value Value to set as the sparse limit. + * @returns {Request} Updated request. + */ + includingScopedSparseLimit(resourceType, value) { + // Lazy init top-level property + if (!this.scopedSparseLimit) { + this.scopedSparseLimit = new Map(); + } + this.scopedSparseLimit.set(resourceType, value); + return this; + } + addingQuery(key, value) { + if (isSome(value)) { + this.additionalQuery[key] = value; + } + else { + delete this.addingQuery[key]; + } + return this; + } + /** + * @param query The additional query values to add + * @returns The modified Reqeust + */ + addingQueryValues(query) { + this.additionalQuery = { + ...this.addingQuery, + ...query, + }; + return this; + } + addingRelationshipLimit(relationship, limit) { + this.relationshipLimits[relationship] = limit; + return this; + } + withSearchTerm(term) { + this.searchTerm = term; + return this; + } + searchingOverTypes(types) { + for (const type of types) { + this.searchTypes.push(type); + } + return this; + } + addingContext(context) { + this.context = context; + return this; + } + includingMacOSCompatibleIOSAppsWhenSupported(verifiedBadgeOnly = false) { + if (this.objectGraph.appleSilicon.isSupportEnabled) { + if (!verifiedBadgeOnly) { + this.enablingFeature("macOSCompatibleIOSApps"); + } + this.includingScopedAttributes("apps", ["isVerifiedForAppleSiliconMac"]); + } + return this; + } + /// Mark a request to include (or exclude) appBinaryTraits attributes. + includingAppBinaryTraitsAttribute(includeAppBinaryTraitsAttribute = true) { + this.includeAppBinaryTraitsAttribute = includeAppBinaryTraitsAttribute; + return this; + } + /** + * Mark a request to use custom attributes. + * This triggers usage of `customXYZ` extend attributes in url-builder for specific extend params + * e.g. `artwork`, `customArtwork`. + */ + usingCustomAttributes(useCustomAttributes) { + this.useCustomAttributes = useCustomAttributes; + return this; + } + alwaysUseIdsAsQueryParam(value) { + this.useIdsAsQueryParam = value; + return this; + } + attributingTo(canonicalUrl) { + this.canonicalUrl = canonicalUrl; + return this; + } + withFilter(type, value) { + this.filterType = type; + this.filterValue = value; + return this; + } + withLimit(limit) { + this.limit = limit; + return this; + } + withSparseLimit(sparseLimit) { + if (sparseLimit !== null) { + this.sparseLimit = sparseLimit; + } + return this; + } + withSparseCount(sparseCount) { + if (sparseCount !== null) { + this.sparseCount = sparseCount; + } + return this; + } + enablingFeature(feature) { + if (!this.enabledFeatures) { + this.enabledFeatures = []; + } + this.enabledFeatures.push(feature); + return this; + } + enablingFeatures(features) { + if (!this.enabledFeatures) { + this.enabledFeatures = []; + } + this.enabledFeatures.push(...features); + return this; + } + /** + * Limit the request to include only certain fields. + * This should only be used in very select use-cases, where: + * - There is no possibility of data being used for other purposes, e.g. sidpack + * - All consumer of this data use it in the same narrow scope, e.g. requesting a set of icons for displaying without metadata only. + * @param fields Set of fields to limit to + */ + asPartialResponseLimitedToFields(fields) { + this.fields = fields; + return this; + } + includesResourceType(resourceType) { + if (this.resourceType === resourceType) { + return true; + } + if (serverData.isDefinedNonNull(this.contentsResourceTypes)) { + return this.contentsResourceTypes.has(resourceType); + } + return false; + } + withCountryCodeOverride(countryCodeOverride) { + this.countryCodeOverride = countryCodeOverride; + return this; + } +} +/** + * Extracts the metadata association from the data. + * @param association The association to extract + * @param data The data to extract from + */ +export function extractMetaAssociationFromData(association, data) { + if (serverData.isNullOrEmpty(data)) { + return null; + } + const associationData = serverData.asArrayOrEmpty(data, `meta.associations.${association}.data`); + if (isNothing(associationData)) { + return null; + } + return [...associationData]; +} +//# sourceMappingURL=data-fetching.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/media/data-structure.js b/node_modules/@jet-app/app-store/tmp/src/foundation/media/data-structure.js new file mode 100644 index 0000000..cafcce8 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/media/data-structure.js @@ -0,0 +1,84 @@ +/** + * Created by joel on 1/25/18. + */ +import * as serverData from "../json-parsing/server-data"; +import { ResponseMetadata } from "../network/network"; +export function dataFromDataContainer(objectGraph, dataContainer) { + const dataArray = serverData.asArrayOrEmpty(dataContainer, "data"); + if (dataArray.length > 1) { + objectGraph.console.warn("tried to extract data from container but more than one member present"); + } + if (dataArray.length !== 1) { + return null; + } + return dataArray[0]; +} +export function dataCollectionFromDataContainer(dataContainer) { + return serverData.asArrayOrEmpty(dataContainer, "data"); +} +/** + * Check whether or not a server vended `Data` object is hydrated or not. + * @param {Data} data to check if hydrated. + */ +export function isDataHydrated(data) { + return serverData.isDefinedNonNull(data.attributes); +} +/** + * Check whether or not a entire data collection contains elements that are fully hydrated. + * @param {Data[]} dataArray Data array to check. + */ +export function isDataCollectionHydrated(dataCollection) { + // Iterate from the back to determine if fully hydrated faster - unhydrated elements tend to be latter elements. + const lastIndex = dataCollection.length - 1; + for (let index = lastIndex; index >= 0; index--) { + const data = dataCollection[index]; + if (!isDataHydrated(data)) { + return false; + } + } + return true; +} +/** + * Check whether or not a entire data collection at least has 1 element that is fully hydrated. + * @param {Data[]} dataArray Data array to check. + */ +export function isDataCollectionPartiallyHydrated(dataCollection) { + for (const data of dataCollection) { + if (isDataHydrated(data)) { + return true; + } + } + return false; +} +/** + * Check whether or not a today data module represents a today page on the heuristic that: + * - The "Today" modules have labels with value 'TodayForApps' as opposed to `WhatYouMissed` + * - Date marker "Today" modules have a 'date' field. + */ +export function isModuleTodayForApps(todayModule) { + const todayModuleId = "TodayForApps"; + const date = serverData.traverse(todayModule, "date"); + return todayModule.label === todayModuleId || serverData.isDefinedNonNull(date); +} +/** + * Get chart results from a server response. Always returns chart segments with valid data + */ +export function chartResultsFromServerResponse(response) { + const resultsArray = serverData.asArrayOrEmpty(response, "results.apps"); + return resultsArray.filter((segment) => { + return !serverData.isNull(segment.data); + }); +} +export function dataCollectionFromResultsListContainer(resultsListContainer) { + return serverData.asArrayOrEmpty(resultsListContainer, "results.contents"); +} +/** + * Get the metrics dictionary included in the meta data of a mediaApi Data object. + * @param {MetaDataProviding} metaDataProvidingObject + * @returns {MapLike<string> | null} + */ +export function metricsFromMediaApiObject(metaDataProvidingObject) { + return serverData.asDictionary(metaDataProvidingObject, "meta.metrics"); +} +// endregion +//# sourceMappingURL=data-structure.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/media/network.js b/node_modules/@jet-app/app-store/tmp/src/foundation/media/network.js new file mode 100644 index 0000000..2b01d40 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/media/network.js @@ -0,0 +1,304 @@ +/** + * Created by joel on 20/2/2018. + * + * This `network.ts` is the Media API arm of the netwok fetch requests. + * It is built on `Network` object and provides standard functionality specific for MAPI. + * + * @see `src/network.ts` for fetching from non-Media API endpoints + */ +import { isNothing, isSome } from "@jet/environment/types/optional"; +import * as serverData from "../json-parsing/server-data"; +import { MetricsIdentifierType } from "../metrics/metrics-identifiers-cache"; +import { ResponseMetadata } from "../network/network"; +import * as urls from "../network/urls"; +import { extractMetaAssociationFromData } from "./data-fetching"; +import * as urlBuilder from "./url-builder"; +const secondaryUserIdHeaderName = "X-Apple-AppStore-UserId-Secondary"; +/** + * Implements the MAPI fetch, building URL from MAPI Request and opaquely managing initial token request and refreshes. + * + * @param {Request} request MAPI Request to fetch with. + * @param {FetchOptions} options? FetchOptions for the MAPI request. + * @returns {Promise<Type>} Promise resolving to some type for given MAPI request. + */ +export async function fetchData(objectGraph, request, options) { + var _a; + const startTime = Date.now(); + const token = await objectGraph.mediaToken.refreshToken(); + const fetchTimingMetricsBuilder = objectGraph.fetchTimingMetricsBuilder; + const requestOptions = options !== null && options !== void 0 ? options : {}; + const personalizationIdentifier = (_a = objectGraph.personalizationMetricsIdentifiersCache) === null || _a === void 0 ? void 0 : _a.getMetricsIdForType(MetricsIdentifierType.user); + if (isSome(personalizationIdentifier)) { + if (isSome(requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers)) { + requestOptions.headers[secondaryUserIdHeaderName] = personalizationIdentifier; + } + else { + requestOptions.headers = { + [secondaryUserIdHeaderName]: personalizationIdentifier, + }; + } + } + const response = await fetchWithToken(objectGraph, request, token, requestOptions, false, fetchTimingMetricsBuilder); + const endTime = Date.now(); + if (request.canonicalUrl) { + response[ResponseMetadata.requestedUrl] = request.canonicalUrl; + } + const roundTripTimeIncludingWaiting = endTime - startTime; + if (roundTripTimeIncludingWaiting > 500) { + const longFetchUrl = urlBuilder.buildURLFromRequest(objectGraph, request).toString(); + objectGraph.console.warn("Fetch took too long (" + roundTripTimeIncludingWaiting.toString() + "ms) " + longFetchUrl); + } + return response; +} +export function redirectParametersInUrl(objectGraph, url) { + const redirectURLParams = objectGraph.bag.redirectUrlWhitelistedQueryParams; + return redirectURLParams.filter((param) => { var _a; return serverData.isDefinedNonNull((_a = url.query) === null || _a === void 0 ? void 0 : _a[param]); }); +} +/** + * Given a built URL, token, and options, calls into native networking APIs to fetch content. + * + * @param {string} url URL to fetch data from. + * @param {string} request The original request used to build this url. + * @param {string} token MAPI token key. + * @param {FetchOptions} options Fetch options for MAPI requests. + * @param {boolean} isRetry flag indicating whether this is a fetch retry following a 401 request, and media token was refreshed. + * @returns {Promise<Type>} Promise resolving to some type for given MAPI request. + */ +async function fetchWithToken(objectGraph, request, token, options = {}, isRetry = false, fetchTimingMetricsBuilder) { + var _a, _b; + const originalUrl = urlBuilder.buildURLFromRequest(objectGraph, request).toString(); + // Removes all affiliate/redirect params for caching (https://connectme.apple.com/docs/DOC-577671) + const filteredURL = new urls.URL(originalUrl); + const redirectParameters = redirectParametersInUrl(objectGraph, filteredURL); + for (const param of redirectParameters) { + filteredURL.removeParam(param); + } + const filteredUrlString = filteredURL.toString(); + let headers = options.headers; + if (!headers) { + headers = {}; + } + headers["Authorization"] = "Bearer " + token; + const response = await objectGraph.network.fetch({ + url: filteredUrlString, + headers: headers, + method: options.method, + body: options.requestBodyString, + timeout: options.timeout, + }); + try { + if (response.status === 401 || response.status === 403) { + if (isRetry) { + throw Error("We refreshed the token but we still get 401 from the API"); + } + objectGraph.mediaToken.resetToken(); + return await objectGraph.mediaToken.refreshToken().then(async (newToken) => { + // Explicitly re-fetch with the original request so logging and metrics are correct + return await fetchWithToken(objectGraph, request, newToken, options, true, fetchTimingMetricsBuilder); + }); + } + else if (response.status === 404) { + // item is not available in this storefront or perhaps not at all + throw noContentError(); + } + else if (!response.ok) { + const error = new NetworkError(`Bad Status code ${response.status} for ${filteredUrlString}, original ${originalUrl}`); + error.statusCode = response.status; + throw error; + } + const parser = (resp) => { + var _a; + const parseStartTime = Date.now(); + let result; + if (serverData.isNull(resp.body) || resp.body === "") { + if (resp.status === 204) { + // 204 indicates a success, but the response will typically be empty + // Create a fake result so that we don't throw an error when JSON parsing + const emptyData = {}; + result = emptyData; + } + else { + throw noContentError(); + } + } + else { + try { + result = JSON.parse(resp.body); + } + catch (e) { + let errorMessage = e.message; + if (["debug", "internal"].includes(objectGraph.client.buildType)) { + errorMessage = `${e.message}, body: ${resp.body}`; + } + throw new JSONParseError(errorMessage); + } + } + const parseEndTime = Date.now(); + if (result) { + result[ResponseMetadata.pageInformation] = serverData.asJSONData(getPageInformationFromResponse(objectGraph, resp)); + if (resp.metrics.length > 0) { + const metrics = { + ...resp.metrics[0], + parseStartTime: parseStartTime, + parseEndTime: parseEndTime, + }; + result[ResponseMetadata.timingValues] = metrics; + } + else { + const fallbackMetrics = { + pageURL: resp.url, + parseStartTime, + parseEndTime, + }; + result[ResponseMetadata.timingValues] = fallbackMetrics; + } + result[ResponseMetadata.contentMaxAge] = getContentTimeToLiveFromResponse(objectGraph, resp); + // If we have an empty data object, throw a 204 (No Content). + if (Array.isArray(result.data) && + serverData.isArrayDefinedNonNullAndEmpty(result.data) && + !serverData.asBooleanOrFalse(options.allowEmptyDataResponse)) { + throw noContentError(); + } + if (Array.isArray(result.data) && request.originalOrdering.length > 1) { + result.data = buildHydratedDataListResponse(objectGraph, request.originalOrdering, (_a = result.data) !== null && _a !== void 0 ? _a : [], request.supplementaryMetadataAssociations); + } + result[ResponseMetadata.requestedUrl] = originalUrl; + } + return result; + }; + if (isSome(fetchTimingMetricsBuilder)) { + return fetchTimingMetricsBuilder.measureParsing(response, parser); + } + else { + return parser(response); + } + } + catch (e) { + if (e instanceof NetworkError) { + throw e; + } + const correlationKey = (_a = response.headers["x-apple-jingle-correlation-key"]) !== null && _a !== void 0 ? _a : (_b = response.metrics[0]) === null || _b === void 0 ? void 0 : _b.clientCorrelationKey; + throw new Error(`Error Fetching - filtered: ${filteredUrlString}, original: ${originalUrl}, correlationKey: ${correlationKey !== null && correlationKey !== void 0 ? correlationKey : "N/A"}, ${e.name}, ${e.message}`); + } +} +export class NetworkError extends Error { +} +class JSONParseError extends Error { +} +export function noContentError() { + const error = new NetworkError(`No content`); + error.statusCode = 204; + return error; +} +export function notFoundError() { + const error = new NetworkError("Not found"); + error.statusCode = 404; + return error; +} +const serverInstanceHeader = "x-apple-application-instance"; +const environmentDataCenterHeader = "x-apple-application-site"; +function getPageInformationFromResponse(objectGraph, response) { + const storeFrontHeader = objectGraph.client.storefrontIdentifier; + let storeFront = null; + if ((storeFrontHeader === null || storeFrontHeader === void 0 ? void 0 : storeFrontHeader.length) > 0) { + const storeFrontHeaderComponents = storeFrontHeader.split("-"); + if (serverData.isDefinedNonNullNonEmpty(storeFrontHeaderComponents)) { + storeFront = storeFrontHeaderComponents[0]; + } + } + return { + serverInstance: response.headers[serverInstanceHeader], + storeFrontHeader: storeFrontHeader, + language: objectGraph.bag.language, + storeFront: storeFront, + environmentDataCenter: response.headers[environmentDataCenterHeader], + }; +} +function getContentTimeToLiveFromResponse(objectGraph, response) { + const cacheControlHeaderKey = Object.keys(response.headers).find((key) => key.toLowerCase() === "cache-control"); + if (serverData.isNull(cacheControlHeaderKey) || cacheControlHeaderKey === "") { + return null; + } + const headerValue = response.headers[cacheControlHeaderKey]; + if (serverData.isNullOrEmpty(headerValue)) { + return null; + } + const matches = headerValue.match(/max-age=(\d+)/); + if (serverData.isNull(matches) || matches.length < 2) { + return null; + } + return serverData.asNumber(matches[1]); +} +/** + * Builds the hydrated list of shelf items, based on the data in the response, and the original unhydated items. + */ +function buildHydratedDataListResponse(objectGraph, unhydratedData, hydratedDataCollection, associations = []) { + // Create a map of all the hydrated data items from the response, using the resource type and ID as the key + const hydratedDataMap = {}; + for (const dataItem of hydratedDataCollection) { + const key = dataMapKey(objectGraph, dataItem.type, dataItem.id); + hydratedDataMap[key] = dataItem; + } + // Next iterate through the unhyrated items in their original order, and swap in the hydrated item. + const hydratedItems = []; + for (const unhydratedItem of unhydratedData) { + const key = dataMapKey(objectGraph, unhydratedItem.type, unhydratedItem.id); + const hydratedItem = hydratedDataMap[key]; + if (isSome(hydratedItem)) { + /// Start with a base of what was there already, this is to ensure we don't lose any existing meta data + /// if some of the requested associations are not present in the response. + if (serverData.isDefinedNonNullNonEmpty(associations)) { + hydratedItem.meta = { + ...unhydratedItem.meta, + }; + for (const association of associations) { + hydrateMetaAssociationIfNecessary(objectGraph, association, hydratedItem, unhydratedItem, hydratedDataMap); + } + } + hydratedItems.push(hydratedItem); + } + } + return hydratedItems; +} +/** + * Creates a key to use in a mapping of data items. + * @param objectGraph Current object graph + * @param data The data item + * @returns A string composed from the data item ID and resource type + */ +function dataMapKey(objectGraph, resourceType, id) { + return `${resourceType}_${id}`; +} +/** + * @param objectGraph The current object graph + * @param association The association we'd like to hydrate in the meta object + * @param unhydratedItem The original MAPI data item to look for editorial card, and fill in with a fetched card if there is one + * @param hydratedDataMap The data map of all the fetched items keyed by id / type + */ +function hydrateMetaAssociationIfNecessary(objectGraph, association, hydratedItem, unhydratedItem, hydratedDataMap) { + var _a; + if (isNothing(hydratedItem.meta)) { + hydratedItem.meta = { + associations: {}, + }; + } + else if (isNothing(hydratedItem.meta.associations)) { + hydratedItem.meta.associations = {}; + } + const unhydratedAssociationsData = extractMetaAssociationFromData(association, unhydratedItem); + if (serverData.isDefinedNonNullNonEmpty(unhydratedAssociationsData)) { + const hydratedAssociationData = []; + for (const unhydratedAssociation of unhydratedAssociationsData) { + const associationDataKey = dataMapKey(objectGraph, unhydratedAssociation.type, unhydratedAssociation.id); + const associationData = hydratedDataMap[associationDataKey]; + if (isSome(associationData)) { + hydratedAssociationData.push(associationData); + } + } + const hydratedAssociations = (_a = serverData.asDictionary(hydratedItem.meta.associations)) !== null && _a !== void 0 ? _a : {}; + hydratedAssociations[association] = { + data: hydratedAssociationData, + }; + } +} +//# sourceMappingURL=network.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/media/platform-attributes.js b/node_modules/@jet-app/app-store/tmp/src/foundation/media/platform-attributes.js new file mode 100644 index 0000000..3849624 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/media/platform-attributes.js @@ -0,0 +1,143 @@ +import { isNothing } from "@jet/environment/types/optional"; +import * as serverData from "../json-parsing/server-data"; +import * as attributes from "./attributes"; +/** + * There are nested attributes that are platform-specific. If provided with a platform for which the response data has + * platform-specific attributes, this function will return those attributes. + * @param {Data} data The data for which to determine attributes. + * @param {AttributePlatform} platform The platform to fetch the attributes for + * @returns {any} If a platform is provided, returns `true` exactly when platform-specific attributes exist for that + * platform. If no platform is provided, it simply returns the data's top-level attributes. + */ +function attributesForPlatform(data, platform) { + const allPlatformAttributes = attributes.attributeAsDictionary(data, "platformAttributes"); + return serverData.traverse(allPlatformAttributes, platform !== null && platform !== void 0 ? platform : undefined); +} +/** + * Determines if attributes exist for a given platform + * @param {Data} data The data to check + * @param {AttributePlatform} platform The platform to check + * @returns {boolean} True if the platform exists in the data's platform attributes. False if not. + */ +export function hasPlatformAttribute(data, platform) { + const platformAttributes = attributesForPlatform(data, platform); + return serverData.isDefinedNonNullNonEmpty(platformAttributes); +} +/** + * Retrieve the specified attribute from the data as a dictionary + * + * @param data The data from which to retrieve the attribute. + * @param platform The platform to look up + * @param attributePath The path of the attribute. + * @returns The value for the requested attribute + */ +export function platformAttributeAsDictionary(data, platform, attributePath) { + const platformAttributes = attributesForPlatform(data, platform); + if (serverData.isNull(platformAttributes)) { + return null; + } + return serverData.asDictionary(platformAttributes, attributePath); +} +/** + * Retrieve the specified attribute from the data as an array. + * + * @param data The data from which to retrieve the attribute. + * @param platform The platform to look up + * @param attributePath The path of the attribute. + * @returns {any[]} The attribute value as an array. + */ +export function platformAttributeAsArray(data, platform, attributePath) { + const platformAttributes = attributesForPlatform(data, platform); + if (isNothing(platformAttributes)) { + return null; + } + return serverData.asArray(platformAttributes, attributePath); +} +/** + * Retrieve the specified attribute from the data as an array, coercing to an empty array if the object is not an array. + * + * @param data The data from which to retrieve the attribute. + * @param platform The platform to look up + * @param attributePath The path of the attribute. + * @returns {any[]} The attribute value as an array. + */ +export function platformAttributeAsArrayOrEmpty(data, platform, attributePath) { + const platformAttributes = attributesForPlatform(data, platform); + if (serverData.isNull(platformAttributes)) { + return []; + } + return serverData.asArrayOrEmpty(platformAttributes, attributePath); +} +/** + * Retrieve the specified attribute from the data as a string. + * + * If the attribute lives under the platform-specific attributes, then a platform may be provided to properly call in to + * the nested structure. + * @param data The data from which to retrieve the attribute. + * @param platform The platform to look up + * @param attributePath The object path for the attribute. + * @param policy The validation policy to use when resolving this value. + * @returns {string} The attribute value as a string. + */ +export function platformAttributeAsString(data, platform, attributePath, policy = "coercible") { + const platformAttributes = attributesForPlatform(data, platform); + if (serverData.isNull(platformAttributes)) { + return null; + } + return serverData.asString(platformAttributes, attributePath, policy); +} +/** + * Retrieve the specified attribute from the data as a boolean. + * + * If the attribute lives under the platform-specific attributes, then a platform may be provided to properly call in to + * the nested structure. + * @param data The data from which to retrieve the attribute. + * @param platform The platform to look up + * @param attributePath The path of the attribute. + * @param policy The validation policy to use when resolving this value. + * @returns {boolean} The attribute value as a boolean. + */ +export function platformAttributeAsBoolean(data, platform, attributePath, policy = "coercible") { + const platformAttributes = attributesForPlatform(data, platform); + if (serverData.isNull(platformAttributes)) { + return null; + } + return serverData.asBoolean(platformAttributes, attributePath, policy); +} +/** + * Retrieve the specified attribute from the data as a boolean, which will be `false` if the attribute does not exist. + * + * If the attribute lives under the platform-specific attributes, then a platform may be provided to properly call in to + * the nested structure. + * @param data The data from which to retrieve the attribute. + * @param platform The platform to look up + * @param attributePath The path of the attribute. + * @returns {boolean} The attribute value as a boolean, coercing to `false` if the value is not present.. + */ +export function platformAttributeAsBooleanOrFalse(data, platform, attributePath) { + const platformAttributes = attributesForPlatform(data, platform); + if (serverData.isNull(platformAttributes)) { + return false; + } + return serverData.asBooleanOrFalse(platformAttributes, attributePath); +} +/** + * Retrieve the specified attribute from the data as a number. + * + * If the attribute lives under the platform-specific attributes, then a platform may be provided to properly call in to + * the nested structure. + * @param data The data from which to retrieve the attribute. + * @param platform The platform to look up + * @param attributePath The path of the attribute. + * @param policy The validation policy to use when resolving this value. + * @returns {boolean} The attribute value as a number. + */ +export function platformAttributeAsNumber(data, platform, attributePath, policy = "coercible") { + const platformAttributes = attributesForPlatform(data, platform); + if (serverData.isNull(platformAttributes)) { + return null; + } + return serverData.asNumber(platformAttributes, attributePath, policy); +} +// endregion +//# sourceMappingURL=platform-attributes.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/media/relationships.js b/node_modules/@jet-app/app-store/tmp/src/foundation/media/relationships.js new file mode 100644 index 0000000..0f96574 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/media/relationships.js @@ -0,0 +1,43 @@ +import * as serverData from "../json-parsing/server-data"; +export function hasRelationship(data, relationshipType, checkForContent = true) { + const relationshipDataContainer = relationship(data, relationshipType); + if (!relationshipDataContainer) { + return false; + } + if (!relationshipDataContainer.data || (checkForContent && relationshipDataContainer.data.length === 0)) { + return false; + } + return true; +} +export function relationship(data, relationshipType) { + if (serverData.isDefinedNonNull(data)) { + return serverData.asInterface(data.relationships, relationshipType); + } + return null; +} +export function relationshipViewsContainer(data, relationshipType) { + return serverData.asInterface(data.views, relationshipType); +} +export function relationshipData(objectGraph, data, relationshipType) { + const relationshipDataArray = serverData.asArrayOrEmpty(data.relationships, [ + relationshipType, + "data", + ]); + if (relationshipDataArray.length === 0) { + return null; + } + if (relationshipDataArray.length > 1) { + objectGraph.console.warn(`there was an array of relationships when only the first was asked for in relationship ${relationshipType}`); + } + return relationshipDataArray[0]; +} +export function relationshipCollection(data, relationshipType, allowNulls = false) { + if (!hasRelationship(data, relationshipType, false) && allowNulls) { + return null; + } + return serverData.asArrayOrEmpty(data.relationships, [relationshipType, "data"]); +} +export function relationshipViewsCollection(data, relationshipType) { + return serverData.asArrayOrEmpty(data.views, [relationshipType, "data"]); +} +//# sourceMappingURL=relationships.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/media/url-builder.js b/node_modules/@jet-app/app-store/tmp/src/foundation/media/url-builder.js new file mode 100644 index 0000000..955529c --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/media/url-builder.js @@ -0,0 +1,381 @@ +/** + * Created by joel on 11/4/2018. + */ +import { isNothing, isSome } from "@jet/environment/types/optional"; +import * as serverData from "../json-parsing/server-data"; +import * as urls from "../network/urls"; +import * as attributes from "./attributes"; +/// this is exposed for compatibility. If you find yourself needing to use this outside of the media api module you +/// probably have code smell. DO NOT USE. +export function buildURLFromRequest(objectGraph, request) { + var _a, _b; + const baseURL = request.href && request.href.length > 0 + ? baseURLForHref(request.href) + : baseURLForResourceType(objectGraph, request.isMixedMediaRequest, request.resourceType, request.countryCodeOverride); + const mediaApiURL = new urls.URL(baseURL); + if (serverData.isDefinedNonNullNonEmpty(request.resourceType)) { + for (const pathComponent of pathComponentsForRequest(request.resourceType, request.targetResourceType)) { + mediaApiURL.append("pathname", pathComponent); + } + } + if (request.isMixedMediaRequest) { + for (const [resourceType, ids] of request.idsByResourceType.entries()) { + mediaApiURL.param(`ids[${resourceType}]`, Array.from(ids).sort().join(",")); + } + } + else if (request.ids.size > 1 || request.useIdsAsQueryParam) { + mediaApiURL.param("ids", Array.from(request.ids).sort().join(",")); + } + else if (request.ids.size === 1) { + const id = request.ids.values().next().value; + mediaApiURL.append("pathname", id); + } + if (request.resourceType !== undefined) { + const trailingPathComponent = trailingPathComponentForResourceType(request.resourceType); + if (serverData.isDefinedNonNullNonEmpty(trailingPathComponent)) { + mediaApiURL.append("pathname", trailingPathComponent); + } + } + mediaApiURL.param("platform", (_a = request.platform) !== null && _a !== void 0 ? _a : undefined); + if (request.additionalPlatforms.size > 0) { + mediaApiURL.param("additionalPlatforms", Array.from(request.additionalPlatforms).sort().join(",")); + } + /** + * Add `extend` attributes. + * Note that when `useCustomAttributes` is true, there is `customArtwork` param even when `attributeIncludes` is initially empty. + * This due MAPI auto-extend for `artwork`, and lack of auto-extend for `customArtwork` + */ + if (request.attributeIncludes.size > 0 || request.useCustomAttributes) { + let extendAttributes = Array.from(request.attributeIncludes); + if (request.useCustomAttributes) { + extendAttributes = convertRequestAttributesToCustomAttributes(objectGraph, extendAttributes); + } + extendAttributes.sort(); + mediaApiURL.param("extend", extendAttributes.join(",")); + } + // Add age restriction if present. + if (serverData.isDefinedNonNull(request.ageRestriction) && objectGraph.bag.enableAgeRatingFilter) { + mediaApiURL.param("restrict[ageRestriction]", request.ageRestriction.toString()); + } + // Automatically extend iOS catalog requests for apps to include appBinaryTraits. + if (request.includeAppBinaryTraitsAttribute) { + request.includingScopedAttributes("apps", ["appBinaryTraits"]); + } + if (serverData.isDefinedNonNull(request.scopedAttributeIncludes)) { + for (const [dataType, scopedIncludes] of request.scopedAttributeIncludes.entries()) { + mediaApiURL.param(`extend[${dataType}]`, Array.from(scopedIncludes).sort().join(",")); + } + } + if (request.relationshipIncludes.size > 0) { + mediaApiURL.param("include", Array.from(request.relationshipIncludes).sort().join(",")); + } + if (serverData.isDefinedNonNull(request.scopedRelationshipIncludes)) { + for (const [dataType, scopedIncludes] of request.scopedRelationshipIncludes.entries()) { + mediaApiURL.param(`include[${dataType}]`, Array.from(scopedIncludes).sort().join(",")); + } + } + if (serverData.isDefinedNonNull(request.metaIncludes)) { + for (const [dataType, scopedMeta] of request.metaIncludes.entries()) { + mediaApiURL.param(`meta[${dataType}]`, Array.from(scopedMeta).sort().join(",")); + } + } + if (serverData.isSetDefinedNonNullNonEmpty(request.viewsIncludes)) { + mediaApiURL.param("views", Array.from(request.viewsIncludes).sort().join(",")); + } + if (serverData.isDefinedNonNull(request.kindIncludes)) { + for (const [dataType, scopedMeta] of request.kindIncludes.entries()) { + mediaApiURL.param(`kinds[${dataType}]`, Array.from(scopedMeta).sort().join(",")); + } + } + if (serverData.isDefinedNonNull(request.associateIncludes)) { + for (const [dataType, scopedAssociate] of request.associateIncludes.entries()) { + mediaApiURL.param(`associate[${dataType}]`, Array.from(scopedAssociate).sort().join(",")); + } + } + if (serverData.isDefinedNonNull(request.scopedAvailableInIncludes)) { + for (const [dataType, scopedAvailableIn] of request.scopedAvailableInIncludes.entries()) { + mediaApiURL.param(`availableIn[${dataType}]`, Array.from(scopedAvailableIn).sort().join(",")); + } + } + if (serverData.isDefinedNonNullNonEmpty(request.fields)) { + let extendedFields = Array.from(request.fields); + if (request.useCustomAttributes) { + extendedFields = convertRequestFieldsToCustomFields(extendedFields); + } + request.fields.sort(); + mediaApiURL.param("fields", extendedFields.join(",")); + } + if (serverData.isDefinedNonNull(request.limit) && request.limit > 0) { + mediaApiURL.param(`limit`, `${request.limit}`); + } + if (serverData.isDefinedNonNull(request.sparseLimit)) { + mediaApiURL.param(`sparseLimit`, `${request.sparseLimit}`); + } + if (serverData.isDefinedNonNull(request.scopedSparseLimit)) { + for (const [dataType, scopedLimit] of request.scopedSparseLimit.entries()) { + mediaApiURL.param(`sparseLimit[${dataType}]`, String(scopedLimit)); + } + } + if (serverData.isDefinedNonNull(request.sparseCount)) { + mediaApiURL.param(`sparseCount`, `${request.sparseCount}`); + } + for (const relationshipID of Object.keys(request.relationshipLimits).sort()) { + const limit = request.relationshipLimits[relationshipID]; + mediaApiURL.param(`limit[${relationshipID}]`, `${limit}`); + } + if (serverData.isDefinedNonNullNonEmpty(request.additionalQuery)) { + mediaApiURL.append("query", request.additionalQuery); + } + if (serverData.isDefinedNonNullNonEmpty(request.searchTerm)) { + // Search hints shouldn't add `search` to the end of the path name as the correct final path + // is `v1/catalog/us/search/suggestions`, which is handled by `trailingPathComponentForResourceType()` + // Search hints also shouldn't have the bubble param + if (isNothing(request.resourceType) || request.resourceType !== "search-hints") { + mediaApiURL.append("pathname", "search"); + mediaApiURL.param("bubble[search]", request.searchTypes.join(",")); + } + mediaApiURL.param("term", request.searchTerm); + } + if (serverData.isDefinedNonNullNonEmpty(request.enabledFeatures)) { + mediaApiURL.param("with", request.enabledFeatures.join(",")); + } + if (serverData.isDefinedNonNullNonEmpty(request.context)) { + mediaApiURL.param("contexts", request.context); + } + if (serverData.isDefinedNonNullNonEmpty(request.filterType) && + serverData.isDefinedNonNullNonEmpty(request.filterValue)) { + mediaApiURL.param(`filter[${request.filterType}]`, request.filterValue); + } + const language = objectGraph.bag.mediaApiLanguage; + // Only attach the language query param if: + // - there is a language available in the bag, and + // - a language has not been manually attached to the request. This is used for special situations to override the language for particular content, + // so it should take precedence over the default. + if (serverData.isDefinedNonNull(language) && serverData.isNull(request.additionalQuery["l"])) { + mediaApiURL.param("l", language); + } + mediaApiURL.host = (_b = hostForUrl(objectGraph, mediaApiURL, request)) !== null && _b !== void 0 ? _b : undefined; + mediaApiURL.protocol = "https"; + return mediaApiURL; +} +/** + * Get the media api base url for all requests. + * @param objectGraph Current object graph + * @param isMixedCatalogRequest Whether the request intends to use mixed catalog + * @param type The request resource type + * @param overrideCountryCode A country code to override the bag value. + * @returns A built base URL string + */ +function baseURLForResourceType(objectGraph, isMixedCatalogRequest, type, overrideCountryCode) { + switch (type) { + case "personalization-data": + case "reviews": + case "app-distribution": + return `/v1/${endpointTypeForResourceType(type)}/`; + default: + const countryCode = isSome(overrideCountryCode) && overrideCountryCode.length > 0 + ? overrideCountryCode + : objectGraph.bag.mediaCountryCode; + const baseURL = `/v1/${endpointTypeForResourceType(type)}/${countryCode}`; + return isMixedCatalogRequest ? baseURL : `${baseURL}/`; + } +} +/** + * Get the media api base url for all requests that already have an href. + * @return {string} + */ +function baseURLForHref(href) { + return href; +} +function endpointTypeForResourceType(type) { + switch (type) { + case "apps": + case "app-events": + case "arcade-apps": + case "app-bundles": + case "charts": + case "contents": + case "developers": + case "eula": + case "in-apps": + case "multiple-system-operators": + case "user-reviews": + case "customers-also-bought-apps-with-download-intent": + return "catalog"; + case "categories": + case "editorial-pages": + case "editorial-items": + case "editorial-item-groups": + case "editorial-elements": + case "groupings": + case "multiplex": + case "multirooms": + case "rooms": + case "today": + case "collections": + return "editorial"; + case "ratings": + return "ratings"; + case "personalization-data": + case "reviews": + return "me"; + case "upsellMarketingItem": + case "landing": + return "engagement"; + case "landing:new-protocol": + return "recommendations"; + case "personal-recommendations": + return "recommendations"; + case "engagement-data": + return "engagement"; + case "app-distribution": + return "listing"; + default: + return "catalog"; + } +} +/** + * The path component to add for the given resource + */ +function pathComponentsForRequest(resourceType, targetResourceType) { + switch (resourceType) { + case "eula": + if (targetResourceType === undefined) { + return [resourceType]; // Might be modelled better as an error. + } + else { + return [resourceType, targetResourceType]; + } + case "landing:new-protocol": + return []; + case "landing": + if (targetResourceType === undefined) { + return ["search", resourceType]; // Might be modelled better as an error. + } + else { + return ["search", resourceType, targetResourceType]; + } + case "user-reviews": + return ["apps"]; + case "reviews": + return ["reviews", "apps"]; + case "multiplex": + return ["multiplex"]; + case "upsellMarketingItem": + return ["upsell", "marketing-items"]; + case "trending-contents": + return ["search", resourceType]; + case "customers-also-bought-apps-with-download-intent": + return ["apps"]; + case "searchLanding:see-all": + return []; + case "search-hints": + return []; + case "app-distribution": + return ["apps"]; + default: + return [resourceType]; + } +} +/** + * Add a component to the end of the path for the given resource + */ +function trailingPathComponentForResourceType(type) { + switch (type) { + case "user-reviews": + return "reviews"; + case "customers-also-bought-apps-with-download-intent": + return "view/customers-also-bought-apps-with-download-intent"; + case "collections": + return "contents"; + case "searchLanding:see-all": + return "view/see-all"; + case "search-hints": + return "search/suggestions"; + default: + return null; + } +} +function hostForUrl(objectGraph, url, request) { + var _a; + const path = (_a = url.pathname) !== null && _a !== void 0 ? _a : ""; + let host = null; + if (request.isStorePreviewRequest) { + host = objectGraph.bag.mediaPreviewHost; + } + else if (request.isMediaRealmRequest) { + host = objectGraph.bag.mediaRealmHost; + } + else if (path.includes("search/landing")) { + // Special case <rdar://problem/50185140> RFW3: Use bag key "apps-media-api-edge-end-points" for "search/landing" end-point + // until we figure out a better way to test the paths + const useEdgeForSearchLanding = objectGraph.bag.edgeEndpoints.indexOf("landing") !== -1; + host = useEdgeForSearchLanding ? objectGraph.bag.mediaEdgeHost(objectGraph) : objectGraph.bag.mediaHost; + } + else if (request.resourceType === "app-distribution" && isSome(objectGraph.bag.appDistributionMediaAPIHost)) { + host = objectGraph.bag.appDistributionMediaAPIHost; + } + else if (request.isMixedMediaRequest && objectGraph.bag.mediaAPICatalogMixedShouldUseEdge) { + // CatalogMixed endpoint should be routed to edge when the bag is enabled. + host = objectGraph.bag.mediaEdgeHost(objectGraph); + } + else if (objectGraph.bag.edgeEndpoints.map((endpoint) => path.includes(endpoint)).reduce(truthReducer, false)) { + if (path.includes("search") && !path.includes("view/see-all")) { + host = objectGraph.bag.mediaEdgeSearchHost; + } + else { + host = objectGraph.bag.mediaEdgeHost(objectGraph); + } + } + else { + host = objectGraph.bag.mediaHost; + } + if (serverData.isNull(host)) { + host = "api.apps.apple.com"; + } + return host; +} +const truthReducer = (accumulator, current) => accumulator || current; +/** + * Performs a conversion for given attribute to fetch the customAttribute variant of it. + * @param objectGraph The object graph + * @param attribute Attribute to convert if needed, e.g. `artwork` + * @returns `string` attribute that is custom equivalent of `attribute`, or `attribute` unmodified. + */ +function convertRequestAttributesToCustomAttributes(objectGraph, requestAttributes) { + const convertedAttributes = requestAttributes.map((attribute) => { + var _a; + return (_a = attributes.attributeKeyAsCustomAttributeKey(attribute)) !== null && _a !== void 0 ? _a : attribute; + }); + /** + * `artwork` is an autoincluded resources, so `attributes` usually doesn't contain this explicitly :( + * Per MAPI contract, we "autoinclude" `customArtwork` explicitly for requests with custon attributes. + */ + convertedAttributes.push("customArtwork"); + /** + * `iconArtwork` is not autoincluded, but we need to ensure it is always requested even alongside its + * custom counterpart, `customIconArtwork`. This is because we might be viewing a macOS only app on iOS, + * where custom attributes are supported, but not available for macOS apps. + */ + if (requestAttributes.includes("iconArtwork")) { + convertedAttributes.push("iconArtwork"); + } + /** + * `customDeepLink` is always desired as an included resource in case an app decides to use a custom tap destination. + * Per MAPI contract, we "autoinclude" `customDeepLink` explicitly for all requests with custom attributes. + */ + convertedAttributes.push("customDeepLink"); + return convertedAttributes; +} +/** + * Performs the conversion for given field value (which may specify `attributes` keys) to customAttribute variant of it. + */ +function convertRequestFieldsToCustomFields(requestFields) { + const convertedFields = requestFields.map((fieldName) => { + var _a; + return (_a = attributes.attributeKeyAsCustomAttributeKey(fieldName)) !== null && _a !== void 0 ? _a : fieldName; + }); + // DON'T include `customArtwork` for request `field` conversion. Only specify if `artwork` was initially in `requestFields`. + return convertedFields; +} +//# sourceMappingURL=url-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/media/util.js b/node_modules/@jet-app/app-store/tmp/src/foundation/media/util.js new file mode 100644 index 0000000..77ed5c2 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/media/util.js @@ -0,0 +1,185 @@ +import { noContentError, notFoundError } from "./network"; +/** + * Validate an untrusted adam ID without contacting the server. + * + * This allows avoiding the work of calling the server with completely bogus + * IDs. It's scoped to web since ID formats can change and web can be updated + * easily (whereas backporting to older native clients is trickier). + * + * @param {AppStoreObjectGraph} objectGraph + * @param {string} id - the Adam ID to validate + * @returns {void} undefined if valid, throws a `NetworkError` (204) otherwise + */ +export function validateAdamId(objectGraph, id) { + if (objectGraph.client.isWeb && !isAdamId(id)) { + throw noContentError(); + } +} +/** + * Check if an ID is a valid Adam ID. + * + * @param {string} id - string to validate + * @return {boolean} true if valid, false otherwise + */ +function isAdamId(id) { + // Media API actually validates if the number <= 2^63-1. But doubles in + // JavaScript cannot precisely represent this (the closest number is >2^63) + // so checking this requires BigInt, which might not be available. At the + // end of the day, checking this is likely not worth the complexity. 2^63-1 + // is 9223372036854775807 so we just restrict the number of digits. + // + // See: https://github.pie.apple.com/its/amp-enums/blob/f75500b44f871f35ba3ce459a5ff4c9f225e71b0/src/main/java/com/apple/jingle/store/IdSpace.java#L131-L140 + // See: https://github.com/google/guava/blob/869a75a1e3ff85d36672a3cd154772dc90c7b3d2/guava/src/com/google/common/primitives/Longs.java#L400-L440 + // See: https://docs.oracle.com/en/java/javase/24/docs/api/java.base/java/lang/Long.html#MAX_VALUE + return /^\d{1,19}$/.test(id); +} +/** + * Validate an untrusted Featured Content ID without contacting the server. + * + * This allows avoiding the work of calling the server with completely bogus + * IDs. It's scoped to web since ID formats can change and web can be updated + * easily (whereas backporting to older native clients is trickier). + * + * @param {AppStoreObjectGraph} objectGraph + * @param {string} id the FC ID to validate + * @returns {void} undefined if valid, throws a `NetworkError` (204) otherwise + */ +export function validateFcId(objectGraph, id) { + if (objectGraph.client.isWeb && !isFcId(id)) { + throw noContentError(); + } +} +/** + * Check if an ID is a valid Featured Content (FC) ID. + * + * @param {string} id - string to validate + * @return {boolean} true if valid, false otherwise + */ +function isFcId(id) { + // FcIds are actually Adam IDs under the hood. + // See: https://github.pie.apple.com/its/Jingle/blob/d2d051c9ef2891f72d5f02f5bbbf2d7748afa7b9/MZStoreComponents/src/main/java/com/apple/jingle/app/store/editorial/SFEditorialHelper.java#L293 + return isAdamId(id); +} +/** + * Validate an untrusted (Chart) Genre ID without contacting the server. + * + * This allows avoiding the work of calling the server with completely bogus + * IDs. It's scoped to web since ID formats can change and web can be updated + * easily (whereas backporting to older native clients is trickier). + * + * @param {AppStoreObjectGraph} objectGraph + * @param {string} id the genre ID to validate + * @returns {void} undefined if valid, throws a `NetworkError` (204) otherwise + */ +export function validateGenreId(objectGraph, id) { + if (objectGraph.client.isWeb && !isGenreId(id)) { + throw noContentError(); + } +} +/** + * Check if an ID is a valid (Chart) Genre ID. + * + * @param {string} id - string to validate + * @return {boolean} true if valid, false otherwise + */ +function isGenreId(id) { + // Genre IDs are Java int (signed 32-bit). + // + // Technically negative is not excluded, but all charts are positive, so + // filter out negative. + // + // See: https://github.pie.apple.com/its/Jingle/blob/main/shared/reference-data-logic/MZReferenceDataLogic/src/main/java/com/apple/jingle/eo/MZGenreService.java#L555 + return isPositiveJavaInt(id); +} +/** + * Validate an untrusted Grouping ID without contacting the server. + * + * This allows avoiding the work of calling the server with completely bogus + * IDs. It's scoped to web since ID formats can change and web can be updated + * easily (whereas backporting to older native clients is trickier). + * + * @param {AppStoreObjectGraph} objectGraph + * @param {string} id the grouping ID to validate + * @returns {void} undefined if valid, throws a `NetworkError` (204) otherwise + */ +export function validateGroupingId(objectGraph, id) { + if (objectGraph.client.isWeb && !isGroupingId(id)) { + throw noContentError(); + } +} +/** + * Check if an ID is a valid Grouping ID. + * + * @param {string} id - string to validate + * @return {boolean} true if valid, false otherwise + */ +function isGroupingId(id) { + // Grouping IDs are Java int (signed 32-bit) + // + // Technically negative does not fail to parse, but they're all positive in + // practice. + // + // See: https://github.pie.apple.com/its/Jingle/blob/aaccec936f1feed227fd171ae66bb160cf38e497/MZStorePlatform/src/main/java/com/apple/jingle/store/mediaapi/util/SFMediaAPIEditorialUtil.java#L634 + return isPositiveJavaInt(id); +} +/** + * Test if a string contains a Java int. + * + * @param {string} s - the string to test + * @returns {boolean} true if the string is a stringified Java int, false otherwise + */ +function isPositiveJavaInt(s) { + // Java int is 32-bit signed. We can check bounds since signed integers are + // exactly representable as doubles (actually up to 2^53 is representable + // exactly). + // + // See: https://docs.oracle.com/en/java/javase/24/docs/api/java.base/java/lang/Integer.html#MAX_VALUE + return /^\d+$/.test(s) && parseInt(s, 10) <= 2147483647; +} +/** + * Validate an untrusted Editorial Shelf Collection ID without contacting the server. + * + * This allows avoiding the work of calling the server with completely bogus + * IDs. It's scoped to web since ID formats can change and web can be updated + * easily (whereas backporting to older native clients is trickier). + * + * @param {AppStoreObjectGraph} objectGraph + * @param {string} id the editorial shelf collection ID to validate + * @returns {void} undefined if valid, throws a `NetworkError` (204) otherwise + */ +export function validateEditorialShelfCollectionId(objectGraph, id) { + if (objectGraph.client.isWeb && !isEditorialShelfCollectionId(id)) { + throw noContentError(); + } +} +/** + * Check if an ID is a valid editorial shelf collection ID. + * + * @param {string} id - string to validate + * @return {boolean} true if valid, false otherwise + */ +function isEditorialShelfCollectionId(id) { + // Ids are prefixed with "eds.". Beyond that they do have a UUID-type + // identifier that follows, but that seems more liable to change. + // + // See: https://github.pie.apple.com/its/amp-enums/blob/f75500b44f871f35ba3ce459a5ff4c9f225e71b0/src/main/java/com/apple/jingle/store/IdSpace.java#L43C5-L43C20 + // See: https://github.pie.apple.com/its/amp-enums/blob/f75500b44f871f35ba3ce459a5ff4c9f225e71b0/src/main/java/com/apple/jingle/store/IdSpace.java#L250-L252 + return id.startsWith("eds."); +} +/** + * Validates if a request can be performed for `vision` platform content, based on + * the feature flag is disabled. + * + * @param {AppStoreObjectGraph} objectGraph The application's state graph. + * @throws {NetworkError} Throws a 404 error if access is restricted. + * @returns {void} + */ +export function validateNeedsVisionRestriction(objectGraph) { + var _a; + if (objectGraph.client.isWeb && + ((_a = objectGraph.activeIntent) === null || _a === void 0 ? void 0 : _a.previewPlatform) === "vision" && + !objectGraph.bag.enableVisionPlatform) { + throw notFoundError(); + } +} +//# sourceMappingURL=util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/metrics/buy-parameters.js b/node_modules/@jet-app/app-store/tmp/src/foundation/metrics/buy-parameters.js new file mode 100644 index 0000000..a48e886 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/metrics/buy-parameters.js @@ -0,0 +1,112 @@ +import { isNothing, isSome } from "@jet/environment/types/optional"; +/** + * An object which allows buy parameters to be operated on like a hash map. + */ +export class BuyParameters { + /** + * Create a buy parameters object with an optional string representation. + * + * @param buyParams A string containing buy parameters. + */ + constructor(buyParams) { + this._values = {}; + if (isSome(buyParams) && buyParams.length > 0) { + const pairs = buyParams.split("&"); + for (const pair of pairs) { + const [encodedKey, encodedValue] = pair.split("="); + const key = decodeURIComponent(encodedKey); + const value = isNothing(encodedValue) ? "" : decodeURIComponent(encodedValue); + this._values[key] = value; + } + } + } + /** + * Determine the search key to use for the given parameters. + * + * @param key The key to determine the search value for. + * @param prefix An optional prefix to prepend to `key`. + * @returns A key which can be used to store and retrieve + * values in this buy parameters object. + */ + _searchKey(key, prefix) { + if (key.length === 0) { + throw new Error("key may not be zero length"); + } + if (isNothing(prefix) || prefix.length === 0) { + return key; + } + else { + return `${prefix}${key.charAt(0).toUpperCase()}${key.slice(1)}`; + } + } + /** + * Returns the value associated with a given key. + * + * @param key The key to retrieve the associated value for. + * @param keyPrefix The prefix to add to the key. Defaults to `mt`. + * @returns The value associated with `key`, or `undefined` is none is found. + */ + get(key, keyPrefix = "mt") { + const searchKey = this._searchKey(key, keyPrefix); + return this._values[searchKey]; + } + /** + * Add a given key-value pair to this buy parameters. + * + * If a value was previously associated with `key`, + * it will be replaced with `value`. + * + * @param key The key to associate `value` with in these buy parameters. + * @param value The value to add to the buy parameters. If value is `undefined` + * or `null`, any values previously associated with `key` will be removed. + * @param keyPrefix The prefix to add to the key. Defaults to `mt`. + * @returns `this` + */ + set(key, value, keyPrefix = "mt") { + const searchKey = this._searchKey(key, keyPrefix); + if (isNothing(value)) { + delete this._values[searchKey]; + } + else { + this._values[searchKey] = value; + } + return this; + } + /** + * Convert this buy parameters to its string representation. + */ + toString() { + let buyParams = ""; + for (const key of Object.keys(this._values)) { + const value = this._values[key]; + if (buyParams.length > 0) { + buyParams += "&"; + } + buyParams += encodeURIComponent(key); + buyParams += "="; + buyParams += encodeURIComponent(value); + } + return buyParams; + } + /** + * Convert the buy params into a map representation, in which + * the keys and values are encoded. + */ + toEncodedMap() { + const map = {}; + for (const key of Object.keys(this._values)) { + const value = this._values[key]; + const encodedKey = encodeURIComponent(key); + const encodedValue = encodeURIComponent(value); + map[encodedKey] = encodedValue; + } + return map; + } + /** + * Buy params in a raw (non url encoded) map representation. + */ + toRawMap() { + return { ...this._values }; + } +} +//# sourceMappingURL=buy-parameters.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/metrics/cookies.js b/node_modules/@jet-app/app-store/tmp/src/foundation/metrics/cookies.js new file mode 100644 index 0000000..5005b72 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/metrics/cookies.js @@ -0,0 +1,27 @@ +import { isNothing } from "@jet/environment/types/optional"; +/** + * Iterate the cookies contained in a string. + * + * @param cookie A string containing zero or more cookies. + */ +export function* cookiesOf(cookie) { + if (isNothing(cookie)) { + return; + } + const rawEntries = cookie.split(";"); + for (const rawEntry of rawEntries) { + const keyEndIndex = rawEntry.indexOf("="); + if (keyEndIndex === -1) { + // If there's no splitter, treat the whole raw + // entry as the key and provide an empty value. + const key = decodeURIComponent(rawEntry).trim(); + yield { key, value: "" }; + } + else { + const key = decodeURIComponent(rawEntry.substring(0, keyEndIndex)).trim(); + const value = decodeURIComponent(rawEntry.substring(keyEndIndex + 1)).trim(); + yield { key, value }; + } + } +} +//# sourceMappingURL=cookies.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/metrics/metrics-identifiers-cache.js b/node_modules/@jet-app/app-store/tmp/src/foundation/metrics/metrics-identifiers-cache.js new file mode 100644 index 0000000..96a487f --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/metrics/metrics-identifiers-cache.js @@ -0,0 +1,245 @@ +import { isNothing, isSome } from "@jet/environment"; +import * as validation from "@jet/environment/json/validation"; +import { makeMetatype } from "@jet/environment/util/metatype"; +/** + * @public + * Type to define which type of metrics identifier key to use to fetch identifiers, fields, etc. + */ +export var MetricsIdentifierType; +(function (MetricsIdentifierType) { + MetricsIdentifierType["client"] = "clientId"; + MetricsIdentifierType["user"] = "userId"; + MetricsIdentifierType["canonical"] = "canonicalAccountIdentifierOverride"; +})(MetricsIdentifierType || (MetricsIdentifierType = {})); +/** + * @public + * The default namespaces to provide to the native `MetricsIdStore` for fetching and caching + */ +export var MetricsIdentifiersDefaultBagNamespaces; +(function (MetricsIdentifiersDefaultBagNamespaces) { + MetricsIdentifiersDefaultBagNamespaces["client"] = "APPSTORE_ENGAGEMENT_CLIENT"; + MetricsIdentifiersDefaultBagNamespaces["user"] = "APPSTORE_ENGAGEMENT"; +})(MetricsIdentifiersDefaultBagNamespaces || (MetricsIdentifiersDefaultBagNamespaces = {})); +export var MetricsIdentifiersPaymentBagNamespaces; +(function (MetricsIdentifiersPaymentBagNamespaces) { + MetricsIdentifiersPaymentBagNamespaces["client"] = "APPSTORE_PAYMENTS_ENGAGEMENT_CLIENT"; + MetricsIdentifiersPaymentBagNamespaces["user"] = "APPSTORE_PAYMENTS_ENGAGEMENT"; +})(MetricsIdentifiersPaymentBagNamespaces || (MetricsIdentifiersPaymentBagNamespaces = {})); +export var MetricsIdentifiersPersonalizationBagNamespaces; +(function (MetricsIdentifiersPersonalizationBagNamespaces) { + MetricsIdentifiersPersonalizationBagNamespaces["user"] = "APPSTORE_PERSONALIZATION"; +})(MetricsIdentifiersPersonalizationBagNamespaces || (MetricsIdentifiersPersonalizationBagNamespaces = {})); +/** + * The payment context mappings for a metrics identifier key. + */ +export const paymentIdentifierContextMapping = { + [MetricsIdentifierType.client]: { + keyType: MetricsIdentifierType.client, + bagNamespace: MetricsIdentifiersPaymentBagNamespaces.client, + crossSyncDevice: false, + }, + [MetricsIdentifierType.user]: { + keyType: MetricsIdentifierType.user, + bagNamespace: MetricsIdentifiersPaymentBagNamespaces.user, + crossSyncDevice: true, + }, +}; +/** + * The default context mappings for a metrics identifier key. + */ +const defaultIdentifierContextMapping = { + [MetricsIdentifierType.client]: { + keyType: MetricsIdentifierType.client, + bagNamespace: MetricsIdentifiersDefaultBagNamespaces.client, + crossSyncDevice: false, + }, + [MetricsIdentifierType.user]: { + keyType: MetricsIdentifierType.user, + bagNamespace: MetricsIdentifiersDefaultBagNamespaces.user, + crossSyncDevice: true, + }, +}; +/** + * The personalization context mappings for a metrics identifier key. + */ +export const personalizationIdentifierContextMapping = { + [MetricsIdentifierType.user]: { + keyType: MetricsIdentifierType.user, + bagNamespace: MetricsIdentifiersPersonalizationBagNamespaces.user, + crossSyncDevice: true, + }, +}; +/** + * Represents a cache for metrics identifiers and fields. + */ +export class MetricsIdentifiersCache { + /** + * Constructs a new instance of the MetricsIdentifiersCache class. + * @param identifierContextMapping - The mapping of identifier types to key contexts. + */ + constructor(identifierContextMapping = defaultIdentifierContextMapping) { + this.cachedMetricsIds = {}; + this.cachedMetricsFields = {}; + /** + * A flag indicating whether a DSID fallback field should be added to the event fields. + */ + this.shouldAddDsIdFallbackField = false; + /** + * The DSID of the currently logged in user on this JS request. + */ + this.userDsId = null; + this.identifierContextMapping = identifierContextMapping; + } + /** + * Loads the values for the specified identifier types. + * @param objectGraph - The object graph. + * @param idTypes - The identifier types. + * @returns A promise that resolves to an array of loaded values. + */ + async loadValues(objectGraph, idTypes) { + if (objectGraph.bag.isMetricsUserIdFallbackEnabled && !objectGraph.user.isUnderThirteen) { + this.shouldAddDsIdFallbackField = true; + this.userDsId = objectGraph.user.dsid; + } + else { + this.shouldAddDsIdFallbackField = false; + this.userDsId = null; + } + const loadedValues = []; + for (const idType of idTypes) { + const idTypeLoadedValues = await this.loadValuesForIdType(objectGraph, idType); + loadedValues.push(idTypeLoadedValues); + } + for (const { idType, id, fields } of loadedValues) { + if (id) { + this.cachedMetricsIds[idType] = id; + } + if (fields) { + this.cachedMetricsFields[idType] = fields; + } + } + } + /** + * @param objectGraph The app store object graph for all our native dependencies + * @param idType The type of id we're loading values for + * @returns The MetricsIdStore values for this id type + */ + async loadValuesForIdType(objectGraph, idType) { + const returnValues = { + idType, + }; + const context = this.identifierContextMapping[idType]; + if (context) { + try { + const fields = await validation.context("MetricsIdentifiersCache:loadValues:metricsFields", async () => { + return await objectGraph.metricsIdentifiers.getMetricsFieldsForContexts([context]); + }); + if (isSome(fields)) { + returnValues["fields"] = fields; + const extractedIdValue = fields[idType]; + if (isSome(extractedIdValue) && + typeof extractedIdValue === "string" && + extractedIdValue.length > 0) { + returnValues["id"] = extractedIdValue; + } + } + } + catch (error) { + objectGraph.console.error(`Unable to fetch metrics fields for idType ${idType}`, error); + } + if (isNothing(returnValues["id"])) { + try { + const id = await validation.context("MetricsIdentifiersCache:loadValues:metricsIdentifier", async () => { + return await objectGraph.metricsIdentifiers.getIdentifierForContext(context); + }); + if (isSome(id)) { + returnValues["id"] = id; + } + } + catch (error) { + objectGraph.console.error(`Unable to fetch metrics identifier for idType ${idType}`, error); + } + } + } + return returnValues; + } + /** + * Gets the metrics identifier for the specified identifier type. + * @param idType - The identifier type. + * @returns The metrics identifier, or undefined if not found. + */ + getMetricsIdForType(idType) { + return this.cachedMetricsIds[idType]; + } + /** + * Gets the metrics fields for the specified identifier types. + * @param idTypes - The identifier types. + * @returns The metrics fields, or undefined if not found. + */ + getMetricsFieldsForTypes(idTypes) { + const fieldsForTypes = idTypes.map((idType) => { var _a; return (_a = this.cachedMetricsFields[idType]) !== null && _a !== void 0 ? _a : {}; }); + const eventFields = Object.assign({}, ...fieldsForTypes); + if (this.shouldAddDsIdFallbackField && idTypes.indexOf(MetricsIdentifierType.user) !== -1) { + this.addDsIdFallbackFieldIfNecessary(eventFields); + } + return eventFields; + } + /** + * Adds a DSID fallback field to the event fields if necessary. + * @param eventFields - The event fields. + */ + addDsIdFallbackFieldIfNecessary(eventFields) { + const existingUserId = eventFields[MetricsIdentifierType.user]; + const isExistingUserIdInvalid = isNothing(existingUserId) || + typeof existingUserId !== "string" || + existingUserId.length === 0 || + existingUserId.length === MetricsIdentifiersCache.clientGeneratedUserIdLength; + if (isExistingUserIdInvalid && isSome(this.userDsId) && this.userDsId.length > 0) { + eventFields["dsId"] = this.userDsId; + } + } + /** + * Allows the setting of an app-level canonical account override for downstream metrics computations + * @param canonicalAccountIdentifier - The identifier to use when operated with canonical account overides + */ + setCanonicalAccountIdentifierOverride(canonicalAccountIdentifier) { + if (canonicalAccountIdentifier.length >= 0) { + this.cachedMetricsFields[MetricsIdentifierType.canonical] = { + [MetricsIdentifierType.canonical]: canonicalAccountIdentifier, + }; + } + } +} +/** + * The metatype of the MetricsIdentifiersCache class. + */ +MetricsIdentifiersCache.defaultMetatype = makeMetatype("app-store:metricsIdentifiersCache"); +MetricsIdentifiersCache.paymentMetatype = makeMetatype("app-store:paymentMetricsIdentifiersCache"); +MetricsIdentifiersCache.personalizationMetatype = makeMetatype("app-store:personalizationMetricsIdentifiersCache"); +/** + * The length of a client generated user ID. + */ +MetricsIdentifiersCache.clientGeneratedUserIdLength = 24; +export class MockMetricsIdentifiersCache extends MetricsIdentifiersCache { + constructor() { + super(); + this.cachedMetricsIds = { + [MetricsIdentifierType.client]: "1a2b3c4d5e", + [MetricsIdentifierType.user]: "1a2b3c4d5e", + }; + this.cachedMetricsFields = { + [MetricsIdentifierType.client]: { + clientId: "1a2b3c4d5e", + }, + [MetricsIdentifierType.user]: { + userNs: "mockuserNs", + userId: "1a2b3c4d5e", + metricsId: 2, + }, + [MetricsIdentifierType.canonical]: { + canonicalAccountIdentifierOverride: "mockCanonicalAccountIdentifier", + }, + }; + } +} +//# sourceMappingURL=metrics-identifiers-cache.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/network/http.js b/node_modules/@jet-app/app-store/tmp/src/foundation/network/http.js new file mode 100644 index 0000000..34c6a9a --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/network/http.js @@ -0,0 +1,42 @@ +/** + * Created by keithpk on 12/3/16. + */ +/** + * The `FormBuilder` class can be used to construct HTTP + * the form parameters for use with an HTTP post operation. + */ +export class FormBuilder { + /** + * The content type to use for form parameters. + */ + static get contentType() { + return "application/x-www-form-urlencoded"; + } + /** + * Construct an empty form builder. + */ + constructor() { + this._params = ""; + } + /** + * Append a parameter to the builder's form parameters. + * @param key The key of the parameter. + * @param value The value of the parameter. + * @return The builder. + */ + param(key, value) { + if (key && value) { + const separator = this._params.length > 0 ? "&" : ""; + this._params += `${separator}${encodeURIComponent(key)}=${encodeURIComponent(value)}`; + } + return this; + } + /** + * Create and return a form parameters string based on the contents of the builder. + * @return The form parameters string. + */ + build() { + return this._params; + } +} +//# sourceMappingURL=http.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/network/network.js b/node_modules/@jet-app/app-store/tmp/src/foundation/network/network.js new file mode 100644 index 0000000..db302e7 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/network/network.js @@ -0,0 +1,123 @@ +/** + * Created by ls on 9/7/2018. + * + * This `network.ts` is the NON-MEDIA API arm of network fetch requests. + * It is built on `Network` object and provides standard functionality, such as: + * 1. Parsing the body into specific format. + * 2. Adding timing metrics onto blob. + * + * This should *only* be used for objects that should have timing metrics, i.e. requests to Non-MediaAPI endpoints + * that will ultimately render some whole page. Otherwise, use `objectGraph.network.fetch` directly. + * + * @see `src/media/network.ts` for fetching from Media API endpoints + */ +import { isSome } from "@jet/environment/types/optional"; +import * as serverData from "../json-parsing/server-data"; +/** @public */ +// eslint-disable-next-line @typescript-eslint/no-namespace +export var ResponseMetadata; +(function (ResponseMetadata) { + ResponseMetadata.requestedUrl = "_jet-internal:metricsHelpers_requestedUrl"; + /** + * Symbol used to place timing metrics values onto fetch responses + * without interfering with the data returned by the server. + */ + ResponseMetadata.timingValues = "_jet-internal:metricsHelpers_timingValues"; + /** + * Key used to access the page information gathered from a response's headers + */ + ResponseMetadata.pageInformation = "_jet-internal:metricsHelpers_pageInformation"; + /** + * Key used to access the content max-age gathered from a response's headers. + */ + ResponseMetadata.contentMaxAge = "_jet-internal:responseMetadata_contentMaxAge"; +})(ResponseMetadata || (ResponseMetadata = {})); +/** + * Module's private fetch implementation built off `net` global. + * + * @param {FetchRequest} request describes fetch request. + * @param {(value: string) => Type} parser Some function parsing response body `string` into specific type. + * @returns {Promise<Type>} Promise resolving to specific object. + * @throws {Error} Throws error if status code of request is not 200. + * + * @note Similar to `fetchWithToken` in `media` module, but excludes media token specific functionality. + * Top level data fetches to endpoints that don't do redirects, and can benefit from metrics should + * call methods that build off of this instead of calling `objectGraph.network.fetch(...)` directly. + */ +async function fetch(objectGraph, request, parser) { + const response = await objectGraph.network.fetch(request); + if (!response.ok) { + throw Error(`Bad Status code ${response.status} for ${request.url}`); + } + const parseStartTime = Date.now(); + const result = parser(response.body); + const parseEndTime = Date.now(); + if (result) { + // Build full network timing metrics. + const completeTimingMetrics = networkTimingMetricsWithParseTime(response.metrics, parseStartTime, parseEndTime); + if (serverData.isDefinedNonNull(completeTimingMetrics)) { + result[ResponseMetadata.timingValues] = completeTimingMetrics; + } + } + result[ResponseMetadata.requestedUrl] = request.url.toString(); + return result; +} +/** + * Fetch from an endpoint with JSON response body. + * + * @param {FetchRequest} request to fetch from endpoint with JSON response.. + * @returns {Promise<Type>} Promise resolving to body of response parsed as `Type`. + * @throws {Error} Throws error if status code of request is not 200. + */ +export async function fetchJSON(objectGraph, request) { + return await fetch(objectGraph, request, (body) => { + if (isSome(body)) { + return JSON.parse(body); + } + else { + // eslint-disable-next-line @typescript-eslint/consistent-type-assertions + return {}; + } + }); +} +/** + * Fetch from an endpoint with XML response body. + * + * @param {FetchRequest} request to fetch from endpoint with XML response. + * @returns {Promise<Type>} Promise resolving to body of response parsed as `Type`. + * @throws {Error} Throws error if status code of request is not 200. + */ +export async function fetchPlist(objectGraph, request) { + return await fetch(objectGraph, request, (body) => { + if (isSome(body)) { + return objectGraph.plist.parse(body); + } + else { + throw new Error(`Could not fetch Plist, response body was not defined for ${request.url}`); + } + }); +} +/** + * With network requests now being created and parsed in JS, different timing metrics are measured in both Native and JS. + * This function populates the missing values from `HTTPTimingMetrics`'s native counterpart, `JSNetworkPerformanceMetrics`. + * + * @param {HTTPTimingMetrics[] | null} responseMetrics Array of response metrics provided by native. + * @param {number} parseStartTime Time at which response body string parse began in JS. + * @param {number} parseEndTime Time at which response body string parse ended in JS. + * @returns {HTTPTimingMetrics | null} Fully populated timing metrics, or `null` if native response provided no metrics events to build off of. + */ +function networkTimingMetricsWithParseTime(responseMetrics, parseStartTime, parseEndTime) { + // No metrics events to build from. + if (serverData.isNull(responseMetrics) || responseMetrics.length === 0) { + return null; + } + // Append parse times to first partial timing metrics from native. + const firstPartialTimingMetrics = { + ...responseMetrics[0], + parseStartTime: parseStartTime, + parseEndTime: parseEndTime, + }; + // Timing metrics with all properties populated. + return firstPartialTimingMetrics; +} +//# sourceMappingURL=network.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/network/url-constants.js b/node_modules/@jet-app/app-store/tmp/src/foundation/network/url-constants.js new file mode 100644 index 0000000..f25d9cb --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/network/url-constants.js @@ -0,0 +1,452 @@ +/** + * Copied from SKUIUrl these action types come in urls like scheme:/?action=[UrlAction] + */ +/* tslint:disable:variable-name */ +export const Protocol = { + /// Protocol used for internal app store routing + internal: "x-as3-internal", + /// Protocol used for routing HTTP URLs + http: "http", + /// Protocol used for routing standard HTTPS URLs + https: "https", + /// The protocol used for iTunes app urls + itms: "itms", + /// The protocol used for secure iTunes app urls + itmss: "itmss", + /// Protocol used to target the app store + itmsAppss: "itms-appss", + /// Protocol used to target the app store + itmsApps: "itms-apps", + /// Protocol used to target the messages app store + itmsMessagess: "itms-messagess", + /// Protocol used to target the messages app store + itmsMessages: "itms-messages", + /// Protocol used to target the watch app store + itmsWatchs: "itms-watchs", + /// Protocol used to target the watch app store + itmsWatch: "itms-watch", + /// Protocol used for internal file routing + file: "file", + /// Protocol used for referencing resources in the host app's bundles. + resource: "resource", + /// Protocol used to target the mac app store + macappstore: "macappstore", + /// Protocol used to target the mac app store + macappstores: "macappstores", + /// Legacy protocol used to target the tv app store, + /// kept to maintain backwards compatibility. + tvappstoreLegacy: "com.apple.tvappstore", + /// Protocol used to target the tv app store + tvappstore: "com.apple.TVAppStore", + /// Protocol used to target Arcade + arcade: "com.apple.Arcade", + /// Protocol used to target StoreKitUI App Store service + storeKitUIServiceAppStore: "appstore-ui", +}; +export const Path = { + // Path for loading a shelf + shelf: "shelf", + // Path for MZStore requests + store: "WebObjects/MZStore.woa/wa", + // Path for MZStoreElements requests + storeElements: "WebObjects/MZStoreElements.woa/wa", + // Path for performing a lookup + lookup: "lookup", + // Path for performing a docTypeLookup + docTypeLookup: "docTypeLookup", + // Path for performing an install sheet + install: "install", + // Path to the grouping page + grouping: "viewGrouping", + // Path to the artist page + viewArtist: "viewArtist", + // Path to the product page + viewSoftware: "viewSoftware", + // Path to the today page + today: "today", + // Path to the arcade main page + arcade: "arcade", + arcadeUpsellPreview: "arcadeUpsellPreview", + // Path to Arcade See All + arcadeSeeAllGames: "arcadeSeeAllGames", + // Pagination path for Arcade See All + arcadeSeeAllGamesLoadMore: "arcadeSeeAllGamesLoadMore", + // Path to the genre page (which is a grouping page) + genre: "genre", + // Path to the genre page (which is a grouping page) + viewGenre: "viewGenre", + recommendationsSeeAll: "recommendationsSeeAll", + // Path for a screenshots lookup. + screenshots: "screenshots", + // Path to a single room + room: "viewRoom", + // Path to a programmed multi-room + multiRoom: "viewMultiRoom", + // Path to the main top charts page + charts: "charts", + // Path to the product page + product: "app", + // Path to the game page + game: "game", + // Path to siri product page deep links on tvOS App Store. + siri: "siri", + // Path to the product page for an app bundle. + productBundle: "app-bundle", + // Path component for the developer page + developer: "developer", + artist: "artist", + // Path component for the ratings shelf + ratings: "ratings", + // Path component for the reviews shelf + reviews: "reviews", + // Path to view reviews for MZStore + viewReviews: "viewContentsUserReviews", + // Path component for the personalized review shelf + personalizedReviews: "personalizedReviews", + // Path to editorial items (articles) + article: "article", + story: "story", + editorialItem: "editorialItem", + viewEditorialItem: "viewEditorialItem", + todayCardPreview: "todayCardPreview", + // Path component for MSO rooms + mso: "mso", + // Path for resetting the storefront + resetAndRedirect: "resetAndRedirect", + // Account + account: "account", + personalizationTransparency: "personalizationTransparency", + // Path component for an href-driven route. + href: "href", + // Path component for the EULA. + eula: "eula", + // Path component for the EULA on tvOS. + tvEula: "tv-eula", + // Path component for the Privacy Policy on tvOS. + privacyPolicy: "privacyPolicy", + // Path component for the Safety and Compliance Page on tvOS. + safetyCompliance: "safety-compliance", + // Path component for recommendations + appsForYou: "apps-for-you", + // Path for the storeFront + storeFront: "storeFront", + // Path for the tab + tab: "tab", + // Path component for the search landing page. + searchLandingPage: "searchLandingPage", + // Path component for search trending content page. + searchTrendingApps: "searchTrendingApps", + // Path for showing product privacy detail page + privacyDetail: "privacyDetail", + // Path for showing product privacy definitions page + privacyDefinitions: "privacyDefinitions", + // Path for the report a problem link + reportAProblem: "reportaproblem.apple.com/store", + // Path for showing a game center player profile + gameCenterProfile: "gameCenterProfile", + // Path for showing the ODP page + onDeviceRecommendations: "onDeviceRecommendations", + // Path for editorial pages + editorialPage: "editorialPage", + // Path to acessibility details + accessibilityDetails: "accessibilityDetails", + // ---------------------- + // Debug + // ---------------------- + test: "test", + shelfTypes: "shelfTypes", + groupingTest: "grouping", + builtIn: "builtIn", + shelfTextTest: "shelfText", + shelfLockupsTest: "shelfLockups", + shelfMiscTest: "shelfMisc", + lockupTest: "lockupTest", + articleTestArtwork: "articleArtworkTest", + articleTestSingleAppIcon: "articleSingleAppIconTest", + articleTestSingleAppIconHeroArt: "articleSingleAppIconHeroArtTest", + articleTestBrandedApp: "articleBrandedAppTest", + articleTestMultiAppTwo: "articleMultiAppTwoTest", + articleTestMultiAppThree: "articleMultiAppThreeTest", + articleTestGrid: "articleGridTest", + articleTestInAppPurchase: "articleInAppPurchaseTest", +}; +export const Host = { + // Legacy Mac Software Update URL + showUpdatesPage: "showUpdatesPage", + // Legacy Deep Link Actions + showAccountPage: "showAccountPage", + showPurchasesPage: "showPurchasesPage", + showSubscriptionsPage: "showSubscriptionsPage", + // Legacy MAS Safari Extension Search + searchExtensions: "searchExtensions", + // Legacy search.itunes.apple.com redirected urls + searchItunes: "search.itunes.apple.com", + // Legacy itunes.apple.com redirected urls + iTunes: "itunes.apple.com", + // Urls allowing programming to preview programmed groupings + storePreview: "storepreview.apple.com", + // Urls allowing programming to preview programmed stories + appsPreview: "preview.apps.apple.com", + // Legacy product url for tvOS App Store + product: "product", + // Host for arcade subscribe page + arcadeSubscribePage: "arcadeSubscribePage", + // Host for an upsell that must necessarily go through our own Arcade subscribe page, + // rather than through an AMS marketing item page. + arcadeSubscribePageCustomContext: "arcadeSubscribePageCustomContext", + // Host for arcade welcome page + arcadeWelcomePage: "arcadeWelcomePage", + // Host for Arcade See All page for standalone case. + arcadeSeeAllPage: "arcadeSeeAllGames", + // Host for the deep link from an Arcade app clip. + appClipSubscribe: "appClipSubscribe", + familyCircle: "familyCircle", + // Host for showing spam blocking extensions + spamBlockingExtensions: "spamBlockingExtensions", + // Host for showing Safari extensions + safariExtensions: "safariExtensions", + // Host for app launch trampoline + launchApp: "launchApp", + // Host for SharePlay more deeplink + sharePlayApps: "sharePlayApps", + // Host for opening a deeplink at the end of Buddy + buddyOnboarding: "buddyOnboarding", + // Host for Arcade download (starter) pack page + arcadeDownloadPackPage: "arcadeDownloadPack", + // Host for showing settings page + showSettingsPage: "showSettingsPage", + // Host for showing settings page + showHiddenPurchasesPage: "showHiddenPurchases", +}; +/// The different preview hosts that require the media api preview endpoint +export const previewHosts = new Set([Host.storePreview, Host.appsPreview]); +export const Parameters = { + // Generic ID + id: "id", + // Generic IDs + ids: "ids", + // Product variant ID for given `id` + productVariantID: "ppid", + // Country Code + countryCode: "cc", + // Language override + language: "l", + // Featured Content ID + featuredContentId: "fcId", + fetchData: "fetchData", + isTodaySection: "isTodaySection", + isTodayFeedPreview: "isTodayFeedPreview", + // Genre + genre: "genre", + // Bundle Identifier + bundleIdentifier: "bundleIdentifier", + // BundleID + bundleId: "bundleId", + // Spotlight In-App Purchase Identifier + offerName: "offerName", + // Top Charts + charts: "charts", + ages: "ages", + chart: "chart", + types: "types", + // v0 urls (used e.g. when redirected from MZContentLink URLs). + v0: "v0", + // Action urls + action: "action", + // Type parameter + type: "type", + context: "context", + isArcade: "isArcade", + isSubscribed: "isSubscribed", + isTrialAvailable: "isTrialAvailable", + isTrialEnrolled: "isTrialEnrolled", + groupingFeaturedContentId: "groupingFeaturedContentId", + editorialPageShelfType: "editorialPageShelfType", + nativeGroupingShelfId: "nativeGroupingShelfId", + isArcadeSeeAllGamesShelf: "isArcadeSeeAllGamesShelf", + isGameCenterActivityFeedShelf: "isGameCenterActivityFeedShelf", + isGameCenterPlayerShelf: "isGameCenterPlayerShelf", + isGameCenterPlayerRibbonItem: "isGameCenterPlayerRibbonItem", + isGameCenterAchievementsShelf: "isGameCenterAchievementsShelf", + isGameCenterContinuePlayingShelf: "isGameCenterContinuePlayingShelf", + isGameCenterPopularWithYourFriendsShelf: "isGameCenterPopularWithYourFriendsShelf", + isGameCenterSuggestedFriendsShelf: "isGameCenterSuggestedFriendsShelf", + isGameCenterReengagementShelf: "isGameCenterReengagementShelf", + isOnDeviceRecommendationsShelf: "isOnDeviceRecommendationsShelf", + isOnDeviceSearchHistoryShelf: "isOnDeviceSearchHistoryShelf", + isSearchFocusHeaderShelf: "isSearchFocusHeaderShelf", + isArcadeDownloadPackShelfPlaceholder: "isArcadeDownloadPackShelfPlaceholder", + onDeviceRecommendationsUseCase: "onDeviceRecommendationsUseCase", + onDevicePersonalizationUseCase: "onDevicePersonalizationUseCase", + // Denotes that this url is coming from the purchases page. + isPurchasesApp: "isPurchasesApp", + // Used for single sign on, the parameter is passed from store kit + isViewOnly: "isViewOnly", + // Determines whether unlisted apps should be returned in the response. + // Note that for direct lookups, MAPI allows the App Store to view unlisted + // apps without this parameter, although they would like to eventually gate + // the behavior behind this parameter. + includeUnlistedApps: "includeUnlistedApps", + enabled: "enabled", + href: "href", + recoMetrics: "recoMetrics", + // Used on article urls when the TodayCard is showing fallback media + showingFallbackMedia: "showingFallbackMedia", + path: "path", + useReleaseId: "useReleaseId", + // The client identifier that should be used to display the item, regardless of host device. + clientIdentifierOverride: "clientIdentifierOverride", + // The message attached to the subscribe page, for ATB. + subscribePageMessage: "message", + // The ID for a specific editorial item, in the case of a subscribe page. + editorialItem: "editorialItem", + // The identifer for the ATB request. + askToBuyId: "askToBuyId", + // Indicates an ID, when the 'app' disambiguation is necessary. + appId: "appId", + // Whether the URL has been launched from a PPT (Purple Performance Test). + isPPT: "isPPT", + // How the shelf is sorted, represented by a value of `ArcadeSeeAllGamesPageSort` + sort: "sort", + // Featured Content ID + grouping: "grouping", + // Code Parameter, e.g. for Redeem code + code: "code", + // Parameter to include attribution on offer action for post subcribge + includePostSubscribeAttribution: "includePostSubscribeAttribution", + // Campaign Token + campaignToken: "ct", + // Provider Token + providerToken: "pt", + // Q Token + qToken: "its_qt", + // Advertisement ID + advertisementId: "adId", + // The token used to pass arbitrary data in a url + token: "token", + // The current parse context for the a page + parseContext: "parseContext", + // An ID for a privacy type + privacyTypeId: "privacyTypeId", + // The token used to pass arbitrary data in a url + requestDescriptor: "requestDescriptor", + // Page Facet + ageRating: "ageRating", + // Page Facet + controllerSupport: "controllerSupport", + // Page Facet + multiplayerSupport: "multiplayerSupport", + // Page Facet + comingSoon: "comingSoon", + // Page Facet + binCompatGames: "binCompatGames", + // Page Facet + gamePreviews: "gamePreviews", + // Upsell (marketing item) marketing hint + offerHints: "offerHints", + // Indicates that a 204 network error should invalidate the App Store's widgets. + invalidateWidgetsOnFailure: "invalidateWidgetsOnFailure", + // Metrics + metrics: "metrics", + // App event ID + appEventId: "eventid", + // Offer Item ID + offerItemId: "offerItemId", + // App event deep link + appEventDeepLink: "deepLink", + // The use case param for collection deeplinking + useCaseShort: "uc", + // The collection id param for collection deeplinking + collectionId: "collection-id", + // The seed id param for collection deeplinking + seedId: "seed-id", + // Whether the shelf is the product page similar items shelf. + isShelfWithAd: "isShelfWithAd", + // The ad placement type for the shelf. Only used if `isShelfWithAd` is true. + shelfWithAdPlacementType: "shelfWithAdPlacementType", + // Provides a refresh type to route a refresh request for a shelf. + // See `refreshUrl` on `Shelf`. + shelfRefreshType: "refreshType", + // Param to denote that this url originated for preloading purposes. + isPreloading: "isPreloading", + // The name parameter for editorial pages with known names + name: "name", + // The editorial page shelf type + shelfType: "shelfType", + // The id of the shelf in a url + shelfId: "shelfId", + // Parameter for the onboarding cards for the today tab + onbaordingCardIds: "onboardingCardIds", + // Parameter for the today card previews to provide a future date and time + preview: "preview", + // The card config for used for the card on a today page + todayCardConfig: "todayCardConfig", + // The parameter that is expanded into the header used for today previews. + experimentId: "experimentId", + shortEditorialNotes: "shortEditorialNotes", + // User subscription status defined by Mercury and passed to Arcade download pack onboarding. + // It is used to select the right copy variant. + arcadeSubscriptionStatus: "subscriptionStatus", + // Used to indicate a web browser is being displayed in the web browser context via App Store Components. + webBrowser: "webBrowser", + // The id of the editorial-page that was used to create a url + editorialPageId: "editorialPageId", + // A filter ID to add to a editorial item request in order to fetch a certain version of the story. + editorialCardId: "filter[canvas:cardId]", + // A filter to add to the hydration call for the Today tab recommended candidates to fetch only recommendable apps. + filterRecommendable: "filter[recommendable]", + // A device family, used for accessibility labels + deviceFamily: "deviceFamily", +}; +// Install Page-specific parameters +export const InAppPurchaseInstallPageParameters = { + // The adamId for the IAP. + inAppPurchaseId: "inAppPurchaseId", +}; +// Product Page-specific parameters +export const ProductPageParameters = { + // Product URL + url: "productUrl", + // Whether an iAP is a subscription. + isSubscription: "isSubscription", + // The minimum version of the app to display + // Typically used to prevent older cached versions being displayed + // when deep-linking from an app clip. + minExternalVersionId: "minExternalVersionId", +}; +// Review Page-specific parameters +export const ReviewsPageParameters = { + // Product adamId + adamId: "adamId", + // Sort index for the reviews request + sort: "sort", +}; +export const MSOPageParameters = { + // Ids of available apps. + availableAdamIds: "availableAdamIds", +}; +export const ShelfParameters = { + // Shelf Title + title: "shelfTitle", + // Whether the shelf should auto-configure a see-all on fetch + shouldInferSeeAllFromFetchedItems: "shelfShouldInferSeeAllFromFetchedItems", + // Shelf content type + contentType: "shelfContentType", + // Shelf offer them + offerTheme: "shelfOfferTheme", + // metrics page information + metricsPageInformation: "metricsPage", +}; +export const ShareURLParameters = { + // Which client should be the link be opened with + clientSpecifier: "app", +}; +export const Hashes = { + // Reviews action anchor (#reviews) + reviews: "reviews", +}; +export const ShelfRefreshType = { + productPageSimilarItems: "productPageSimilarItems", +}; +/* tslint:enable:variable-name */ +//# sourceMappingURL=url-constants.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/network/urls.js b/node_modules/@jet-app/app-store/tmp/src/foundation/network/urls.js new file mode 100644 index 0000000..6abbd37 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/network/urls.js @@ -0,0 +1,382 @@ +/** + * Created by keithpk on 12/2/16. + */ +import { isNothing } from "@jet/environment/types/optional"; +const protocolRegex = /^([a-z][a-z0-9.+-]*:)(\/\/)?([\S\s]*)/i; +const queryParamRegex = /([^=?&]+)=?([^&]*)/g; +const componentOrder = ["hash", "query", "pathname", "host"]; +function splitUrlComponent(input, marker, style) { + const index = input.indexOf(marker); + let result; + let remainder = input; + if (index !== -1) { + const prefix = input.slice(0, index); + const suffix = input.slice(index + marker.length, input.length); + if (style === "prefix") { + result = prefix; + remainder = suffix; + } + else { + result = suffix; + remainder = prefix; + } + } + // log("Token: " + marker + " String: " + input, " Result: " + result + " Remainder: " + remainder) + return { + result: result, + remainder: remainder, + }; +} +export class URL { + constructor(url) { + this.query = {}; + if (!url) { + return; + } + // Split the protocol from the rest of the urls + let remainder = url; + const match = protocolRegex.exec(url); + if (match) { + // Pull out the protocol + let protocol = match[1]; + if (protocol) { + protocol = protocol.split(":")[0]; + } + this.protocol = protocol; + // Save the remainder + remainder = match[3]; + } + // Then match each component in a specific order + let parse = { remainder: remainder, result: undefined }; + for (const component of componentOrder) { + if (!parse.remainder) { + break; + } + switch (component) { + case "hash": { + parse = splitUrlComponent(parse.remainder, "#", "suffix"); + this.hash = parse.result; + break; + } + case "query": { + parse = splitUrlComponent(parse.remainder, "?", "suffix"); + if (parse.result) { + this.query = URL.queryFromString(parse.result); + } + break; + } + case "pathname": { + parse = splitUrlComponent(parse.remainder, "/", "suffix"); + if (parse.result) { + // Replace the initial /, since paths require it + this.pathname = "/" + parse.result; + } + break; + } + case "host": { + if (parse.remainder) { + const authorityParse = splitUrlComponent(parse.remainder, "@", "prefix"); + const userInfo = authorityParse.result; + const hostPort = authorityParse.remainder; + if (userInfo) { + const userInfoSplit = userInfo.split(":"); + this.username = decodeURIComponent(userInfoSplit[0]); + this.password = decodeURIComponent(userInfoSplit[1]); + } + if (hostPort) { + const hostPortSplit = hostPort.split(":"); + this.host = hostPortSplit[0]; + this.port = hostPortSplit[1]; + } + } + break; + } + default: { + throw new Error("Unhandled case!"); + } + } + } + } + set(component, value) { + if (!value) { + return this; + } + if (component === "query") { + if (typeof value === "string") { + value = URL.queryFromString(value); + } + } + switch (component) { + // Exhaustive match to make sure TS property minifiers and other + // transformer plugins do not break this code. + case "protocol": + this.protocol = value; + break; + case "username": + this.username = value; + break; + case "password": + this.password = value; + break; + case "port": + this.port = value; + break; + case "pathname": + this.pathname = value; + break; + case "query": + this.query = value; + break; + case "hash": + this.hash = value; + break; + default: + // The fallback for component which is not a property of URL object. + this[component] = value; + break; + } + return this; + } + get(component) { + switch (component) { + // Exhaustive match to make sure TS property minifiers and other + // transformer plugins do not break this code. + case "protocol": + return this.protocol; + case "username": + return this.username; + case "password": + return this.password; + case "port": + return this.port; + case "pathname": + return this.pathname; + case "query": + return this.query; + case "hash": + return this.hash; + default: + // The fallback for component which is not a property of URL object. + return this[component]; + } + } + append(component, value) { + const existingValue = this.get(component); + let newValue; + if (component === "query") { + if (typeof value === "string") { + value = URL.queryFromString(value); + } + if (typeof existingValue === "string") { + newValue = { existingValue, ...value }; + } + else { + newValue = { ...existingValue, ...value }; + } + } + else { + let existingValueString = existingValue; + if (!existingValueString) { + existingValueString = ""; + } + let newValueString = existingValueString; + if (component === "pathname") { + const pathLength = existingValueString.length; + if (!pathLength || existingValueString[pathLength - 1] !== "/") { + newValueString += "/"; + } + } + // eslint-disable-next-line @typescript-eslint/restrict-plus-operands, @typescript-eslint/no-base-to-string + newValueString += value; + newValue = newValueString; + } + return this.set(component, newValue); + } + param(key, value) { + if (!key) { + return this; + } + if (!this.query) { + this.query = {}; + } + this.query[key] = value; + return this; + } + removeParam(key) { + if (!key || !this.query) { + return this; + } + if (this.query[key] !== undefined) { + delete this.query[key]; + } + return this; + } + /** + * Push a new string value onto the path for this url + * @returns URL this object with the updated path. + */ + path(value) { + return this.append("pathname", value); + } + pathExtension() { + var _a; + // Extract path extension if one exists + if (isNothing(this.pathname)) { + return null; + } + const lastFilenameComponents = (_a = this.pathname + .split("/") + .filter((item) => item.length > 0) // Remove any double or trailing slashes + .pop()) === null || _a === void 0 ? void 0 : _a.split("."); + if (lastFilenameComponents === undefined) { + return null; + } + if (lastFilenameComponents.filter((part) => { + return part !== ""; + }).length < 2 // Remove any empty parts (e.g. .ssh_config -> ["ssh_config"]) + ) { + return null; + } + return lastFilenameComponents.pop(); + } + /** + * Returns the path components of the URL + * @returns An array of non-empty path components from `urls`. + */ + pathComponents() { + if (!this.pathname) { + return []; + } + return this.pathname.split("/").filter((component) => component.length > 0); + } + /** + * Returns the last path component from this url, updating the url to not include this path component + * @returns String the last path component from this url. + */ + popPathComponent() { + if (!this.pathname) { + return null; + } + const lastPathComponent = this.pathname.slice(this.pathname.lastIndexOf("/") + 1); + if (lastPathComponent.length === 0) { + return null; + } + this.pathname = this.pathname.slice(0, this.pathname.lastIndexOf("/")); + return lastPathComponent; + } + /** + * Same as toString + * + * @returns {string} A string representation of the URL + */ + build() { + return this.toString(); + } + /** + * Converts the URL to a string + * + * @returns {string} A string representation of the URL + */ + toString() { + let url = ""; + if (this.protocol) { + url += this.protocol + "://"; + } + if (this.username) { + url += encodeURIComponent(this.username); + if (this.password) { + url += ":" + encodeURIComponent(this.password); + } + url += "@"; + } + if (this.host) { + url += this.host; + if (this.port) { + url += ":" + this.port; + } + } + if (this.pathname) { + url += this.pathname; + /// Trim off trailing path separators when we have a valid path + /// We don't do this unless pathname has elements otherwise we will trim the `://` + if (url.endsWith("/") && this.pathname.length > 0) { + url = url.slice(0, -1); + } + } + if (this.query && Object.keys(this.query).length) { + url += "?" + URL.toQueryString(this.query); + } + if (this.hash) { + url += "#" + this.hash; + } + return url; + } + // ---------------- + // Static API + // ---------------- + /** + * Converts a string into a query dictionary + * @param query The string to parse + * @returns The query dictionary containing the key-value pairs in the query string + */ + static queryFromString(query) { + const result = {}; + let parseResult = queryParamRegex.exec(query); + while (parseResult) { + const key = decodeURIComponent(parseResult[1]); + const value = decodeURIComponent(parseResult[2]); + result[key] = value; + parseResult = queryParamRegex.exec(query); + } + return result; + } + /** + * Converts a query dictionary into a query string + * + * @param query The query dictionary + * @returns {string} The string representation of the query dictionary + */ + static toQueryString(query) { + let queryString = ""; + let first = true; + for (const key of Object.keys(query)) { + if (!first) { + queryString += "&"; + } + first = false; + queryString += encodeURIComponent(key); + const value = query[key]; + if (value && value.length) { + queryString += "=" + encodeURIComponent(value); + } + } + return queryString; + } + /** + * Convenience method to instantiate a URL from a string + * @param url The URL string to parse + * @returns {URL} The new URL object representing the URL + */ + static from(url) { + return new URL(url); + } + /** + * Convenience method to instantiate a URL from numerous (optional) components + * @param protocol The protocol type + * @param host The host name + * @param path The path + * @param query The query + * @param hash The hash + * @returns {URL} The new URL object representing the URL + */ + static fromComponents(protocol, host, path, query, hash) { + const url = new URL(); + url.protocol = protocol; + url.host = host; + url.pathname = path; + url.query = query; + url.hash = hash; + return url; + } +} +//# sourceMappingURL=urls.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/routing/routing-components.js b/node_modules/@jet-app/app-store/tmp/src/foundation/routing/routing-components.js new file mode 100644 index 0000000..28fdc48 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/routing/routing-components.js @@ -0,0 +1,318 @@ +/** + * Created by km on 11/16/16. + */ +import * as urls from "../network/urls"; +import * as urlUtil from "./url-util"; +// endregion +// region private URLRule helpers. +/** + * Checks whether or not a given _pathComponents component contains a parameter. + * @param pathComponent The _pathComponents component to check. + * @returns true if the _pathComponents component is surrounded by curly braces; false otherwise. + */ +function isPathComponentParameter(pathComponent) { + const parameterStartIndex = pathComponent.indexOf("{"); + const parameterEndIndex = pathComponent.indexOf("}"); + return parameterStartIndex >= 0 && parameterEndIndex > parameterStartIndex + 1; +} +/** + * Extracts the parameter contained in a _pathComponents component. + * @param pathComponent A _pathComponents component surrounded by curly braces. + * @returns The parameter contained in the component. + */ +function getPathComponentParameter(pathComponent) { + const parameterStartIndex = pathComponent.indexOf("{"); + const parameterEndIndex = pathComponent.indexOf("}"); + const pathHasRequiredCurlyBraces = parameterStartIndex >= 0 && parameterEndIndex > parameterStartIndex; + return pathHasRequiredCurlyBraces + ? pathComponent.substring(parameterStartIndex + 1, parameterEndIndex) + : pathComponent; +} +/** + * Extracts the value from a path component, for a given internal key example: + * Path Component: "id123456" + * Internal Key: "id{id}" + * Return Value: "123456" + * @param pathComponent A _pathComponents component surrounded by curly braces. + * @returns The parameter contained in the component. + */ +export function getPathComponentParameterValueUsingInternalKey(pathComponent, internalKey) { + const valueStartIndex = internalKey.indexOf("{"); + const valueEndIndex = pathComponent.length - (internalKey.length - (internalKey.indexOf("}") + 1)); + const pathHasRequiredCurlyBraces = valueStartIndex >= 0 && valueEndIndex > valueStartIndex; + return pathHasRequiredCurlyBraces ? pathComponent.substring(valueStartIndex, valueEndIndex) : pathComponent; +} +/** + * Creates a mapping from key to _pathComponents component index + * for efficiently extracting parameters from a _pathComponents. + * @param rulePath The _pathComponents to create a mapping for. + * @returns A map of keys to _pathComponents component indexes. + */ +function makePathParameterMapping(rulePath) { + const mapping = {}; + rulePath.forEach((ruleComponent, index) => { + if (isPathComponentParameter(ruleComponent)) { + mapping[ruleComponent] = index; + } + }); + return mapping; +} +/** + * Normalizes a given protocol string for matching. + * @param protocol The protocol to match against. + * @returns The `protocol` with colon added if needed. + */ +function normalizeProtocol(protocol) { + // An empty string is falsy. + if (protocol === null || protocol === undefined) { + return null; + } + return protocol; +} +/** + * Creates `UrlRouteQuery` objects from substring of url. + * ? = optional + * -caseInsensitive = case insensitive + * @param parameters strings of form `<key>[?][-i]=<value>`. + * @returns Array of `UrlRouteQuery` objects. + */ +function parseQuery(parameters) { + const parsedQuery = []; + if (!parameters) { + return parsedQuery; + } + for (const param of parameters) { + const parts = param.split("="); + let key = parts[0]; + const optional = key.indexOf("?") !== -1; + key = key.replace("?", ""); + const caseInsensitive = key.indexOf("-caseInsensitive") !== -1; + key = key.replace("-caseInsensitive", ""); + let value = null; + if (parts.length > 1) { + value = decodeURIComponent(parts[1]); + } + parsedQuery.push({ + key, + value, + optional, + caseInsensitive, + }); + } + return parsedQuery; +} +// endregion +// region Url Rule +/** + * The `UrlRule` class extracts the pattern format from `UrlRuleDefinition`s, and encapsulates + * the information needed to match against a candidate URL and extract parameters from it. + * + * The terminology here is: + * - rule: A specific url pattern. + * - route: A group of rules that together form a single route, i.e. UrlRule[]. + */ +export class UrlRule { + /** + * Construct the route with all required properties. + * @param rule The rule to match. + */ + constructor(rule) { + this.identifier = rule.identifier; + this._protocol = normalizeProtocol(rule.protocol); + this._hostName = rule.hostName; + if (rule.path) { + this._pathComponents = rule.path.split("/").filter((component) => component.length > 0); + this._pathParameterMap = makePathParameterMapping(this._pathComponents); + } + else { + this._pathComponents = null; + this._pathParameterMap = null; + } + this._pathExtension = rule.pathExtension; + this._query = parseQuery(rule.query); + this._hash = rule.hash; + this._regex = rule.regex; + if (rule.exclusions) { + this._exclusions = rule.exclusions.map(function (ex) { + return new UrlRule(ex); + }); + } + else { + this._exclusions = null; + } + } + /** + * Checks whether or not the route matches a given URL. + * @param url The URL to check against. + * @returns true if the route matches `urls`; false otherwise. + */ + matches(url) { + var _a, _b; + if (this._regex) { + if (!this._regex.length) { + // If the rule specifies regex but does not supply patterns, we need to return false. Otherwise, we will + // risk matching against everything. This is because an empty regex with no other rule parameters will + // cause us to fallthrough to the end and match against all URLs. + return false; + } + let didMatchRegex = false; + for (const regexPattern of this._regex) { + if (regexPattern.test(url.toString())) { + // If we match against any of regex patterns, then we should proceed. + // If no matches are found, then this rule is not matched. + didMatchRegex = true; + break; + } + } + if (!didMatchRegex) { + return false; + } + } + if (this._protocol && url.protocol !== this._protocol) { + return false; + } + if (this._hostName && url.host !== this._hostName) { + return false; + } + if (this._pathComponents) { + const rulePathComponents = this._pathComponents; + const urlPathComponents = url.pathComponents(); + if (rulePathComponents.length !== urlPathComponents.length) { + return false; + } + // We're iterating two arrays here, an old style for-loop is appropriate + const length = rulePathComponents.length; + for (let i = 0; i < length; i++) { + const ruleComponent = rulePathComponents[i]; + if (isPathComponentParameter(ruleComponent)) { + // component parameters always match + continue; + } + const urlComponent = urlPathComponents[i]; + if (ruleComponent !== urlComponent) { + return false; + } + } + } + if (this._pathExtension) { + if (url.pathExtension() !== this._pathExtension) { + return false; + } + } + if (this._query) { + for (const param of this._query) { + let value; + if (param.caseInsensitive) { + for (const [queryKey, queryValue] of Object.entries((_a = url.query) !== null && _a !== void 0 ? _a : {})) { + if (param.key.toLocaleLowerCase() === queryKey.toLocaleLowerCase()) { + value = queryValue; + } + } + } + else { + value = (_b = url.query) === null || _b === void 0 ? void 0 : _b[param.key]; + } + if (!value && !param.optional) { + return false; + } + if (param.value && param.value !== value) { + return false; + } + } + } + if (this._hash && url.hash !== this._hash) { + return false; + } + if (this._exclusions) { + for (const exclusionRule of this._exclusions) { + if (exclusionRule._exclusions) { + throw Error("Matching exclusion rules with further exclusion rules may introduce significant code-complexity and/or reduce the ease with which developers are able to reason about your desired goals. Are there any simpler options?"); + } + if (exclusionRule.matches(url)) { + return false; + } + } + } + return true; + } + /** + * Extract information from a matching url. + * @param matchingUrl The url to extract parameters from. + * @returns `Parameters` extracted from `matchingUrl` + * @note This function is only valid when `this.matches(matchingUrl) === true`. + */ + extractParameters(matchingUrl) { + var _a, _b; + const parameters = {}; + if (this._pathComponents !== null && this._pathParameterMap !== null) { + const urlPathComponents = matchingUrl.pathComponents(); + for (const internalKey of Object.keys(this._pathParameterMap)) { + const externalKey = getPathComponentParameter(internalKey); + const index = this._pathParameterMap[internalKey]; + const parameterValue = getPathComponentParameterValueUsingInternalKey(urlPathComponents[index], internalKey); + parameters[externalKey] = decodeURIComponent(parameterValue); + } + } + if (this._query) { + for (const param of this._query) { + parameters[param.key] = (_b = (_a = matchingUrl.query) === null || _a === void 0 ? void 0 : _a[param.key]) !== null && _b !== void 0 ? _b : undefined; + } + } + return parameters; + } +} +/** + * `UrlRouter` manages a set of url rule templates to allow `urls` to serve as keys for different associated objects (like Builders). + * + * @note This is replaces old `UrlRouter` as a synchronous way match route URLs to handlers. In contrast to the previous implementation, + * it maps entire objects (containing related async handlers and properties) to urls. + */ +export class UrlRouter { + /// Constructs an empty URL router object. + constructor() { + this._routeMappings = []; + } + /** + * Register a new route defined by a set of definitions and object on the router. + * @param routeDefinitions The definitions of rules to register. + * @param object The object for the rule. + */ + associate(routeDefinitions, object) { + const route = []; + for (const definition of routeDefinitions) { + route.push(new UrlRule(definition)); + } + this._routeMappings.push({ route: route, object: object }); + } + /** + * Resolve given url to associated object, if any exist. + * @param urlOrString URL or string representation of url to resolve objects for. + * @returns `UrlRouterResult` containing url, extracted parameters, and associated object, or `null` if no match was found. + */ + routedObjectForUrl(urlOrString) { + let url = typeof urlOrString === "string" ? new urls.URL(urlOrString) : urlOrString; + url = urlUtil.normalizedAppStoreUrl(url); + url = urlUtil.normalizedActionUrl(url); + for (const mapping of this._routeMappings) { + for (const rule of mapping.route) { + if (rule.matches(url)) { + return { + normalizedUrl: url, + parameters: rule.extractParameters(url), + object: mapping.object, + matchedRuleIdentifier: rule.identifier, + }; + } + } + } + // No match. Still return a result with normalized url. + return { + normalizedUrl: url, + parameters: null, + object: null, + matchedRuleIdentifier: null, + }; + } +} +// endregion +//# sourceMappingURL=routing-components.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/action-provider.js b/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/action-provider.js new file mode 100644 index 0000000..e0038da --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/action-provider.js @@ -0,0 +1,13 @@ +import { isBaseActionProvider } from "@jet/environment/dispatching"; +/** + * Retrieve an {@linkcode ActionModel} for the given {@linkcode intent} through + * any registered `IntentController`s that implement `ActionProvider` + */ +export function actionFor(intent, objectGraph, options = {}) { + const resolvedController = objectGraph.dispatcher.controller(intent); + if (isBaseActionProvider(resolvedController)) { + return resolvedController.actionFor(intent, objectGraph, options); + } + return null; +} +//# sourceMappingURL=action-provider.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/app-store-intent-dispatcher.js b/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/app-store-intent-dispatcher.js new file mode 100644 index 0000000..0a88ada --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/app-store-intent-dispatcher.js @@ -0,0 +1,62 @@ +import { IntentDispatcher } from "@jet/environment/dispatching"; +import { ExperimentCache } from "../experimentation/experiment-cache"; +import { MetricsIdentifiersCache, MetricsIdentifierType, paymentIdentifierContextMapping, personalizationIdentifierContextMapping, } from "../metrics/metrics-identifiers-cache"; +import { AppStoreObjectGraph } from "./app-store-object-graph"; +export class AppStoreIntentDispatcher { + constructor() { + this.dispatcher = new IntentDispatcher(); + } + // MARK: - IBaseIntentDispatcher + register(controller) { + this.dispatcher.register(controller); + } + async dispatch(intent, objectGraph) { + const intentObjectGraph = await this.createIntentObjectGraphWithAsyncValues(objectGraph); + return await this.dispatcher.dispatch(intent, intentObjectGraph); + } + controller(intent) { + return this.dispatcher.controller(intent); + } + get registeredControllers() { + return this.dispatcher.registeredControllers; + } + async createIntentObjectGraphWithAsyncValues(objectGraph) { + const experimentCache = new ExperimentCache(); + const metricsIdentifiersCache = new MetricsIdentifiersCache(); + const personalizationMetricsIdentifierCache = new MetricsIdentifiersCache(personalizationIdentifierContextMapping); + let paymentMetricsIdentifiersCache; + // Doing these in sequence to help minimize the liklihood of hitting the treatment store locking timeout + // rdar://147518835 (AppStore Ad Regression Performance - Metrics Identifier blocking network requests) + if (objectGraph instanceof AppStoreObjectGraph) { + let appStoreObjectGraph = objectGraph; + // reassigning the bag creates a fresh cache + appStoreObjectGraph = appStoreObjectGraph.addingBag(appStoreObjectGraph.bag.underlyingBag); + await experimentCache.loadTreatments(appStoreObjectGraph); + await metricsIdentifiersCache.loadValues(appStoreObjectGraph, [ + MetricsIdentifierType.client, + MetricsIdentifierType.user, + ]); + // Only load the values if the namespace is in the bag + if (objectGraph.bag.personalizationUserIdEnabled) { + await personalizationMetricsIdentifierCache.loadValues(objectGraph, [MetricsIdentifierType.user]); + } + // The payment topic uses a different metrics identifier cache as it has a separate namespace. + if (appStoreObjectGraph.props.enabled("paymentTopicFromBag") && + appStoreObjectGraph.bag.metricsPaymentNamespaceEnabled) { + paymentMetricsIdentifiersCache = new MetricsIdentifiersCache(paymentIdentifierContextMapping); + // Only add this promise if paymentMetricsIdentifiersCache is actually created + await paymentMetricsIdentifiersCache.loadValues(appStoreObjectGraph, [ + MetricsIdentifierType.client, + MetricsIdentifierType.user, + ]); + } + objectGraph = appStoreObjectGraph; + } + return objectGraph + .adding(ExperimentCache.metatype, experimentCache) + .adding(MetricsIdentifiersCache.defaultMetatype, metricsIdentifiersCache) + .adding(MetricsIdentifiersCache.paymentMetatype, paymentMetricsIdentifiersCache || metricsIdentifiersCache) + .adding(MetricsIdentifiersCache.personalizationMetatype, personalizationMetricsIdentifierCache); + } +} +//# sourceMappingURL=app-store-intent-dispatcher.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/app-store-object-graph.js b/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/app-store-object-graph.js new file mode 100644 index 0000000..a5102b2 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/app-store-object-graph.js @@ -0,0 +1,380 @@ +import { ObjectGraph } from "@jet/environment/dependencies"; +import { fetchTimingMetricsBuilderType, } from "@jet/environment/metrics/fetch-timing-metrics-builder"; +import * as jetTypes from "@jet/environment/types/globals/types"; +import * as askTypes from "../../api/typings/constants"; +import { isDefinedNonNull } from "../json-parsing/server-data"; +import { AppleSiliconWrapper } from "../wrappers/apple-silicon"; +import { BagWrapper } from "../wrappers/bag"; +import { ClientWrapper } from "../wrappers/client"; +import { ClientOrderingWrapper } from "../wrappers/client-ordering"; +import { ConsoleWrapper } from "../wrappers/console"; +import { HostWrapper } from "../wrappers/host"; +import { LocalizationWrapper } from "../wrappers/localization"; +import { PropertiesWrapper } from "../wrappers/properties"; +import { StorageWrapper } from "../wrappers/storage"; +import { ExperimentCache } from "../experimentation/experiment-cache"; +import { MetricsIdentifiersCache } from "../metrics/metrics-identifiers-cache"; +import { LocaleMetaType } from "../dependencies/locale/locale"; +import { SEOMetaType } from "../dependencies/seo"; +import { ActiveIntentMetaType, ActiveIntent } from "../dependencies/active-intent"; +import { LocaleFromBag } from "../dependencies/locale/locale-from-bag"; +import { ObjectGraphType } from "../../gameservicesui/src/foundation/object-graph-types"; +export class AppStoreObjectGraph extends ObjectGraph { + configureDefaults( + // Jet Types + aBag, aCryptography, aHost, aNetwork, aPlatform, aPlist, aRandom, aServices, aCookieProvider, aConsole, + // Ask Types + aStoreMetrics, aAMSEngagement, aLocalization, aAdsLocalizer, aDevice, aClient, aProperties, aUser, aPlayer, aMetricsIdentifiers, aClientOrdering, aArcade, aGameCenter, aResilientDeepLinks, aAppleSilicon, aStorage, aAds, aOnDeviceRecommendationsManager, aOnDeviceSearchHistoryManager, aFeatureFlags, aMediaToken, aAppDistribution, timeoutManager, treatmentStore, userDefaults) { + let objectGraph = this + // Jet Types + .addingCryptography(aCryptography) + .addingHost(aHost) + .addingNetwork(aNetwork) + .addingPlatform(aPlatform) + .addingPlist(aPlist) + .addingRandom(aRandom) + .addingServices(aServices) + .addingCookieProvider(aCookieProvider) + .addingBag(aBag) // Bag depends on having Host + .addingConsole(aConsole) + // ASK types + .addingStoreMetrics(aStoreMetrics) + .addingAMSEngagement(aAMSEngagement) + .addingLoc(aLocalization) + .addingAdsLoc(aAdsLocalizer) + .addingDevice(aDevice) + .addingClient(aClient) + .addingProperties(aProperties) + .addingUser(aUser) + .addingPlayer(aPlayer) + .addingMetricsIdentifiers(aMetricsIdentifiers) + .addingClientOrdering(aClientOrdering) + .addingArcade(aArcade) + .addingGameCenter(aGameCenter) + .addingDeepLinks(aResilientDeepLinks) + .addingAppleSilicon(aAppleSilicon) + .addingStorage(aStorage) + .addingAds(aAds) + .addingOnDeviceRecommendationsManager(aOnDeviceRecommendationsManager) + .addingOnDeviceSearchHistoryManager(aOnDeviceSearchHistoryManager) + .addingFeatureFlags(aFeatureFlags) + .addingMediaToken(aMediaToken) + .addingAppDistribution(aAppDistribution) + .addingTimeoutManager(timeoutManager) + .addingAdsLoc(aAdsLocalizer) + .addingTreatmentStore(treatmentStore) + .addingUserDefaults(userDefaults); + objectGraph.loc.load(objectGraph); + // `LocaleFromBag` requires that the `bag` is already present on the Object Graph + objectGraph = objectGraph.addingLocale(new LocaleFromBag(objectGraph)); + return objectGraph; + } + // Jet Types + get bag() { + return this.required(BagWrapper.type); + } + addingBag(bag) { + return this.addingBagWrapper(new BagWrapper(bag, this.host)).adding(jetTypes.bag, bag); + } + addingBagWrapper(bag) { + return this.adding(BagWrapper.type, bag); + } + get console() { + return this.required(ConsoleWrapper.type); + } + addingConsole(console) { + return this.addingConsoleWrapper(new ConsoleWrapper(console)); + } + addingConsoleWrapper(console) { + return this.adding(ConsoleWrapper.type, console); + } + get cryptography() { + return this.required(jetTypes.cryptography); + } + addingCryptography(cryptography) { + return this.adding(jetTypes.cryptography, cryptography); + } + get host() { + return this.required(HostWrapper.type); + } + addingHost(host) { + return this.addingHostWrapper(new HostWrapper(host)); + } + addingHostWrapper(host) { + return this.adding(HostWrapper.type, host); + } + get locale() { + return this.required(LocaleMetaType); + } + addingLocale(locale) { + return this.adding(LocaleMetaType, locale); + } + get network() { + return this.required(jetTypes.net); + } + addingNetwork(network) { + return this.adding(jetTypes.net, network); + } + get platform() { + return this.required(jetTypes.platform); + } + addingPlatform(platform) { + return this.adding(jetTypes.platform, platform); + } + get plist() { + return this.required(jetTypes.plist); + } + addingPlist(plist) { + return this.adding(jetTypes.plist, plist); + } + get random() { + return this.required(jetTypes.random); + } + addingRandom(random) { + return this.adding(jetTypes.random, random); + } + get services() { + return this.required(jetTypes.services); + } + addingServices(services) { + return this.adding(jetTypes.services, services); + } + get cookieProvider() { + return this.required(jetTypes.cookieProvider); + } + addingCookieProvider(cookieProvider) { + return this.adding(jetTypes.cookieProvider, cookieProvider); + } + get fetchTimingMetricsBuilder() { + return this.optional(fetchTimingMetricsBuilderType); + } + addingFetchTimingMetricsBuilder(fetchTimingMetricsBuilder) { + return this.adding(fetchTimingMetricsBuilderType, fetchTimingMetricsBuilder); + } + // Ask Types + get storeMetrics() { + return this.required(askTypes.storeMetrics); + } + addingStoreMetrics(storeMetrics) { + return this.adding(askTypes.storeMetrics, storeMetrics); + } + get amsEngagement() { + return this.optional(askTypes.amsEngagement); + } + addingAMSEngagement(amsEngagement) { + return this.adding(askTypes.amsEngagement, amsEngagement); + } + get loc() { + return this.required(LocalizationWrapper.type); + } + addingLoc(loc) { + return this.addingLocWrapper(new LocalizationWrapper(loc, this)); + } + addingLocWrapper(loc) { + return this.adding(LocalizationWrapper.type, loc); + } + get adsLoc() { + return this.required(askTypes.adsLocalizer); + } + addingAdsLoc(loc) { + return this.adding(askTypes.adsLocalizer, loc); + } + get device() { + return this.required(askTypes.device); + } + addingDevice(device) { + return this.adding(askTypes.device, device); + } + get client() { + return this.required(ClientWrapper.type); + } + addingClient(client) { + return this.addingClientWrapper(new ClientWrapper(client)); + } + addingClientWrapper(client) { + return this.adding(ClientWrapper.type, client); + } + get props() { + return this.required(PropertiesWrapper.type); + } + addingProperties(properties) { + return this.addingPropertiesWrapper(new PropertiesWrapper(properties)); + } + addingPropertiesWrapper(properties) { + return this.adding(PropertiesWrapper.type, properties); + } + get user() { + return this.required(askTypes.user); + } + addingUser(user) { + return this.adding(askTypes.user, user); + } + /// Returns the current GameCenter player, only available for GAMES_TARGET + get player() { + if (preprocessor.GAMES_TARGET && this.props.enabled("157263806-add-playerBridge-askGlobal")) { + return this.required(askTypes.player); + } + else { + return undefined; + } + } + addingPlayer(player) { + return this.adding(askTypes.player, player); + } + get metricsIdentifiers() { + return this.required(askTypes.metricsIdentifiers); + } + addingMetricsIdentifiers(metricsIdentifiers) { + return this.adding(askTypes.metricsIdentifiers, metricsIdentifiers); + } + get clientOrdering() { + return this.required(ClientOrderingWrapper.type); + } + addingClientOrdering(clientOrdering) { + return this.addingClientOrderingWrapper(new ClientOrderingWrapper(clientOrdering)); + } + addingClientOrderingWrapper(clientOrdering) { + return this.adding(ClientOrderingWrapper.type, clientOrdering); + } + get arcade() { + return this.required(askTypes.arcade); + } + addingArcade(arcade) { + return this.adding(askTypes.arcade, arcade); + } + get gameCenter() { + return this.required(askTypes.gameCenter); + } + addingGameCenter(gameCenter) { + return this.adding(askTypes.gameCenter, gameCenter); + } + get deepLinks() { + return this.required(askTypes.resilientDeepLinks); + } + addingDeepLinks(resilientDeepLinks) { + return this.adding(askTypes.resilientDeepLinks, resilientDeepLinks); + } + get appleSilicon() { + return this.required(AppleSiliconWrapper.type); + } + addingAppleSilicon(appleSilicon) { + return this.addingAppleSiliconWrapper(new AppleSiliconWrapper(appleSilicon)); + } + addingAppleSiliconWrapper(appleSilicon) { + return this.adding(AppleSiliconWrapper.type, appleSilicon); + } + get storage() { + return this.required(StorageWrapper.type); + } + addingStorage(storage) { + return this.addingStorageWrapper(new StorageWrapper(storage)); + } + addingStorageWrapper(storage) { + return this.adding(StorageWrapper.type, storage); + } + get ads() { + return this.required(askTypes.ads); + } + addingAds(ads) { + return this.adding(askTypes.ads, ads); + } + get onDeviceRecommendationsManager() { + return this.required(askTypes.onDeviceRecommendationsManager); + } + addingOnDeviceRecommendationsManager(onDeviceRecommendationsManager) { + return this.adding(askTypes.onDeviceRecommendationsManager, onDeviceRecommendationsManager); + } + get onDeviceSearchHistoryManager() { + return this.required(askTypes.onDeviceSearchHistoryManager); + } + addingOnDeviceSearchHistoryManager(onDeviceSearchHistoryManager) { + return this.adding(askTypes.onDeviceSearchHistoryManager, onDeviceSearchHistoryManager); + } + get featureFlags() { + return this.required(askTypes.featureFlags); + } + addingFeatureFlags(featureFlags) { + return this.adding(askTypes.featureFlags, featureFlags); + } + get mediaToken() { + return this.required(askTypes.mediaToken); + } + addingMediaToken(mediaToken) { + return this.adding(askTypes.mediaToken, mediaToken); + } + get appDistribution() { + return this.required(askTypes.appDistribution); + } + addingAppDistribution(appDistribution) { + return this.adding(askTypes.appDistribution, appDistribution); + } + get timeoutManager() { + return this.required(askTypes.timeoutManager); + } + addingTimeoutManager(timeoutManager) { + return this.adding(askTypes.timeoutManager, timeoutManager); + } + get treatmentStore() { + return this.required(askTypes.treatmentStore); + } + addingTreatmentStore(treatmentStore) { + return this.adding(askTypes.treatmentStore, treatmentStore); + } + get experimentCache() { + return this.optional(ExperimentCache.metatype); + } + get metricsIdentifiersCache() { + return this.optional(MetricsIdentifiersCache.defaultMetatype); + } + get paymentMetricsIdentifiersCache() { + return this.optional(MetricsIdentifiersCache.paymentMetatype); + } + get personalizationMetricsIdentifiersCache() { + return this.optional(MetricsIdentifiersCache.personalizationMetatype); + } + get userDefaults() { + if (!this.client.isiOS) { + return undefined; + } + return this.required(askTypes.userDefaults); + } + addingUserDefaults(userDefaults) { + return this.adding(askTypes.userDefaults, userDefaults); + } + isAvailable(type) { + return isDefinedNonNull(this.optional(type)); + } + // "Web" client dependencies + get activeIntent() { + return this.optional(ActiveIntentMetaType); + } + addingActiveIntent(implementation) { + return this.adding(ActiveIntentMetaType, new ActiveIntent(implementation)); + } + get seo() { + return this.optional(SEOMetaType); + } + addingSEO(implementation) { + return this.adding(SEOMetaType, implementation); + } + // GameStoreKit dependencies + get dispatcher() { + return this.required(ObjectGraphType.dispatcher); + } + get nativeIntentDispatcher() { + return this.required(ObjectGraphType.nativeIntentDispatcher); + } + get debugSettings() { + return this.required(ObjectGraphType.debugSettings); + } + get router() { + return this.required(ObjectGraphType.router); + } + get localizer() { + return this.required(ObjectGraphType.localizer); + } + get personNameComponentsFormatter() { + return this.required(ObjectGraphType.personNameComponentsFormatter); + } +} +//# sourceMappingURL=app-store-object-graph.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/runtime.js b/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/runtime.js new file mode 100644 index 0000000..d3b5904 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/runtime/runtime.js @@ -0,0 +1,52 @@ +import * as validation from "@jet/environment/json/validation"; +import { LegacyRuntime } from "@jet/environment/runtime"; +export class AppStoreRuntime extends LegacyRuntime { + constructor(dispatcher, objectGraph) { + super(dispatcher, objectGraph, {}); + } + exportingService(name, service) { + this.wrapServiceInValidation(service); + const existingService = this.serviceWithName(name) || {}; + const newService = { + ...existingService, + ...service, + }; + return super.exportingService(name, newService); + } + // eslint-disable-next-line @typescript-eslint/ban-types + exportingServiceName(name, functionName, implementation) { + const service = {}; + service[functionName] = implementation; + this.exportingService(name, service); + } + wrapServiceInValidation(service) { + for (const memberName of Object.keys(service)) { + const serviceFunction = service[memberName]; + // For every service route function that we find, we're going + // to wrap it in a thunk so that we can attach validation + // incidents to it before it's returned back to native code. + if (serviceFunction instanceof Function) { + // Using a regular function here because we want to forward + // `this` as well as our arguments to the wrapped function. + service[memberName] = function validationThunk(...args) { + // Execute the function + const returnValue = serviceFunction.apply(this, args); + // Ensure we record validation incidents after the fact + if (returnValue instanceof Promise) { + return returnValue.then((value) => { + validation.recordValidationIncidents(value); + return value; + }); + } + else { + // This would be a violation of the calling convention, + // but I guess we might as well consume the incidents. + validation.recordValidationIncidents(returnValue); + return returnValue; + } + }; + } + } + } +} +//# sourceMappingURL=runtime.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/util/array-util.js b/node_modules/@jet-app/app-store/tmp/src/foundation/util/array-util.js new file mode 100644 index 0000000..57c8e84 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/util/array-util.js @@ -0,0 +1,32 @@ +/** + * Creates an array containing multiple copies of the elements of another array. + * + * For example, if A = [Q, W, E, R, T, Y], then calling repeating(A, 3) would return + * [Q, W, E, R, T, Y, Q, W, E, R, T, Y, Q, W, E, R, T, Y] + * + * @param elements The elements that will be repeated + * @param times The number of times all of the elements should appear in the new array. + */ +export function arrayByRepeating(elements, times) { + if (times <= 0) { + return []; + } + let newArray = []; + for (let i = 0; i < times; i++) { + newArray = newArray.concat(elements); + } + return newArray; +} +export function partition(array, predicate) { + const part1 = []; + const part2 = []; + array.forEach((item) => (predicate(item) ? part1.push(item) : part2.push(item))); + return [part1, part2]; +} +export function isEmpty(elements) { + return elements.length === 0; +} +export function isNotEmpty(elements) { + return !isEmpty(elements); +} +//# sourceMappingURL=array-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/util/color-util.js b/node_modules/@jet-app/app-store/tmp/src/foundation/util/color-util.js new file mode 100644 index 0000000..84e3815 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/util/color-util.js @@ -0,0 +1,231 @@ +import { isNothing, isSome } from "@jet/environment/types/optional"; +const HEX_PARSER = new RegExp("#?([0-9,a-f,A-F][0-9,a-f,A-F])([0-9,a-f,A-F][0-9,a-f,A-F])([0-9,a-f,A-F][0-9,a-f,A-F])([0-9,a-f,A-F][0-9,a-f,A-F])?"); +export function fromHex(hexString) { + if (isNothing(hexString) || hexString === "") { + return null; + } + const results = HEX_PARSER.exec(hexString); + if (results === null || !(results.length === 4 || results.length === 5)) { + return null; + } + const red = parseInt(results[1], 16) / 255; + const green = parseInt(results[2], 16) / 255; + const blue = parseInt(results[3], 16) / 255; + const alpha = isSome(results[4]) ? parseInt(results[4], 16) / 255 : undefined; + const newColor = { + red: red, + green: green, + blue: blue, + alpha: alpha, + type: "rgb", + }; + return newColor; +} +export const black = rgbWith(0, 0, 0); +export const white = rgbWith(1, 1, 1); +export function rgbWith(red, green, blue, alpha) { + const newColor = { + red: red, + green: green, + blue: blue, + alpha: alpha, + type: "rgb", + }; + return newColor; +} +export function luminanceFrom(rgbColor) { + // Note: This is lifted from UIColor_Private + // Using RGB color components, calculates and returns (0.2126 * r) + (0.7152 * g) + (0.0722 * b). + return rgbColor.red * 0.2126 + rgbColor.green * 0.7152 + rgbColor.blue * 0.0722; +} +/** + * Determines whether the given color is considered dark. + * @param color The color to test. + * @param darkColorCutoff The cutoff value, which ought to be between 0 and 100. + */ +export function isDarkColor(color, darkColorCutoff = 84) { + if (isNothing(color)) { + return false; + } + switch (color.type) { + case "rgb": + // Multiplying 100 because the rest of the codebase now works off darkColorCutoff 0-100. + // Before this change it used to be darkColorCutoff 0.0-1.0 + return luminanceFrom(color) * 100 < darkColorCutoff; + case "named": + return isNamedColorDarkColor(color); + default: + return false; + } +} +function isNamedColorDarkColor(namedColor) { + switch (namedColor.name) { + case "black": + return true; + default: + return false; + } +} +export function named(name) { + const newColor = { + name: name, + type: "named", + }; + return newColor; +} +export function dynamicWith(lightColor, darkColor) { + const newColor = { + lightColor: lightColor, + darkColor: darkColor, + type: "dynamic", + }; + return newColor; +} +/** + * A convenience for comparing two colors to see if they are equal. + * @param firstColor The first color to compare + * @param secondColor The second color to compare + * @returns True if the colors are considered equal + */ +export function isColorEqualToColor(firstColor, secondColor) { + if (isNothing(firstColor) || isNothing(secondColor)) { + return false; + } + if (firstColor.type === "rgb" && secondColor.type === "rgb") { + return (firstColor.red === secondColor.red && + firstColor.green === secondColor.green && + firstColor.blue === secondColor.blue && + firstColor.alpha === secondColor.alpha); + } + else if (firstColor.type === "named" && secondColor.type === "named") { + return firstColor.name === secondColor.name; + } + else if (firstColor.type === "dynamic" && secondColor.type === "dynamic") { + return (isColorEqualToColor(firstColor.lightColor, secondColor.lightColor) && + isColorEqualToColor(firstColor.darkColor, secondColor.darkColor)); + } + return false; +} +/** + * Type guard to check if a value is a ColorBucketSaturationBrightnessCriteria. + * @param value The value to check. + * @returns True if the value is a ColorBucketSaturationBrightnessCriteria, false otherwise. + */ +function isSaturationBrightnessCriteria(value) { + if (typeof value !== "object" || value === null) { + return false; + } + const obj = value; // Cast for easier property access + // Check if all required properties exist and have the correct types + return ("colorHex" in obj && + typeof obj.colorHex === "string" && + "maxSaturation" in obj && + typeof obj.maxSaturation === "number" && + "maxBrightness" in obj && + typeof obj.maxBrightness === "number"); +} +/** + * Finds the closest matching color from a list of hex colors using LAB color space + * for more perceptually accurate matching + */ +export function findColorBucketForColor(targetRGB, saturationBrightnessBasedBuckets, hueBasedBuckets) { + if (isNothing(targetRGB) || (saturationBrightnessBasedBuckets.length === 0 && hueBasedBuckets.length === 0)) { + return null; + } + const targetColor = targetRGB; + if (isNothing(targetColor)) { + return null; + } + const targetHsb = rgbToHsb(targetColor); + for (const saturationBrightnessBasedBucket of saturationBrightnessBasedBuckets) { + if (doesColorMeetCriteria(targetHsb, saturationBrightnessBasedBucket)) { + return fromHex(saturationBrightnessBasedBucket.colorHex); + } + } + for (const hueBasedBucket of hueBasedBuckets) { + if (doesColorMeetCriteria(targetHsb, hueBasedBucket)) { + return fromHex(hueBasedBucket.colorHex); + } + } + return null; +} +/** + * Determines whether a color meets the specified criteria. + * + * For saturation/brightness criteria, the color passes if either its saturation or brightness + * is less than or equal to the maximum allowed values. + * + * For hue criteria, the color passes if its hue falls within the specified range (inclusive). + * + * @param color The RGB color to evaluate + * @param criteria The criteria to check against (either hue-based or saturation/brightness-based) + * @returns True if the color passes the criteria, false otherwise or if color is null/undefined + */ +export function doesColorMeetCriteria(color, criteria) { + if (isNothing(color)) { + return false; + } + const hsbColor = isHSBColor(color) ? color : rgbToHsb(color); + // Check saturation / brightness buckets first, using <= for inclusive range checks + if (isSaturationBrightnessCriteria(criteria)) { + return hsbColor.saturation <= criteria.maxSaturation || hsbColor.brightness <= criteria.maxBrightness; + } + else { + // Check if the hue falls within the min/max bounds (inclusive) + // Special handling for the Pink range potentially including 360 if needed, + // but mapping 360->0 covers the Coral case correctly. + return hsbColor.hue >= criteria.minHue && hsbColor.hue <= criteria.maxHue; + } +} +function isHSBColor(value) { + if (typeof value !== "object" || value === null) { + return false; + } + const obj = value; // Cast for easier property access + // Check if the type property exists and has the correct value + return "type" in obj && obj.type === "hsb"; +} +/** + * Converts RGB color to HSB color space. + * HSL is particularly good at representing relationships between colors + * as humans perceive them, especially for determining similar hues + * across different brightness levels. + */ +function rgbToHsb(rgb) { + const r = rgb.red; + const g = rgb.green; + const b = rgb.blue; + const max = Math.max(r, g, b); + const min = Math.min(r, g, b); + const delta = max - min; + // Calculate brightness (value in HSV) + const brightness = max * 100; + // Calculate saturation + const saturation = max === 0 ? 0 : (delta / max) * 100; + // Calculate hue + let hue = 0; + if (delta !== 0) { + switch (max) { + case r: + hue = ((g - b) / delta + (g < b ? 6 : 0)) * 60; + break; + case g: + hue = ((b - r) / delta + 2) * 60; + break; + case b: + hue = ((r - g) / delta + 4) * 60; + break; + default: + break; + } + } + // Ensure hue is in [0, 360) + hue = (hue + 360) % 360; + return { + type: "hsb", + hue: hue, + saturation: saturation, + brightness: brightness, + }; +} +//# sourceMappingURL=color-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/util/constants.js b/node_modules/@jet-app/app-store/tmp/src/foundation/util/constants.js new file mode 100644 index 0000000..86522d5 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/util/constants.js @@ -0,0 +1,26 @@ +/** + * Created by keithpk on 2/9/17. + */ +/** + * These are the developer IDs for apps that Apple works on internally + * The IDs in the list below are CPIDs (content provider IDs), which are not exposed + * to the client. So, we use the developer.id field that we have available instead. + * Note that Dark Sky both the same developer ID as Apple Inc. + * 2003 Apple Inc + * 120076162 Apple Health Research + * 244848 The Dark Sky Company LLC + * 115216 Claris International Inc. + * 14275 Shazam Entertainment Limited + * 118988565 AC Wellness Network LLC + */ +export const appleOwnedDeveloperIds = [ + "284417353", + "1464590764", + "314638464", + "284993479", + "1351056256", // AC Wellness Network LLC +]; +export const iAdRequestDataHeaderName = "X-Apple-iAd-Request-Data"; +export const appStoreClientRequestIdName = "X-Apple-App-Store-Client-Request-Id"; +export const iAdRoutingInfoHeaderName = "X-Apple-iAd-Env-Name"; +//# sourceMappingURL=constants.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/util/date-util.js b/node_modules/@jet-app/app-store/tmp/src/foundation/util/date-util.js new file mode 100644 index 0000000..182dd63 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/util/date-util.js @@ -0,0 +1,127 @@ +// +// date.ts +// AppStoreKit +// +// Created by Sam Vafaee on 10/25/17. +// Copyright (c) 2017 Apple Inc. All rights reserved. +// +import * as serverData from "../json-parsing/server-data"; +/** + * Returns the date representation for a string ignoring the time. For preorders, it + * is vital that any date string be passed through this before being used. + * @param dateString The date string to parse + * @returns A date in local time zone. + */ +export function parseDateOmittingTimeFromString(dateString) { + // Sanity check + if (serverData.isNull(dateString) || dateString === "") { + return null; + } + // Only consider date + if (dateString.indexOf("T") !== -1) { + dateString = dateString.split("T")[0]; + } + // This string replacement is needed to ensure midnight in the local time zone + // is used, rather than UTC-midnight. + return new Date(dateString.replace(/-/g, "/")); +} +/** + * Strips time from the given date and returns it as midnight UTC of the same day. + * @param date Local date. + * @returns UTC date + */ +export function convertLocalDateToUTCMidnight(date) { + // Sanity check + if (serverData.isNull(date)) { + return null; + } + return new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate())); +} +/** + * Returns the number of milliseconds from epoch to UTC midnight of the given date. + * @param date Local date. + * @returns Milliseconds from epoch. + */ +export function millisecondsToUTCMidnightFromLocalDate(date) { + // Sanity check + if (serverData.isNull(date)) { + return null; + } + const utcDate = convertLocalDateToUTCMidnight(date); + if (serverData.isNull(utcDate)) { + return null; + } + return utcDate.getTime(); +} +/** + * Removes the time portion from the given date and returns it as midnight of the same day. + * @param date Local date + * @returns Local date + */ +export function convertLocalDateToLocalMidnight(date) { + // Sanity check + if (serverData.isNull(date)) { + return null; + } + const midnight = new Date(date); + midnight.setHours(0, 0, 0, 0); + return midnight; +} +/** + * Sets the minutes, seconds and milliseconds of the given date to 0. + * @param date Local date + * @returns Local date + */ +export function convertLocalDateByFlooringToHour(date) { + // Sanity check + if (serverData.isNull(date)) { + return null; + } + return dateFlooredToHour(date); +} +/** + * Creates a new date with the minutes, seconds and milliseconds of the given date set to 0. + * @param date The date to remove minutes, seconds, and milliseconds from. + * @returns The new date with minutes, seconds, and milliseconds removed using local device time zone. + */ +export function dateFlooredToHour(date) { + const dateCopy = new Date(date.getTime()); + dateCopy.setMinutes(0); + dateCopy.setSeconds(0); + dateCopy.setMilliseconds(0); + return dateCopy; +} +/** + * Returns the number of hours between two dates, or null if either date is null. + * @param fromDate The date to calculate from. + * @param toDate The date to calculate to. + */ +export function numberOfHoursBetween(fromDate, toDate) { + // Sanity check + if (serverData.isNull(fromDate) || serverData.isNull(toDate)) { + return null; + } + return Math.ceil((toDate.getTime() - dateFlooredToHour(fromDate).getTime()) / (60 * 60 * 1000)); +} +/** + * Returns the number of days between two dates, or null if either date is null. + * @param fromDate The date to calculate from. + * @param toDate The date to calculate to. + */ +export function numberOfDaysBetween(fromDate, toDate) { + // Sanity check + if (serverData.isNull(fromDate) || serverData.isNull(toDate)) { + return null; + } + return Math.floor((toDate.getTime() - fromDate.getTime()) / (60 * 60 * 1000 * 24)); +} +/** + * Whether or not two dates occur on the same day. + * @param date A date that will be compared to the second input. + * @param otherDate A date that will be compared to the first input. + */ +export function areLocalDatesSameDay(date, otherDate) { + var _a, _b; + return ((_a = convertLocalDateToLocalMidnight(date)) === null || _a === void 0 ? void 0 : _a.getTime()) === ((_b = convertLocalDateToLocalMidnight(otherDate)) === null || _b === void 0 ? void 0 : _b.getTime()); +} +//# sourceMappingURL=date-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/util/errors.js b/node_modules/@jet-app/app-store/tmp/src/foundation/util/errors.js new file mode 100644 index 0000000..d1a3482 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/util/errors.js @@ -0,0 +1,13 @@ +/** + * Created by Ben Williams on 3/13/19. + */ +/** + * Enables compile time detection for code that should be unreachable + * For example, calling this function in the default case of a switch statement + * will provide compile time checking that the switch is exhaustive + * @return never + */ +export function unreachable(value) { + throw new Error(`This method should never be called with value: ${value}`); +} +//# sourceMappingURL=errors.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/util/math-util.js b/node_modules/@jet-app/app-store/tmp/src/foundation/util/math-util.js new file mode 100644 index 0000000..92b4992 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/util/math-util.js @@ -0,0 +1,32 @@ +/** + * Given an integer m > 1, called a modulus, two integers are said to be congruent modulo m, + * if m is a divisor of their difference (i.e., if there is an integer k such that a \u2212 b = km). + * + * Unlike JavaScript's remainder operator (%), this mod function never returns negative values. + * + * @param n An integer + * @param m The modulous + */ +export function mod(n, m) { + return ((n % m) + m) % m; +} +/** + * Reduce sig fig of `value` to `significantDigits`. + * @param value Value to reduce precision of. + * @param significantDigits Significant digits to keep. + */ +export function reduceSignificantDigits(value, significantDigits) { + const roundFactor = Math.pow(10.0, significantDigits); + const roundingFunction = value > 0.0 ? Math.floor : Math.ceil; + return roundingFunction(value / roundFactor) * roundFactor; +} +/** + * Clamps a value between an upper and lower bound. + * @param value The preferred value. + * @param min The minimum allowed value. + * @param max The maximum allowed value. + */ +export function clamp(value, min, max) { + return Math.max(min, Math.min(max, value)); +} +//# sourceMappingURL=math-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/util/objects.js b/node_modules/@jet-app/app-store/tmp/src/foundation/util/objects.js new file mode 100644 index 0000000..6740572 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/util/objects.js @@ -0,0 +1,33 @@ +/* eslint-disable @typescript-eslint/no-explicit-any */ +/** + * Created by km on 3/6/17. + */ +/** + * Creates and returns a shallow copy of a given object. + * @param object The object to create a shallow copy of. + * @returns The new copy of object. + */ +export function shallowCopyOf(object) { + if (object === null || object === undefined) { + return object; + } + const copy = Object.create(Object.getPrototypeOf(object)); + Object.assign(copy, object); + return copy; +} +/** + * Returns whether or not a given object is an instance of + * a specified type, modifying the type of the object in + * TypeScript's type system. + * + * Prefer this function to using `instanceof` directly as it + * will retype the passed in object if the check succeeds. + * + * @param object The object whose nominal type will be checked. + * @param type The metatype that `object` is expected to be an instance of. + * @returns Whether object is an instance of type, updating the type of object accordingly. + */ +export function isTypeOf(object, type) { + return object instanceof type; +} +//# sourceMappingURL=objects.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/util/promise-util.js b/node_modules/@jet-app/app-store/tmp/src/foundation/util/promise-util.js new file mode 100644 index 0000000..d661559 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/util/promise-util.js @@ -0,0 +1,215 @@ +/** + * This module provides enhanced promise handling capabilities beyond native JavaScript Promises. + * It focuses on distinguishing between required and optional promises, standardizing results, + * and simplifying error handling for complex async operations. + */ +/** + * Symbol used to uniquely identify PromiseResult objects. + * This allows for reliable type checking. + */ +export const PROMISE_RESULT_SYMBOL = Symbol("PromiseResult"); +/** + * Type guard to check if a value is a PromiseResult. + * + * @param value - The value to check + * @returns True if the value is a PromiseResult, false otherwise + */ +function isPromiseResult(value) { + return value !== null && typeof value === "object" && PROMISE_RESULT_SYMBOL in value; +} +/** + * Custom error class that aggregates multiple promise failures. + * Provides access to all underlying errors while presenting a combined error message. + */ +export class MultiPromiseError extends Error { + constructor(reasons) { + super(errorMessageForReasons(reasons)); + this.reasons = reasons; + this.reasons = reasons; + } +} +/** + * Helper function to create a standardized fulfilled result object. + * Ensures the result has the PROMISE_RESULT_SYMBOL for type checking. + * + * @param value - The value to wrap in a fulfilled result + * @returns A standardized fulfilled result object + */ +export function makeFulfilledResult(value) { + return { + success: true, + value, + error: null, + [PROMISE_RESULT_SYMBOL]: true, + }; +} +/** + * Helper function to create a standardized rejected result object. + * Ensures the result has the PROMISE_RESULT_SYMBOL for type checking. + * + * @param error - The error to wrap in a rejected result + * @returns A standardized rejected result object + */ +export function makeRejectedResult(error) { + const normalizedError = error instanceof Error ? error : new Error(String(error)); + return { + success: false, + value: null, + error: normalizedError, + [PROMISE_RESULT_SYMBOL]: true, + }; +} +/** + * Custom error class that indicates that a required promise failed. + */ +export class RequiredPromiseError extends Error { + constructor(reason) { + super(reason.message); + this.reason = reason; + this.reason = reason; + } +} +/** + * Transforms a promise into one that never throws, instead returning a standardized result. + * Use this for optional operations that shouldn't cause the overall process to fail. + * This is a convenience alias for tryAwait with a more semantic name. + * + * @param promise - The promise to make optional + * @returns A promise that resolves to a PromiseResult instead of throwing + */ +export async function optional(promise) { + return await tryAwait(promise); +} +/** + * Marks a promise as required (will throw on rejection). + * This is mainly for code clarity as regular promises are already required by default. + * + * @param promise - The promise to mark as required + * @returns The original promise (identity function) + */ +export async function required(promise) { + return await promise; +} +/** + * Executes a mix of required and optional promises, returning standardized results. + * Regular promises are treated as required and will cause this function to throw if they fail. + * Promises wrapped with optional() will never cause this function to throw. + * + * This implementation handles both regular promises and promises that resolve to PromiseResult. + * + * @param promises - Array of promises (both required and optional) + * @returns Promise resolving to an array of standardized results + * @throws Original error if a single required promise fails + * @throws MultiPromiseError if multiple required promises fail + * @note For homogeneous promise arrays, prefer using more specific functions: + * - Use allRequired() when all promises should be treated as required + * - Use allOptional() when all promises should be treated as optional + * - Only use allMixed() when you need to combine both required and optional promises + */ +export async function allMixed(promises) { + // Process each promise + const results = await Promise.all(promises.map(async (promise) => { + try { + const value = await promise; + // If it's a PromiseResult (from optional()/tryAwait), use it directly + if (isPromiseResult(value)) { + // Handle the case where T is already a PromiseResult + // This fixes the double-wrapping issue when all promises are optional + return value; + } + else { + // It's a regular promise that succeeded + return makeFulfilledResult(value); + } + } + catch (error) { + // This was a required promise that failed + return makeRejectedResult(error instanceof Error ? error : new Error(String(error))); + } + })); + const requiredFailures = []; + results.forEach((result) => { + if (!result.success) { + requiredFailures.push(result.error); + } + }); + // If any required promises failed, throw an error + if (requiredFailures.length > 0) { + if (requiredFailures.length === 1) { + throw requiredFailures[0]; + } + else { + throw new MultiPromiseError(requiredFailures); + } + } + return results; +} +/** + * Executes all promises and returns their values. + * All promises are treated as required and will cause this function to throw if any fail. + * + * @param promises - Array of promises + * @returns Promise resolving to an array of values + * @throws Original error if a single promise fails + * @throws MultiPromiseError if multiple promises fail + */ +export async function allRequired(promises) { + return await Promise.all(promises); +} +/** + * Makes all promises optional and then executes them, returning standardized results. + * This function is specifically designed for cases where you want all promises to be treated as optional. + * It avoids the double-wrapping issue that can occur when using allMixed with arrays of optional promises. + * + * @param promises - Array of promises to make optional + * @returns Promise resolving to an array of standardized results + * @example + * ``` + * const promises = urls.map(fetchData); + * const results = await allOptional(promises); + * // Each result is a PromiseResult<T> that won't cause the overall operation to fail + * ``` + */ +export async function allOptional(promises) { + // Use Promise.all with optional() for each promise + return await Promise.all(promises.map(optional)); +} +/** + * Creates an error message from multiple rejection reasons. + * Formats multiple error reasons into a single error message string, + * handling both Error objects and other rejection values. + * + * @param reasons - Array of error reasons that caused promise rejections + * @returns Concatenated error message string + */ +function errorMessageForReasons(reasons) { + return reasons + .map((reason) => { + if (reason instanceof Error) { + return reason.message; + } + else { + return JSON.stringify(reason); + } + }) + .join(""); +} +/** + * Safely awaits a promise and returns a standardized result object. + * Eliminates the need for repetitive try/catch blocks throughout the codebase. + * + * @param promiseOrFn - Either a promise or a function that returns a promise + * @returns A standardized PromiseResult object indicating success or failure + */ +export async function tryAwait(promiseOrFn) { + try { + // Handle both promise and function that returns a promise + const promise = typeof promiseOrFn === "function" ? promiseOrFn() : promiseOrFn; + const value = await promise; + return makeFulfilledResult(value); + } + catch (error) { + return makeRejectedResult(error); + } +} +//# sourceMappingURL=promise-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/util/string-util.js b/node_modules/@jet-app/app-store/tmp/src/foundation/util/string-util.js new file mode 100644 index 0000000..affeba3 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/util/string-util.js @@ -0,0 +1,127 @@ +/** + * Created by dabolfathi on 4/26/17. + */ +/** + * Returns a single string, which is the result of joining together all + * the strings in the list with the provided separator. + * @param strings The list of strings to be joined. + * @param separator The separator to use when joining them together. + * @returns {string} The joined string. + */ +export function join(strings, separator) { + if (strings == null || separator == null) { + return null; + } + if (strings.length === 0) { + return ""; + } + let stringCount = strings.length; + let joinedString = ""; + strings.forEach((element, index) => { + if (element === null) { + stringCount -= 1; + } + else { + joinedString += element; + if (index < stringCount - 1) { + joinedString += separator; + } + } + }); + return joinedString; +} +/** + * Generate a normalized string for robust multilingual search that properly handles + * CJK (Chinese, Japanese, Korean), Arabic, Cyrillic, and Latin-based scripts. + * Preserves Unicode characters while normalizing diacritics and case appropriately. + * + * @param input The input string to normalize + * @returns A normalized string suitable for search matching + */ +export function normalizeForSearch(input) { + if (!input) { + return ""; + } + try { + // Remove special characters + // \u2122 -> (Trade Mark Sign) + // \u2120 -> (Service Mark) + // \u03a9 -> (Greek Capital Letter Omega) + // \u00a9 -> (Copyright Sign) + // \u00ae -> (Registered Sign) + // \u30fc -> (Katakana-Hiragana Prolonged Sound Mark) + // \u03c9 -> (Greek Small Letter Omega) + const removedSpecialUnicodesRegex = /[\u2122\u2120\u03a9\u00a9\u00ae\u30fc\u03c9]/g; + return (input + .toLowerCase() // Case insensitivity + .replace(removedSpecialUnicodesRegex, "") + // Apply normalization only to Latin characters to preserve CJK integrity + // Handle Latin characters safely with basic ranges A-Za-z + // \u00C0-\u00FF - Latin-1 Supplement (Upper Half) + // \u0100-\u017F - Latin Extended-A (includes dotless i \u0131) + // \u0180-\u024F - Latin Extended-B + // \u1E00-\u1EFF - Latin Extended Additional + .replace(/[A-Za-z\u00A0-\u00FF\u0100-\u017F\u0180-\u024F\u1E00-\u1EFF\p{Diacritic}]+/gu, (latinText) => { + return (latinText + .normalize("NFKD") + .replace(/\p{Diacritic}/gu, "") + // Convert specific characters that don't match basic Latin + .replace(/\u0131/g, "i") // Convert dotless i to regular i + // Keep only actual Latin characters and numbers after normalization + .replace(/[^A-Za-z0-9]/g, "")); + }) + // Remove punctuation, symbols, and control characters but preserve: + // - Letters from all writing systems (\p{L}) + // - Numbers (\p{N}) + // - Whitespace (\s) + // - Underscores (_) + .replace(/[^\p{L}\p{N}\s_]/gu, "") + // Normalize multiple whitespace to single spaces + .replace(/\s+/g, " ") + // Trim leading/trailing whitespace + .trim()); + } + catch (error) { + // Fallback: use basic character classes + return (input + .toLowerCase() + // Remove punctuation, symbols, and control characters but preserve: + // - Letters from all writing systems (\p{L}) + // - Numbers (\p{N}) + // - Whitespace (\s) + // - Underscores (_) + .replace(/[^\p{L}\p{N}\s_]/gu, "") + // Normalize multiple whitespace to single spaces + .replace(/\s+/g, " ") + // Trim leading/trailing whitespace + .trim()); + } +} +/** + * Whether or not the input string is contains search term using normalized string which comparing using case insensitive, locale insensitive and ignore all special characters. + * + * @param input + * @param normalizedTerm + * @returns + */ +export function containsSearchTerm(input, normalizedTerm) { + const normalizedInput = normalizeForSearch(input); + return normalizedInput.includes(normalizedTerm); +} +/** + * Wraps a string with bidirectional isolate characters to ensure proper text direction handling. + * This is particularly useful for user-generated content like display names that may contain + * mixed left-to-right and right-to-left text. + * + * @param text The string to wrap with bidi isolates + * @returns The string wrapped with Left-to-Right Isolate (U+2066) and Pop Directional Isolate (U+2069) + */ +export function withBidiIsolates(text) { + if (!text) { + return text; + } + // U+2068: First Strong Isolate + // U+2069: Pop Directional Isolate + return "\u2068" + text + "\u2069"; +} +//# sourceMappingURL=string-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/util/validation-util.js b/node_modules/@jet-app/app-store/tmp/src/foundation/util/validation-util.js new file mode 100644 index 0000000..fe9bd93 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/util/validation-util.js @@ -0,0 +1,30 @@ +import { isSome } from "@jet/environment"; +import * as validation from "@jet/environment/json/validation"; +import { tryAwait } from "./promise-util"; +/** + * Creates a validation context for async operations and ensures proper cleanup. + * + * Wraps an async operation in a validation context, automatically handling + * context cleanup even when errors occur. Optionally processes errors through + * a provided error handler. + * + * @param name - The name for the validation context + * @param producer - Async function that produces the result + * @param errorHandler - Optional function to handle errors from the producer + * @returns The result of the async operation + */ +export async function withAsyncValidationContext(name, producer, errorHandler) { + validation.beginContext(name); + let result = await tryAwait(producer()); + if (!result.success && isSome(errorHandler)) { + result = await tryAwait(errorHandler(result.error)); + } + validation.endContext(); + if (!result.success) { + throw result.error; + } + else { + return result.value; + } +} +//# sourceMappingURL=validation-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/apple-silicon.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/apple-silicon.js new file mode 100644 index 0000000..4371e77 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/apple-silicon.js @@ -0,0 +1,13 @@ +import { makeMetatype } from "@jet/environment/util/metatype"; +import * as serverData from "../../foundation/json-parsing/server-data"; +import { Wrapper } from "./wrapper"; +export class AppleSiliconWrapper extends Wrapper { + get isSupportEnabled() { + return serverData.isDefinedNonNull(this.implementation) && this.implementation.isSupportEnabled; + } + get isRosettaAvailable() { + return serverData.isDefinedNonNull(this.implementation) && this.implementation.isRosettaAvailable; + } +} +AppleSiliconWrapper.type = makeMetatype("app-store:as-wrapper"); +//# sourceMappingURL=apple-silicon.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/bag.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/bag.js new file mode 100644 index 0000000..ad76b76 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/bag.js @@ -0,0 +1,1126 @@ +/** + * Created by km on 1/9/17. + */ +import { isSome } from "@jet/environment"; +import { makeMetatype } from "@jet/environment/util/metatype"; +import * as serverData from "../json-parsing/server-data"; +import { Wrapper } from "./wrapper"; +import { CachedBag } from "./cached-bag"; +export class BagWrapper extends Wrapper { + constructor(bag, host) { + super(new CachedBag(bag)); + this.underlyingBag = bag; + } + /// The boolean for whether today ad medium lockup screenshots are enabled + get todayAdMediumLockupScreenshotEnabled() { + var _a; + return (_a = this.implementation.boolean("today-ad-medium-lockup-screenshots-enabled")) !== null && _a !== void 0 ? _a : false; + } + get todayAdMediumLockupScreenshotAnimationEnabled() { + var _a; + return (_a = this.implementation.boolean("today-ad-medium-lockup-screenshots-animation-enabled")) !== null && _a !== void 0 ? _a : true; + } + /// The URL for the trending searches endpoint. + get trendingSearchesURL() { + return this.implementation.url("trending-searches"); + } + /// The URL for the search hints endpoint. + get searchHintsURL() { + return this.implementation.url("searchHints"); + } + /// The URL for fetching a personalized review + get personalizedUserReviewURL() { + return this.implementation.url("personalizedUserReviewUrl"); + } + /// The boolean for whether personalized reviews are enabled + get personalizedUserReviewEnabled() { + return this.implementation.boolean("personalizedUserReviewEnabled"); + } + /// The URL for posting tap-to-rate requests. + get userRateURL() { + return this.implementation.url("p2-application-user-rate-content"); + } + /// The URL for posting write review requests. + get writeReviewURL() { + return this.implementation.url("p2-application-user-write-review"); + } + /// The base URL for accessory rooms + get accessoryRoomURL() { + return this.implementation.url("p2-accessory-room"); + } + /// The URL for passbook main room + get passbookMainURL() { + return this.implementation.url("passbook"); + } + /// The URL for library-link room + get libraryLinkURL() { + return this.implementation.url("library-link"); + } + /// The metrics configuration for mt-metrics kit integration + get metricsConfiguration() { + return serverData.asJSONData(this.implementation.dictionary("metrics")); + } + // When the metrics payment topic is enabled the clientId and userId are on a separate namespace. + get metricsPaymentNamespaceEnabled() { + if (serverData.isNullOrEmpty(this.metricsPaymentTopic)) { + return false; + } + const identifiers = serverData.asJSONData(this.implementation.dictionary("metrics-identifiers")); + const metricsNameSpace = serverData.asDictionary(identifiers, "APPSTORE_PAYMENTS_ENGAGEMENT"); + const metricsClientIdSpace = serverData.asDictionary(identifiers, "APPSTORE_PAYMENTS_ENGAGEMENT_CLIENT"); + return (isSome(metricsNameSpace) && + metricsNameSpace.length !== 0 && + isSome(metricsClientIdSpace) && + metricsClientIdSpace.length !== 0); + } + // The Payment topic if one is provided by the bag. Otherwise the default one will be used + get metricsPaymentTopic() { + var _a, _b; + if (preprocessor.GAMES_TARGET) { + return (_a = serverData.asString(this.metricsConfiguration, "topics.GAMES_PAYMENTS_ENGAGEMENT_TOPIC")) !== null && _a !== void 0 ? _a : null; + } + else { + return (_b = serverData.asString(this.metricsConfiguration, "topics.APPSTORE_PAYMENTS_ENGAGEMENT_TOPIC")) !== null && _b !== void 0 ? _b : null; + } + } + // Whether the personalization user id has been inlcuded in the metrics identifiers bag entry + get personalizationUserIdEnabled() { + const identifiers = serverData.asJSONData(this.implementation.dictionary("metrics-identifiers")); + const personalizationIdNameSpace = serverData.asDictionary(identifiers, "APPSTORE_PERSONALIZATION"); + return isSome(personalizationIdNameSpace) && Object.keys(personalizationIdNameSpace).length !== 0; + } + /// The language for the users storefront + get language() { + return this.implementation.string("language"); + } + /// The language for media API + get mediaApiLanguage() { + const languageTag = this.implementation.string("language-tag"); + if (languageTag) { + return languageTag; + } + return this.implementation.string("language"); + } + /// The URL for terms and conditions page + get termsAndConditionsURL() { + return this.implementation.url("p2-service-terms-url"); + } + /// whether we should send iAd data as a post request + get usePostForAppStoreSearch() { + return this.implementation.boolean("usePostForAppStoreSearch"); + } + /// Whether or not monetary gifting is enabled. + get isMonetaryGiftingEnabled() { + return this.implementation.boolean("isBuyingScheduledGiftCertificateEnabled"); + } + /// The URL for Account Top-Up in the finance sheet. + get accountTopUpURL() { + return this.implementation.url("AddFundsUrl"); + } + /// The title for Account Top-Up in the finance sheet. + get accountTopUpTitle() { + return this.implementation.string("account-top-up-title"); + } + /// Whether or not content gifting is enabled. + get isContentGiftingEnabled() { + return this.implementation.boolean("isScheduledGiftingEnabled"); + } + /// The URL for buy button metadata. + get buyButtonMetadataURL() { + return this.implementation.url("personalized-buy-buttons/software"); + } + /// Whether or not the current storefront supports the TV App. + get isTVAppEnabled() { + return this.implementation.boolean("uvSearch/nowplaying-enabled"); + } + /// the url to send people to to email support + get emailSupportLinkURL() { + return this.implementation.url("supportLinkUrl"); + } + /// The URL to report a review item helpful or not. + get voteUrl() { + return this.implementation.url("voteUrl"); + } + /// Enables the Review Summary module + get enableReviewSummarization() { + return this.implementation.boolean("enable-review-summarization"); + } + /// Provides configuration for Review Summary Report A Concern + get reviewSummaryReportConcernData() { + return serverData.asJSONData(this.implementation.dictionary("review-summarization-report-concern")); + } + /// The URL to report a concern about a review item. + get reportConcernUrl() { + return this.implementation.url("reportConcernUrl"); + } + /// The explanation for the report a concern screen for a review. + get reportConcernExplanation() { + return this.implementation.string("reportConcernExplanation"); + } + /// An array of reasons for reporting a concern for a review. + get reportConcernReasons() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("reportConcernReasons"))); + } + /// The boolean that enables report a problem. + get reportProblemEnabled() { + var _a; + return (_a = this.implementation.boolean("product-page-report-problem-enabled")) !== null && _a !== void 0 ? _a : false; + } + /// The bag key that stores the report a problem URL. + get productPageReportProblemURL() { + return this.implementation.string("product-page-report-problem-url"); + } + /// The string array of adamIDs of SAD apps with subscriptions. + get productPageReportProblemSADSubscriptionArray() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("product-page-report-problem-sad-subscriptions"))); + } + /// The string array of second party apps to not show the report a problem link for. + /// We have added the array of IDs while we wait for bag key support. Removal is tracked by rdar://82606581 (Remove array of second party app ids from JS bag.) + get productPageReportProblemSecondPartyAppArray() { + const secondPartyAppArray = serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("product-page-report-problem-second-party-apps"))); + const defaultSecondPartyAppArray = [ + "1473505534", + "1416238567", + "640199958", + "1529498570", + "915061776", + "1130498044", + "1070072560", + ]; + if (serverData.isNullOrEmpty(secondPartyAppArray)) { + return defaultSecondPartyAppArray; + } + return secondPartyAppArray; + } + /// The URL to create a new account. + get createAccountUrl() { + var _a; + return ((_a = this.implementation.url("createAccountUrl")) !== null && _a !== void 0 ? _a : "https://buy.itunes.apple.com/WebObjects/MZFinance.woa/wa/signupWizard"); + } + get mediaCountryCode() { + return this.implementation.string("countryCode"); + } + get mediaHost() { + return this.implementation.url("apps-media-api-host"); + } + mediaEdgeHost(objectGraph) { + // The key has different type for AppStoreComponents + // see <rdar://71290056>. + if (objectGraph.host.clientIdentifier === "com.apple.appstorecomponentsd") { + return this.implementation.url("apps-media-api-edge-host"); + } + else { + return this.implementation.string("apps-media-api-edge-host"); + } + } + get mediaAPICatalogMixedShouldUseEdge() { + var _a; + return (_a = this.implementation.boolean("apps-media-api-catalog-mixed-should-use-edge")) !== null && _a !== void 0 ? _a : false; + } + get mediaEdgeSearchHost() { + return this.implementation.string("apps-media-api-search-edge-host"); + } + get mediaPreviewHost() { + return this.implementation.string("apps-media-api-preview-host"); + } + get mediaRealmHost() { + return this.implementation.string("notification-settings-media-api-host"); + } + get edgeEndpoints() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("apps-media-api-edge-end-points"))); + } + get mediaAdvertRequestLimit() { + var _a; + return (_a = this.implementation.double("apps-media-api-search-ads-limit")) !== null && _a !== void 0 ? _a : 4; + } + get searchSortOptions() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("searchSortOptions"))); + } + get ageBands() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("ageBands"))); + } + get redirectUrlWhitelistedQueryParams() { + let params = serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("processRedirectUrl/whitelistedQueryParams"))); + if (serverData.isNullOrEmpty(params)) { + params = [ + "affC", + "adId", + "advp", + "at", + "ct", + "itsct", + "itscg", + "itscc", + "itcCt", + "its_qt", + "ls", + "partnerId", + "pt", + "qtkid", + "uo", + ]; + } + return params; + } + get redirectUrlEndpoint() { + var _a; + return ((_a = this.implementation.string("processRedirectUrl/endpoint")) !== null && _a !== void 0 ? _a : "https://itunes.apple.com/WebObjects/MZStoreServices.woa/wa/processRedirectUrl"); + } + get aristotleParentAppAdamId() { + var _a; + return (_a = this.implementation.string("aristotle-app-id")) !== null && _a !== void 0 ? _a : "383941000"; + } + /// The AdamId of the App Store app which owns the IAP for Arcade subscriptions + get arcadeAppAdamId() { + return this.implementation.string("app-store-app-id"); + } + /// The product family of the Arcade subscription IAP. This is for multiple IAPs for the same service not family sharing. + get arcadeProductFamilyId() { + var _a; + return (_a = this.implementation.string("arcade-iap-family-id")) !== null && _a !== void 0 ? _a : this.implementation.string("ocelot-iap-family-id"); + } + /// The Identifier (developer supplied reverse dns style name) of the IAP for Arcade subscriptions + get arcadeProductId() { + var _a; + return ((_a = this.implementation.string("arcade-iap-offer-name")) !== null && _a !== void 0 ? _a : this.implementation.string("ocelot-iap-offer-name")); + } + /// The percentage of users that will see the Arcade category bar See All Games uplift. + get arcadeCategoryBarSAGUpliftDisplayRate() { + var _a; + return (_a = this.implementation.double("arcade-category-bar-see-all-games-display-rate")) !== null && _a !== void 0 ? _a : 0.0; + } + get isArcadeEnabled() { + var _a; + return (_a = this.implementation.boolean("arcade-enabled")) !== null && _a !== void 0 ? _a : false; + } + get isAppsGroupingTagsEnabled() { + var _a; + return (_a = this.implementation.boolean("apps-groupings-tags-enabled")) !== null && _a !== void 0 ? _a : false; + } + get isAppsProductPageTagsEnabled() { + var _a; + return (_a = this.implementation.boolean("apps-product-page-tags-enabled")) !== null && _a !== void 0 ? _a : false; + } + get isAppsSlpTagsEnabled() { + var _a; + return (_a = this.implementation.boolean("apps-slp-tags-enabled")) !== null && _a !== void 0 ? _a : false; + } + get searchResultsLearnMoreEditorialId() { + return this.implementation.string("transparencyLawEditorialItemId"); + } + /// An array containing a mapping of system app bundle IDs and adam IDs. + get systemApps() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("hideableSystemApps"))); + } + /// An array containing a mapping of system app bundle IDs and adam IDs + /// Should only be used for watchOS as a temporary fix for rdar://100234873 + get nonDeletableSystemApps() { + const apps = serverData.asJSONValue(this.implementation.array("nonDeletableSystemApps")); + if (serverData.isDefinedNonNullNonEmpty(apps)) { + return serverData.asArrayOrEmpty(apps); + } + else { + return [ + { "id": 1635387927, "bundle-id": "com.apple.Depth" }, + { "id": 1635862301, "bundle-id": "com.apple.Mandrake" }, + { "id": 1584216343, "bundle-id": "com.apple.findmy.finddevices" }, + { "id": 1584215960, "bundle-id": "com.apple.NanoWorldClock" }, + { "id": 1584215812, "bundle-id": "com.apple.HeartRate" }, + { "id": 1584215851, "bundle-id": "com.apple.SessionTrackerApp" }, + { "id": 1146562108, "bundle-id": "com.apple.NanoPhone" }, + { "id": 1146560473, "bundle-id": "com.apple.MobileSMS" }, + { "id": 1584215428, "bundle-id": "com.apple.NanoPhotos" }, + { "id": 1459455352, "bundle-id": "com.apple.DeepBreathing" }, + { "id": 1067456176, "bundle-id": "com.apple.NanoCompass.watchkitapp" }, // Compass + ]; + } + } + /// The standard tabs for the current storefront. + get tabsStandard() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("tabs/standard"))); + } + // URL to sub-in for deep links specifying the watch category. Note that this can be a multiplexing url. + get watchAppsGroupingURL() { + var _a; + return ((_a = this.implementation.url("watchAppsGrouping")) !== null && _a !== void 0 ? _a : "https://apps.apple.com/WebObjects/MZStore.woa/wa/viewFeature?id=1472048385"); + } + get requireAgeVerification() { + return this.implementation.boolean("requireAgeVerification"); + } + get ageRatingLearnMoreEditorialItemId() { + return this.implementation.string("ageRatingLearnMoreEditorialItemId"); + } + get appleSiliconMacUnverifiedBadgeEditorialItemId() { + return this.implementation.string("appleSiliconMacUnverifiedBadgeEditorialItemId"); + } + get safariExtensionsGroupingURL() { + return this.implementation.url("safariExtensionsGrouping"); + } + get familySubscriptionsLearnMoreEditorialItemId() { + return this.implementation.string("familySubscriptionsLearnMoreEditorialItemId"); + } + get dynamicUIRegexStrings() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("commerce-ui-urls/dynamic-url-patterns"))); + } + get financeUIRegexStrings() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("commerce-ui-urls/url-patterns"))); + } + get webViewRegexStrings() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("commerce-ui-urls/v2-url-patterns"))); + } + get arcadePreOrderUpsellLimitSeconds() { + var _a; + return (_a = this.implementation.double("arcadePreOrderUpsellLimitSeconds")) !== null && _a !== void 0 ? _a : 86400; + } + get recentlyPlayedGamesWindowInSeconds() { + var _a; + return (_a = this.implementation.double("recentlyPlayedGamesWindowInSeconds")) !== null && _a !== void 0 ? _a : 7776000; // 90 days + } + get gamesFriendsPlayedWindowInSeconds() { + var _a; + return (_a = this.implementation.integer("games-friends-played-window-in-seconds")) !== null && _a !== void 0 ? _a : 15778800; // Half a year + } + get enableComingSoonToggle() { + return this.implementation.boolean("enableComingSoonToggle"); + } + /// Whether or not to show the app acessibility labels + get enableAppAccessibilityLabels() { + var _a; + return (_a = this.implementation.boolean("enable-app-accessibility-labels")) !== null && _a !== void 0 ? _a : false; + } + /// Whether or not to show the app privacy labels + get enablePrivacyNutritionLabels() { + var _a; + return (_a = this.implementation.boolean("enable-privacy-nutrition-labels")) !== null && _a !== void 0 ? _a : false; + } + /// Whether or not to show the seller info + get enableSellerInfo() { + var _a; + return (_a = this.implementation.boolean("enable-seller-info")) !== null && _a !== void 0 ? _a : false; + } + // Whether or not to show the seller ICP annotation + get enableSellerICPAnnotation() { + var _a; + return (_a = this.implementation.boolean("enable-seller-icp")) !== null && _a !== void 0 ? _a : false; + } + /// Whether to display enhanced category features (bar, breakout, and swoosh) on apps and games tabs + get enableFeaturedCategoriesOnGroupings() { + var _a; + return (_a = this.implementation.boolean("enable-featured-categories-on-groupings")) !== null && _a !== void 0 ? _a : false; + } + /// Whether to display enhanced category bricks on apps and games tabs + get enableCategoryBricksOnGroupings() { + var _a; + return (_a = this.implementation.boolean("enable-category-bricks-on-groupings")) !== null && _a !== void 0 ? _a : false; + } + get arcadeOfferEditorialItemId() { + return this.implementation.string("arcadeOfferEditorialItemId"); + } + get sponsoredSearchODMLTimeout() { + var _a; + return (_a = this.implementation.double("sponsored-search-odml-timeout")) !== null && _a !== void 0 ? _a : 3; + } + get isSearchLandingAdsEnabled() { + var _a; + return (_a = this.implementation.boolean("isSearchLandingAdsEnabled")) !== null && _a !== void 0 ? _a : false; + } + get isLLMSearchTagsEnabled() { + var _a; + return (_a = this.implementation.boolean("apps-search-tags-enabled")) !== null && _a !== void 0 ? _a : false; + } + get searchLandingAdFetchTimeout() { + var _a; + return (_a = this.implementation.double("search-landing-ad-fetch-timeout")) !== null && _a !== void 0 ? _a : 0.175; + } + // Time that SLP needs to be offscreen for it to be refreshed in seconds. + get searchLandingPageOffscreenRefreshInterval() { + var _a; + return (_a = this.implementation.double("search-landing-offscreen-refresh-interval-in-seconds")) !== null && _a !== void 0 ? _a : 60; // default is minute + } + // Time to delay the data fetch for SLP when refreshing + get searchLandingPageRefreshUpdateDelayInterval() { + var _a; + return (_a = this.implementation.double("search-landing-page-update-delay-interval-in-seconds")) !== null && _a !== void 0 ? _a : 0.3; // default is 0.3s + } + get appPrivacyLearnMoreEditorialItemId() { + return this.implementation.string("appPrivacyLearnMoreEditorialItemId"); + } + // The editorial id for the article page showing the transparency info for ratings and reviews + get ratingsAndReviewsLearnMoreEditorialId() { + return this.implementation.string("ratings-and-reviews-learn-more-editorial-item-id"); + } + // The editorial id for the article page showing info about the review summary + get reviewSummarizationLearnMoreEditorialItemId() { + return this.implementation.string("review-summarization-learn-more-editorial-item-id"); + } + /// An array containing a list of app bundle IDs and adam IDs for apps that should not display + /// any app privacy shelves + get suppressedPrivacyAppIds() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("suppressedPrivacyLabels"))); + } + /// An array containing a list of app bundle IDs and adam IDs for apps that should not display + /// any app accessibility shelves + get suppressedAccessibilityAppIds() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("suppressed-accessibility-labels"))); + } + get appPrivacyDefinitionsEditorialItemId() { + return this.implementation.string("appPrivacyDefinitionsEditorialItemId"); + } + // The EI ID for the web's category tabs shown in the sidebar + get webNavigationCategoryTabsEditorialItemId() { + return this.implementation.string("web-navigation-category-tabs-editorial-item-id"); + } + /// The percentage of users that will see a live preview of the widget in the Widget Gallery + get todayWidgetLivePreviewRolloutRate() { + var _a; + return (_a = this.implementation.double("todayWidgetLivePreviewRolloutRate")) !== null && _a !== void 0 ? _a : 1.0; + } + /// The percentage of users that will see the new carousel item styles under Hero 3.0 + get hero3RolloutRate() { + var _a; + return (_a = this.implementation.double("arcade-hero-shelf-tagline-style-rollout-rate")) !== null && _a !== void 0 ? _a : 1.0; + } + /// The percentage of users that will see the trial enrolled (subscriber) tab + get arcadeTrialEnrolledStateRate() { + var _a; + return (_a = this.implementation.double("arcade-trial-enrolled-state-rate")) !== null && _a !== void 0 ? _a : 0.0; + } + get marketingItemSelectionTimeout() { + var _a; + return (_a = this.implementation.double("marketing-item-selection-timeout")) !== null && _a !== void 0 ? _a : 1.0; + } + /// Whether or not to enable app events + get enableAppEvents() { + var _a; + return (_a = this.implementation.boolean("enableAppEvents")) !== null && _a !== void 0 ? _a : false; + } + /// Whether or not product page variants is enabled (feature-gate) + get enableProductPageVariants() { + var _a; + return (_a = this.implementation.boolean("enableProductPageVariants")) !== null && _a !== void 0 ? _a : false; + } + get enableArcadeTrialEligibleBadging() { + return this.implementation.boolean("enable-arcade-trial-eligible-badging"); + } + /// The duration we should use for the hero carousel auto scrolling + get heroCarouselAutoScrollDuration() { + var _a; + return (_a = this.implementation.double("heroCarouselAutoScrollDuration")) !== null && _a !== void 0 ? _a : 7.0; + } + /// Enable additional JS logging for Product Page Variants + get enableAdditionalLoggingForPPV() { + var _a; + return (_a = this.implementation.boolean("enableAdditionalLoggingForPPV")) !== null && _a !== void 0 ? _a : false; + } + /// Whether or not to enable on device personalization + get enableOnDevicePersonalization() { + const enableOnDevicePersonalization = this.implementation.boolean("enable-on-device-personalization"); + if (serverData.isNull(enableOnDevicePersonalization)) { + return true; + } + return enableOnDevicePersonalization; + } + /// Whether or not automatic page refreshing is enabled + get enableAutomaticPageRefresh() { + var _a; + return (_a = this.implementation.boolean("enable-automatic-page-refresh")) !== null && _a !== void 0 ? _a : true; + } + /// Rollout rate for smart stack suggestions for the today widget. + get widgetSuggestionsFromTodayTabRolloutRate() { + var _a; + return (_a = this.implementation.double("today-widget-suggestions-from-today-tab-rollout-rate")) !== null && _a !== void 0 ? _a : 1.0; + } + /// The upper bound for how many extra minutes we delay the smart stack from suggesting the Today Widget (to protect MAPI). + get todayWidgetSmartStackJitterMinutes() { + var _a; + return (_a = this.implementation.double("today-widget-smart-stack-jitter-minutes")) !== null && _a !== void 0 ? _a : 45; + } + get enableSystemAppReviews() { + var _a; + return (_a = this.implementation.boolean("enable-system-app-reviews")) !== null && _a !== void 0 ? _a : false; + } + /// Whether or not CPPs are enabled for Search Ads. + get enableCPPInSearchAds() { + return this.implementation.boolean("enableCPPsInSearchAds") || false; + } + get cancelPreorderItemSrv() { + return (this.implementation.url("cancelPreorderItemSrv") || "https://buy.itunes.apple.com/commerce/preorders/cancel"); + } + get getCancellablePreorderItemsSrv() { + return (this.implementation.url("getCancellablePreorderItemsSrv") || + "https://buy.itunes.apple.com/commerce/preorders/cancellable"); + } + /// An array of the enabled ad placements. + get enabledAdPlacements() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("enabled-ad-placements"))); + } + /// A dictionary of timeout values for the ad placements. + get adPlacementTimeouts() { + return serverData.asDictionary(serverData.asJSONData(this.implementation.dictionary("ad-placement-timeouts"))); + } + /// The editorial story ID for In App Purchases + get inAppPurchasesLearnMoreEditorialItemId() { + return this.implementation.string("in-app-purchases-learn-more-editorial-item-id"); + } + /// Determines whether external purchases are enabled. + get enableExternalPurchases() { + var _a; + return (_a = this.implementation.boolean("enable-external-purchase")) !== null && _a !== void 0 ? _a : false; + } + /// An array of the enabled external purchases placements + get enabledExternalPurchasesPlacements() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("enabled-external-purchase-placements"))); + } + /// The editorial item ID for the external purchases story + get externalPurchasesLearnMoreEditorialItemId() { + return this.implementation.string("external-purchase-learn-more-editorial-item-id"); + } + /// The editorial item ID for the external browser story + get externalBrowserLearnMoreEditorialItemId() { + return this.implementation.string("external-browser-learn-more-editorial-item-id"); + } + /// The SharePlay groupings url + get sharePlayAppsEditorialItemId() { + return this.implementation.string("share-play-apps-editorial-item-id"); + } + /// Determines whether to show the icon on the external purchases product page banner + get externalPurchasesIncludeProductPageBannerIcon() { + var _a; + return (_a = this.implementation.boolean("external-purchase-product-page-banner-include-icon")) !== null && _a !== void 0 ? _a : false; + } + /// Determines whether to use a variant of the external purchases product page annotation copy + get externalPurchasesProductPageAnnotationVariant() { + return this.implementation.string("external-purchase-product-page-annotation-variant"); + } + /// Tells us whether we want new events for ODJ to be enabled or not. + get newEventsForODJAreEnabled() { + var _a; + return (_a = this.implementation.boolean("new-events-for-odj-are-enabled")) !== null && _a !== void 0 ? _a : false; + } + get defaultChart() { + return serverData.asJSONData(this.implementation.dictionary("default-chart")); + } + // The url to display the user account + get accountUrl() { + var _a; + return ((_a = this.implementation.url("accountUrl")) !== null && _a !== void 0 ? _a : "https://buy.itunes.apple.com/WebObjects/MZFinance.woa/wa/accountSummary"); + } + // The url to display the user account + get redeemUrl() { + var _a; + return ((_a = this.implementation.url("redeemUrl")) !== null && _a !== void 0 ? _a : "https://buy.itunes.apple.com/WebObjects/MZFinance.woa/wa/redeemLandingPage"); + } + // The url to display the user account + get charityUrl() { + var _a; + return ((_a = this.implementation.url("charityUrl")) !== null && _a !== void 0 ? _a : "https://buy.itunes.apple.com/WebObjects/MZFinance.woa/wa/buyCharityGiftWizard"); + } + // The url to display the manage subs page + get manageSubscriptionsUrl() { + var _a; + return ((_a = this.implementation.url("manageSubscriptionsUrl")) !== null && _a !== void 0 ? _a : "https://finance-app.itunes.apple.com/subscriptions/manage?context=deeplink"); + } + // The url to display the manage subs page + get manageSubscriptionsV2Url() { + var _a; + return ((_a = this.implementation.url("manageSubscriptionsV2Url")) !== null && _a !== void 0 ? _a : "https://apps.mzstatic.com/content/54a1317a0ad442d3965d64ef6bfaae1c/"); + } + /// The language value to use for ad language content filtering. + /// This may not necessarily match the user's language setting - in some regions ads are required + /// to be localized to the country's primary language, regardless of the user's own preferences. + get adsOverrideLanguage() { + return this.implementation.string("ads-override-language"); + } + /// The percentage of users that will see the controller recommended or required treatment + /// (as opposed to supported) on supported platforms. + get gameControllerRecommendedRolloutRate() { + var _a; + return (_a = this.implementation.double("game-controller-recommended-rollout-rate")) !== null && _a !== void 0 ? _a : 0; + } + /// The ID of the editorial item that provides information about game controllers. + get gameControllerLearnMoreEditorialItemId() { + return this.implementation.string("game-controller-learn-more-editorial-item-id"); + } + /// The ID of the editorial item that provides information about spatial controllers. + get spatialControlsLearnMoreEditorialItemId() { + return this.implementation.string("spatial-controllers-learn-more-editorial-item-id"); + } + // Whether the user can use MAPI based search focus + get mediaAPISearchFocusEnabled() { + var _a; + return (_a = this.implementation.boolean("apps-search-focus-suggestions-enabled")) !== null && _a !== void 0 ? _a : false; + } + /// Indicates whether the Search Landing Page supports the V2 protocol + get supportsSearchLandingPageV2() { + var _a; + return (_a = this.implementation.boolean("supports-apps-slp-v2")) !== null && _a !== void 0 ? _a : false; + } + get enableSearchLandingPageV2ByTreatment() { + var _a; + return (_a = this.implementation.boolean("enable-apps-slp-v2-by-treatment")) !== null && _a !== void 0 ? _a : false; + } + /// The percentage of users that will see the new Search Landing Page V2 protocol + get searchLandingPageV2RolloutRate() { + var _a; + return (_a = this.implementation.double("apps-slp-v2-rollout-rate")) !== null && _a !== void 0 ? _a : 0; + } + /// The percentage of users that will see the Today tab Arcade personalization + get todayTabArcadePersonalizationRate() { + var _a; + return (_a = this.implementation.double("today-tab-arcade-personalization-rate")) !== null && _a !== void 0 ? _a : 0; + } + /// Whether to enable extending supported Game Center features. + get gameCenterExtendSupportedFeatures() { + var _a; + return (_a = this.implementation.boolean("game-center-extend-supported-features")) !== null && _a !== void 0 ? _a : false; + } + get adPlacementEligibleSlotPositions() { + const eligibleSlotPositions = serverData.asJSONData(this.implementation.dictionary("ad-placement-eligible-slot-positions")); + if (serverData.isDefinedNonNullNonEmpty(eligibleSlotPositions)) { + return eligibleSlotPositions; + } + return { + "today": [ + { + shelfIdentifier: "0", + slot: 0, + }, + { + shelfIdentifier: "0", + slot: 1, + }, + ], + "product-page-ymal": [ + { + shelfIdentifier: "customers-also-bought-apps", + slot: 0, + }, + ], + }; + } + // The url to display the manage preorders page + get managePreordersUrl() { + var _a; + return (_a = this.implementation.url("preordersUrl")) !== null && _a !== void 0 ? _a : "https://finance-app.itunes.apple.com/preorders"; + } + // A url to modify the user's account. + get modifyAccount() { + var _a; + return ((_a = this.implementation.url("modifyAccount")) !== null && _a !== void 0 ? _a : "https://buy.itunes.apple.com/WebObjects/MZFinance.woa/wa/accountSummary"); + } + // The url to display the purchase history page + get purchaseHistoryUrl() { + return this.implementation.url("purchaseHistoryUrl"); + } + // The url to display the ratings and reviews page + get ratingsReviewsUrl() { + var _a; + return ((_a = this.implementation.url("ratingsReviewsUrl")) !== null && _a !== void 0 ? _a : "https://apps.mzstatic.com/content/54a1317a0ad442d3965d64ef6bfaae1c/ratings-reviews"); + } + // A url to sign up for a new account. + get signup() { + var _a; + return ((_a = this.implementation.url("signup")) !== null && _a !== void 0 ? _a : "https://buy.itunes.apple.com/WebObjects/MZFinance.woa/wa/signupWizard"); + } + // The landing page to redeem a code. + get redeemCodeLanding() { + var _a; + return ((_a = this.implementation.url("redeemCodeLanding")) !== null && _a !== void 0 ? _a : "https://buy.itunes.apple.com/WebObjects/MZFinance.woa/wa/redeemLandingPage"); + } + /// The bag key that stores the generic report a problem URL. + get reportProblemUrl() { + return this.implementation.string("reportProblemUrl"); + } + // Whether the app store should allow unrestricted arcade tab badging by server side marketing journeys + get unrestrictedServerSideTabBadging() { + var _a; + return (_a = this.implementation.boolean("unrestricted-server-side-tab-badging")) !== null && _a !== void 0 ? _a : false; + } + // Whether all users should receive the "condensed" today ad. + get todayAdCondensedEnabled() { + var _a; + return (_a = this.implementation.boolean("today-ad-condensed-enabled")) !== null && _a !== void 0 ? _a : false; + } + // Whether to enable bin-compat checks for the visionOS App Store + get enableVisionAppStoreBinCompatChecks() { + var _a; + return (_a = this.implementation.boolean("enable-vision-app-store-bincompat-checks")) !== null && _a !== void 0 ? _a : false; + } + // The ID for an editorial page containing Safari Extensions + get safariExtensionsEditorialPageId() { + return this.implementation.url("safari-extensions-editorial-page-id"); + } + /// The ID of the editorial item to show when deeplinking to buddy onboarding + get buddyOnboardingEditorialItemId() { + return this.implementation.string("buddy-onboarding-editorial-item-id"); + } + // Whether click events should be sent for the friends playing shelf on the product page + get productPageFriendsPlayingClickEventsEnabled() { + var _a; + return (_a = this.implementation.boolean("product-page-friends-playing-click-events-enabled")) !== null && _a !== void 0 ? _a : false; + } + // ID of the editorial item to show for more information about the "High Motion" annotation. + get highMotionLearnMoreEditorialItemId() { + return this.implementation.string("high-motion-learn-more-editorial-item-id"); + } + // The speed of the river in the medium lockup with screenshots ad. + // This is temporary, and only for testing purposes. + get todayAdMediumLockupScreenshotsRiverSpeed() { + return this.implementation.double("today-ad-medium-lockup-screenshots-river-speed"); + } + // Collection ID of the game categories for Arcade download/starter pack onboarding. + get arcadeDownloadPackCategoriesCollectionId() { + return this.implementation.string("arcade-download-packs-onboarding-collection-id"); + } + // Time interval in seconds where Arcade download pack shelf is visible after user has gone through the onboarding flow. + get arcadeDownloadPackShelfTTLInSeconds() { + var _a; + return (_a = this.implementation.integer("arcade-starter-pack-ttl-in-seconds")) !== null && _a !== void 0 ? _a : 0; + } + // The feature flag as whether or not we should display IAP offers (eg winback offers). + get enableOfferItems() { + var _a; + return (_a = this.implementation.boolean("enable-winback-offers")) !== null && _a !== void 0 ? _a : false; + } + // The host for App Distribution Media API requests. + get appDistributionMediaAPIHost() { + return this.implementation.string("app-distribution-media-api-host"); + } + // The language tag to use for App Distribution Media API requests. + get appDistributionLanguageTag() { + return this.implementation.string("app-distribution-language-tag"); + } + // Whether App Distribution is supported. + get supportsAppDistribution() { + var _a; + return (_a = this.implementation.boolean("supports-app-distribution")) !== null && _a !== void 0 ? _a : false; + } + // Whether Arcade download/starter pack onboarding should be triggered after Arcade purchase from the page offer button. + // When Mercury supports this flow the flag should be disabled. + get arcadeDownloadPackPostSubscribeTrigger() { + var _a; + return (_a = this.implementation.boolean("arcade-download-packs-post-subscribe-trigger")) !== null && _a !== void 0 ? _a : true; + } + // The feature flag as whether or not we should display contingent offers. + get enableContingentOffers() { + var _a; + return (_a = this.implementation.boolean("enable-contingent-offers")) !== null && _a !== void 0 ? _a : false; + } + /// The percentage of users that will see Arcade packs onboarding experience. + get arcadeDownloadPackRolloutRate() { + var _a; + return (_a = this.implementation.double("arcade-download-packs-rollout-rate")) !== null && _a !== void 0 ? _a : 0; + } + // Whether to enable including the Vision platform in fetch requests + get enableVisionPlatform() { + var _a; + return (_a = this.implementation.boolean("enable-vision-platform")) !== null && _a !== void 0 ? _a : false; + } + // Dictionary containing the use cases that are supported for mixed media requests. + get supportedMixedMediaRequestUsecases() { + var _a; + return ((_a = serverData.asDictionary(serverData.asJSONData(this.implementation.dictionary("supported-mixed-media-request-usecases")))) !== null && _a !== void 0 ? _a : {}); + } + // Whether the page and click events are enabled for Arcade download pack. + get arcadeDownloadPacksMetricsEventsEnabled() { + var _a; + return (_a = this.implementation.boolean("arcade-download-packs-metrics-events-enabled")) !== null && _a !== void 0 ? _a : true; + } + // Whether the impression events are enabled for Arcade download pack. + get arcadeDownloadPacksImpressionEventsEnabled() { + var _a; + return (_a = this.implementation.boolean("arcade-download-packs-impression-events-enabled")) !== null && _a !== void 0 ? _a : true; + } + /// The learn more EI ID for when purchasing a visionOS only app on iOS + get visionOnlyAppLearnMoreEditorialItemId() { + return this.implementation.string("vision-only-app-learn-more-editorial-item-id"); + } + // Whether Arcade download pack onboarding will be shown after successful CIP carrier link. + get arcadeDownloadPacksCIPDeeplinkIntegrationEnabled() { + var _a; + return (_a = this.implementation.boolean("arcade-download-packs-cip-deeplink-trigger")) !== null && _a !== void 0 ? _a : false; + } + // Whether Arcade download pack onboarding will be shown after Hardware upsell successful purchase. + // Only for tab badge upsell. + get arcadeDownloadPacksHardwareTabBadgeUpsellIntegrationEnabled() { + var _a; + return (_a = this.implementation.boolean("arcade-download-packs-hw-tabbadge-trigger")) !== null && _a !== void 0 ? _a : false; + } + // A URL that links to the About the App Store website + get aboutAppStoreUrl() { + return this.implementation.string("about-app-store-url"); + } + // The EI ID for the About In App Purchases article + get aboutInAppPurchasesEditorialItemId() { + return this.implementation.string("about-in-app-purchases-editorial-item-id"); + } + // A URL that links to the Request A Refund website + get requestARefundUrl() { + return this.implementation.string("request-a-refund-url"); + } + // Whether the personalized recommendations toggle should be displayed in the personalized + // recommendations screen. + get personalizedRecommendationsToggleEnabled() { + var _a; + return (_a = this.implementation.boolean("enable-personalized-recommendations-toggle")) !== null && _a !== void 0 ? _a : false; + } + /// Whether we should be using metricsId exclusively and remove DSID in events + get metricsIdMigrationEnabled() { + var _a; + return (_a = this.implementation.boolean("metrics-id-migration-enabled")) !== null && _a !== void 0 ? _a : true; + } + // Whether natural language search is enabled for all features, e.g. What's New, Bubble Tip, Hints, and Results. + get isNaturalLanguageSearchEnabled() { + var _a; + return (_a = this.implementation.boolean("apps-natural-language-search-enabled")) !== null && _a !== void 0 ? _a : false; + } + // Whether natural language search is partially enabled, e.g. Bubble Tip and Results only, excludes What's New and Hints. + get isNaturalLanguageSearchResultsEnabled() { + var _a; + return (_a = this.implementation.boolean("apps-natural-language-search-results-enabled")) !== null && _a !== void 0 ? _a : false; + } + /// Whether we should be using metricsId exclusively and remove DSID in events + get metricsIdentifiersShouldCache() { + var _a; + return (_a = this.implementation.boolean("metrics-identifiers-should-cache")) !== null && _a !== void 0 ? _a : true; + } + // A URL that links to the Change Your Payment Method support article + get changePaymentMethodUrl() { + return this.implementation.string("change-payment-method-url"); + } + // The EI ID for the Information about the French App Store article + get aboutFrenchAppStoreEditorialItemId() { + return this.implementation.string("about-app-store-editorial-item-id"); + } + // A bag override which can disable product page on demand shelf fetching if necessary, without + // a JS release + get isOnDemandShelfFetchingEnabled() { + var _a; + return (_a = this.implementation.boolean("on-demand-product-shelf-fetching-enabled")) !== null && _a !== void 0 ? _a : true; + } + // A bag override which can enable the addition of the dsId field to metrics events in the case of + // missing userId + get isMetricsUserIdFallbackEnabled() { + var _a; + return (_a = this.implementation.boolean("metrics-user-id-fallback-enabled")) !== null && _a !== void 0 ? _a : false; + } + // A bag override which can enable the addition of the alt_ab2_data field to metrics events in the case of + // missing ab2_data + get isMetricsAb2DataFallbackEnabled() { + var _a; + return (_a = this.implementation.boolean("metrics-ab2data-fallback-enabled")) !== null && _a !== void 0 ? _a : !preprocessor.GAMES_TARGET; + } + /// Whether or not to enable on device reco reordering. Default to true while in dev. + get enableRecoOnDeviceReordering() { + var _a; + return (_a = this.implementation.boolean("enable-on-device-reco-reordering")) !== null && _a !== void 0 ? _a : false; + } + // The EI IDs for any Vision Pro ribbon bar items + get ribbonBarVisionEditorialItemIds() { + return serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("ribbon-bar-vision-editorial-item-ids"))); + } + // The IDs for any EIs that should be filtered from search results + get searchFilterEditorialItemIds() { + const array = serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("search-filter-editorial-item-ids"))); + return new Set(array); + } + // The ID for the accessibility learn more EI on the product page + get accessibilityLearnMoreEditorialItemId() { + return this.implementation.string("accessibility-learn-more-editorial-item-id"); + } + /// Whether discovery content based on ownership of a Vision Pro device is enabled + get enableDeviceDrivenDiscoveryContent() { + var _a; + return (_a = this.implementation.boolean("enable-device-driven-discovery-content")) !== null && _a !== void 0 ? _a : false; + } + /// Whether to show install size for apps on the product page + get enableProductPageInstallSize() { + var _a; + return (_a = this.implementation.boolean("enable-product-page-install-size")) !== null && _a !== void 0 ? _a : false; + } + // Whether we show the prerendered icon artwork + get enableIconArtwork() { + var _a; + return (_a = this.implementation.boolean("enable-icon-artwork")) !== null && _a !== void 0 ? _a : false; + } + // The rollout rate associated with `enable-icon-artwork` + get iconArtworkRolloutRate() { + var _a; + return (_a = this.implementation.double("icon-artwork-rollout-rate")) !== null && _a !== void 0 ? _a : 0.0; + } + // Whether the new age rating system should be used + get enableUpdatedAgeRatings() { + var _a; + return (_a = this.implementation.boolean("enable-app-store-age-ratings")) !== null && _a !== void 0 ? _a : false; + } + // Whether age rating should be sent to MAPI to filter returned content + get enableAgeRatingFilter() { + var _a; + return (_a = this.implementation.boolean("enable-age-rating-filter")) !== null && _a !== void 0 ? _a : false; + } + // Whether two-phase buy is enabled. This is expected to always be false, and only exists + // as an escape hatch. + get enableTwoPhaseOfferConfirmation() { + var _a; + return (_a = this.implementation.boolean("enable-two-phase-offer-confirmation")) !== null && _a !== void 0 ? _a : false; + } + /// Determines whether to use a variant of the external purchases product page banner text copy + get externalPurchasesProductPageBannerTextVariant() { + return this.implementation.string("external-purchase-product-page-banner-text-variant"); + } + /// Describes the variant of the external purchases product page banner icon to use + get externalPurchasesProductPageBannerIconVariant() { + return this.implementation.string("external-purchase-product-page-banner-icon-variant"); + } + /** ******* GameStoreKit *********/ + // A default maximum number of games used for query events & updates. + get maxGamesForFetchingEvents() { + var _a; + return (_a = this.implementation.integer("max-games-for-fetching-events")) !== null && _a !== void 0 ? _a : 30; + } + // The mock home feed url for testing + get mockHomeFeedURL() { + return this.implementation.string("mock-home-feed-url"); + } + // Disable play-together endpoint + get disablePlayTogetherEndpoint() { + var _a; + return (_a = this.implementation.boolean("disable-play-together-endpoint")) !== null && _a !== void 0 ? _a : false; + } + // Metrics topic for the current bundle. + get metricsTopic() { + var _a, _b; + if (preprocessor.GAMES_TARGET) { + const defaultTopic = "xp_amp_gc_cs"; + const metricsTopic = (_a = serverData.asString(this.metricsConfiguration, "topics.GAMES_CLICKSTREAM_TOPIC")) !== null && _a !== void 0 ? _a : null; + return metricsTopic !== null && metricsTopic !== void 0 ? metricsTopic : defaultTopic; + } + else { + const defaultTopic = "xp_ase_appstore_ue"; + return (_b = this.implementation.string("metrics_topic")) !== null && _b !== void 0 ? _b : defaultTopic; + } + } + // A default collectionID of the game recommendations for arcade subscriber. + get playTogetherGameRecommendationsArcade() { + var _a; + return (_a = this.implementation.string("play-together-arcade-game-recommendations")) !== null && _a !== void 0 ? _a : "1803255513"; + } + // A default collectionID of the game recommendations for users with no arcade subscription. + get playTogetherGameRecommendationsNonArcade() { + var _a; + return (_a = this.implementation.string("play-together-non-arcade-game-recommendations")) !== null && _a !== void 0 ? _a : "1804480915"; + } + /// A collectionID of arcade game recommendations for multiplayer activity + get multiplayerActivityGameRecommendationsArcade() { + var _a; + return (_a = this.implementation.string("multiplayer-activity-arcade-game-recommendations")) !== null && _a !== void 0 ? _a : "1821553042"; + } + /// A collectionID of non-arcade game recommendations for multiplayer activity + get multiplayerActivityGameRecommendationsNonArcade() { + var _a; + return (_a = this.implementation.string("multiplayer-activity-non-arcade-game-recommendations")) !== null && _a !== void 0 ? _a : "1821553152"; + } + // Whether to show the Subscriber Access Arcade Badge + get showArcadeSubscriberAccessBadge() { + var _a; + return (_a = this.implementation.boolean("show-arcade-subscriber-access-badge")) !== null && _a !== void 0 ? _a : false; + } + // Whether to show the Non-Subscriber Arcade Badge + get showArcadeNonSubscriberBadge() { + var _a; + return (_a = this.implementation.boolean("show-arcade-non-subscriber-badge")) !== null && _a !== void 0 ? _a : false; + } + /// The URL for the learn more link on the Cross Use Consent screen. + get gamesCrossUseConsentLearnMoreURL() { + return this.implementation.string("games-crossuse-consent-learn-more-url"); + } + /// The duration for the auto advance interval for the Play Now feed hero carousel + get gamesPlayNowHeroCarouselAutoAdvanceInterval() { + var _a; + return (_a = this.implementation.double("games-play-now-hero-carousel-auto-advance-interval")) !== null && _a !== void 0 ? _a : 10.0; + } + /// The max duration for the auto advance interval for the Play Now feed hero carousel + get gamesPlayNowHeroCarouselAutoAdvanceMaxInterval() { + var _a; + return (_a = this.implementation.double("games-play-now-hero-carousel-auto-advance-max-interval")) !== null && _a !== void 0 ? _a : 30.0; + } + /// The duration for the auto advance interval for the Editorial hero carousel + get gamesEditorialHeroCarouselAutoAdvanceInterval() { + var _a; + return (_a = this.implementation.double("games-editorial-hero-carousel-auto-advance-interval")) !== null && _a !== void 0 ? _a : 10.0; + } + /// The max duration for the auto advance interval for the Editorial hero carousel + get gamesEditorialHeroCarouselAutoAdvanceMaxInterval() { + var _a; + return (_a = this.implementation.double("games-editorial-hero-carousel-auto-advance-max-interval")) !== null && _a !== void 0 ? _a : 30.0; + } + get enablePreviewPlatformForWeb() { + var _a; + return (_a = this.implementation.boolean("enable-preview-platform-for-web")) !== null && _a !== void 0 ? _a : false; + } + // How long to look back for completed challenges to show in active challenges shelf + get completedChallengesInActiveShelfTimeThreshold() { + var _a; + return (_a = this.implementation.integer("completed-challenges-in-active-shelf-time-threshold")) !== null && _a !== void 0 ? _a : 86400; // default to 1 day + } + // Whether we should request for a review when we have a chance. + get requestReviewEnabled() { + var _a; + return (_a = this.implementation.boolean("request-review-enabled")) !== null && _a !== void 0 ? _a : true; + } + // The minimum number of app launches before we consider requesting for a review. + get requestReviewMinAppLaunchCount() { + var _a; + return (_a = this.implementation.integer("request-review-min-app-launch-count")) !== null && _a !== void 0 ? _a : 15; + } + // The minimum number of game launches from the app before we consider requesting a review. + get requestReviewMinGameLaunchCount() { + var _a; + return (_a = this.implementation.integer("request-review-min-game-launch-count")) !== null && _a !== void 0 ? _a : 5; + } + // Whether we should request licenses in product information + get enableLicenses() { + var _a; + return (_a = this.implementation.boolean("enable-licenses")) !== null && _a !== void 0 ? _a : false; + } + // The number of apps to display in the chart detail screen. + get chartDetailPageItemCount() { + var _a; + return (_a = this.implementation.integer("chart-detail-page-item-count")) !== null && _a !== void 0 ? _a : 25; + } + /// https://quip-apple.com/G5EGABrSh1YO#temp:C:UdDa344becf5aac473db8085f35a + /// URL query parameters that are permitted to be included in the pageUrl field of page metrics events. + get metricsAllowedListURLParams() { + let params = serverData.asArrayOrEmpty(serverData.asJSONValue(this.implementation.array("metrics-allowed-list-url-params"))); + if (serverData.isNullOrEmpty(params)) { + params = [ + "itsct", + "itscg", + "itcCt", + "ct", + "pt", + "advp", + "mttn3pid", + "mttnagencyid", + "mttncc", + "mttnpid", + "mttnsiteid", + "mttnsub1", + "mttnsub2", + "mttnsubad", + "mttnsubkw", + "mttnsubplmnt", + "id", + "term", + "salableAdamId", + "ign-itscg", + "ign-itsct", + "utm_campaign", + "clusterId", + ]; + } + return params; + } +} +BagWrapper.type = makeMetatype("app-store:bag-wrapper"); +//# sourceMappingURL=bag.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/cached-bag.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/cached-bag.js new file mode 100644 index 0000000..e7ac2db --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/cached-bag.js @@ -0,0 +1,82 @@ +import { isSome } from "@jet/environment"; +import { Wrapper } from "./wrapper"; +/** + * A bag wrapper that implements caching. All accessed values are cached until this object is reinitialized via rebootstrap or recreated. + * + */ +export class CachedBag extends Wrapper { + constructor() { + super(...arguments); + /** + * A cache of entries + * + * Note that `Opt<T>` values which are nil are stored, representing that the bag has no value for a key, which + * is coalesced in the JS. This prevents infinite cache misses when the bag has no value for a key, resulting in + * unnecessary calls to the native client + */ + this.cache = {}; + } + registerBagKeys(keys) { + this.implementation.registerBagKeys(keys); + } + string(key, forceDisableCache = false) { + return this.fromCache(key, forceDisableCache, () => { + return this.implementation.string(key); + }); + } + double(key, forceDisableCache = false) { + return this.fromCache(key, forceDisableCache, () => { + return this.implementation.double(key); + }); + } + integer(key, forceDisableCache = false) { + return this.fromCache(key, forceDisableCache, () => { + return this.implementation.integer(key); + }); + } + boolean(key, forceDisableCache = false) { + return this.fromCache(key, forceDisableCache, () => { + return this.implementation.boolean(key); + }); + } + array(key, forceDisableCache = false) { + return this.fromCache(key, forceDisableCache, () => { + return this.implementation.array(key); + }); + } + dictionary(key, forceDisableCache = false) { + return this.fromCache(key, forceDisableCache, () => { + return this.implementation.dictionary(key); + }); + } + url(key, forceDisableCache = false) { + return this.fromCache(key, forceDisableCache, () => { + return this.implementation.url(key); + }); + } + /** + * Returns a cached value if possible to do so, otherwise uses the closure to fetch a new value which is cached and returned + * + * @param key The key on which to cache + * @param forceDisableCache Disables the cache to ensure a fresh value from the bag + * @param fetchValue A closure to fetch new values with + * @returns A previously or newly cached value + */ + fromCache(key, forceDisableCache = false, fetchValue) { + if (forceDisableCache) { + return fetchValue(); + } + else { + const cacheEntry = this.cache[key]; + if (isSome(cacheEntry)) { + return cacheEntry.value; + } + else { + const newValue = fetchValue(); + this.cache[key] = { value: newValue }; + return newValue; + } + } + } +} +//# sourceMappingURL=cached-bag.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/client-ordering.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/client-ordering.js new file mode 100644 index 0000000..683d81c --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/client-ordering.js @@ -0,0 +1,43 @@ +/** + * Created by dersu on 6/23/17. + */ +import { makeMetatype } from "@jet/environment/util/metatype"; +import { Wrapper } from "./wrapper"; +export class ClientOrderingWrapper extends Wrapper { + async orderedVisibleIAPs(appBundleId, defaultOrdering, defaultVisibleIdentifiers, spotlightIdentifier) { + return await new Promise((resolve, reject) => { + // Collections that are parameters over the bridge cannot have `nil` constituents on the other side, so we + // should make sure we don't give such inputs or else we'll crash the app. + const cleanedDefaultOrdering = defaultOrdering.filter((item) => { + return item !== null && item !== undefined; + }); + const cleanedDefaultVisibleIdentifiers = defaultVisibleIdentifiers.filter((item) => { + return item !== null && item !== undefined; + }); + this.implementation.orderedVisibleIAPs(appBundleId, cleanedDefaultOrdering, cleanedDefaultVisibleIdentifiers, spotlightIdentifier, (ordering, error) => { + if (error) { + reject(error); + } + else { + resolve(ordering); + } + }); + }); + } + async visibilityForIAPs(productMap) { + return await new Promise((resolve, reject) => { + this.implementation.visibilityForIAPs(productMap, (visibilities, error) => { + if (error) { + // Do not reject; we should gracefully fail, since this ordering + // data isn't strictly necessary to render search results. + resolve({}); + } + else { + resolve(visibilities); + } + }); + }); + } +} +ClientOrderingWrapper.type = makeMetatype("app-store:client-ordering-wrapper"); +//# sourceMappingURL=client-ordering.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/client.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/client.js new file mode 100644 index 0000000..5a53dac --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/client.js @@ -0,0 +1,204 @@ +/** + * Created by Pete Hare on 2/7/17. + */ +import { makeMetatype } from "@jet/environment/util/metatype"; +import { Size } from "../../api/models/base"; +import * as serverData from "../json-parsing/server-data"; +import { Wrapper } from "./wrapper"; +// region API +/** + * Client identifier for the App Store. + */ +export const appStoreIdentifier = "com.apple.AppStore" /* ClientIdentifier.AppStore */; +/** + * Client identifier for the Bridge (Watch) store. + */ +export const watchIdentifier = "com.apple.AppStore.BridgeStoreExtension" /* ClientIdentifier.AppStore_BridgeStoreExtension */; +/** + * Client identifier for the iMessages store. + */ +export const messagesIdentifier = "com.apple.MobileSMS" /* ClientIdentifier.MobileSMS */; +/** + * Client identifier for the arcade app. + */ +export const arcadeIdentifier = "com.apple.Arcade" /* ClientIdentifier.Arcade */; +/** + * Client identifier indicating ATV. + */ +export const tvIdentifier = "com.apple.TVAppStore" /* ClientIdentifier.TVAppStore */; +/** + * Client identifier for the Arcade launch repair SubscribePageExtension (iOS). + */ +export const productPageExtensionIdentifier = "com.apple.AppStore.ProductPageExtension" /* ClientIdentifier.AppStore_ProductPageExtension */; +/** + * Client identifier for the Arcade launch repair SubscribePageExtension (iOS). + */ +export const subscribePageExtensionIdentifier = "com.apple.AppStore.SubscribePageExtension" /* ClientIdentifier.AppStore_SubscribePageExtension */; +export class ClientWrapper extends Wrapper { + get buildType() { + return this.implementation.buildType; + } + // This is only supported in Luckier client builds from AppStoreJet 11.1.7 & GamesUI 2.1.5 onwards. Any previous + // clients will return undefined. + get buildVersion() { + return this.implementation.buildVersion; + } + get deviceType() { + return this.implementation.deviceType; + } + get guid() { + return this.implementation.guid; + } + get isActivityAvailable() { + return this.implementation.isActivityAvailable; + } + get isElectrocardiogramInstallationAllowed() { + return this.implementation.isElectrocardiogramInstallationAllowed; + } + get isScandiumInstallationAllowed() { + return this.implementation.isScandiumInstallationAllowed; + } + get isSidepackingEnabled() { + return this.implementation.isSidepackingEnabled; + } + get isTinkerWatch() { + return this.implementation.isTinkerWatch; + } + get screenCornerRadius() { + return this.implementation.screenCornerRadius; + } + get screenSize() { + return Size.fromNativeSize(this.implementation.screenSize); + } + get storefrontIdentifier() { + return this.implementation.storefrontIdentifier; + } + get supportsHEIF() { + return this.implementation.supportsHEIF; + } + get thinnedApplicationVariantIdentifier() { + return this.implementation.thinnedApplicationVariantIdentifier; + } + get isMandrakeSupported() { + return this.implementation.isMandrakeSupported; + } + get isCharonSupported() { + return this.implementation.isCharonSupported; + } + get isIconArtworkCapable() { + return this.implementation.isIconArtworkCapable; + } + get maxAppContentRating() { + return this.implementation.maxAppContentRating; + } + get hostBundleId() { + return this.implementation.hostBundleId; + } + isPairedSystemVersionAtLeast(version) { + var _a, _b, _c; + return (_c = (_b = (_a = this.implementation).isPairedSystemVersionAtLeast) === null || _b === void 0 ? void 0 : _b.call(_a, version)) !== null && _c !== void 0 ? _c : false; + } + deletableSystemAppCanBeInstalledOnWatchWithBundleID(bundleId) { + return this.implementation.deletableSystemAppCanBeInstalledOnWatchWithBundleID(bundleId); + } + deviceHasCapabilities(capabilities) { + return this.implementation.deviceHasCapabilities(capabilities); + } + deviceHasCapabilitiesIncludingCompatibilityCheckIsVisionOSCompatibleIOSApp(capabilities, supportsVisionOSCompatibleIOSBinary) { + if (this.isPad && capabilities.includes("healthkit")) { + // Workaround for: rdar://116905381 (J517/21C16: Unable to download AC Wellness even though App Store page says its compatible with my iPad) + return false; + } + return this.implementation.deviceHasCapabilitiesIncludingCompatibilityCheckIsVisionOSCompatibleIOSApp(capabilities, supportsVisionOSCompatibleIOSBinary); + } + isActivePairedWatchSystemVersionAtLeastMajorVersionMinorVersionPatchVersion(majorVersion, minorVersion, patchVersion) { + return this.implementation.isActivePairedWatchSystemVersionAtLeastMajorVersionMinorVersionPatchVersion(majorVersion, minorVersion, patchVersion); + } + canDevicePerformAppActionWithAppCapabilities(appAction, appCapabilities) { + return this.implementation.canDevicePerformAppActionWithAppCapabilities(appAction, appCapabilities); + } + isAutomaticDownloadingEnabled() { + return this.implementation.isAutomaticDownloadingEnabled(); + } + isAuthorizedForUserNotifications() { + return this.implementation.isAuthorizedForUserNotifications(); + } + /** + * Check whether the active paired device's OS is below a given version. + */ + isActivePairedWatchSystemVersionBelow(version) { + // We want to use isActivePairedWatchSystemVersionAtLeastMajorVersionMinorVersionPatchVersion + // rather than isPairedSystemVersionAtLeast here, as the latter is only available from YukonB onwards + const versionComponents = version.split("."); + const majorVersion = serverData.asNumber(versionComponents[0]) || 0; + const minorVersion = serverData.asNumber(versionComponents[1]) || 0; + const patchVersion = serverData.asNumber(versionComponents[2]) || 0; + return !this.implementation.isActivePairedWatchSystemVersionAtLeastMajorVersionMinorVersionPatchVersion(majorVersion, minorVersion, patchVersion); + } + /** Returns `true` for phone-factor iOS devices. */ + get isPhone() { + return this.deviceType === "phone"; + } + /** Returns `true` for pad-factor iOS devices. */ + get isPad() { + return this.deviceType === "pad"; + } + /** + * Returns `true` for iOS devices. + * + * Note: this property might be replaced with a build-time macro in "production" + */ + get isiOS() { + return this.isPhone || this.isPad; + } + /** + * Returns `true` for Mac devices + + * Note: this property might be replaced with a build-time macro in "production" + */ + get isMac() { + return this.deviceType === "mac"; + } + /** + * Returns `true` for TV devices. + + * Note: this property might be replaced with a build-time macro in "production" + */ + get isTV() { + return this.deviceType === "tv"; + } + /** + * Returns `true` for Watch devices. + + * Note: this property might be replaced with a build-time macro in "production" + */ + get isWatch() { + return this.deviceType === "watch"; + } + /** + * Returns `true` for Vision devices. + * + * Note: this property might be replaced with a build-time macro in "production" + */ + get isVision() { + return this.deviceType === "vision"; + } + /** + * Returns `true` for the Web + * + * Note: this property might be replaced with a build-time macro in "production" + */ + get isWeb() { + return this.deviceType === "web"; + } + get isCompanionVisionApp() { + return this.hostBundleId === "com.apple.visionproapp"; + } + /** Returns the list of remote identifiers to download any purchases to. */ + get remoteDownloadIdentifiers() { + return this.implementation.remoteDownloadIdentifiers; + } +} +ClientWrapper.type = makeMetatype("app-store:client-wrapper"); +// endregion +//# sourceMappingURL=client.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/console.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/console.js new file mode 100644 index 0000000..1bbfac0 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/console.js @@ -0,0 +1,18 @@ +import { makeMetatype } from "@jet/environment/util/metatype"; +import { Wrapper } from "./wrapper"; +export class ConsoleWrapper extends Wrapper { + info(...args) { + return this.implementation.info(...args); + } + error(...args) { + return this.implementation.error(...args); + } + log(...args) { + return this.implementation.log(...args); + } + warn(...args) { + return this.implementation.warn(...args); + } +} +ConsoleWrapper.type = makeMetatype("app-store:console-wrapper"); +//# sourceMappingURL=console.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/host.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/host.js new file mode 100644 index 0000000..001a1e3 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/host.js @@ -0,0 +1,64 @@ +import { makeMetatype } from "@jet/environment/util/metatype"; +import { Wrapper } from "./wrapper"; +export class HostWrapper extends Wrapper { + get clientIdentifier() { + return this.implementation.clientIdentifier; + } + get clientVersion() { + return this.implementation.clientVersion; + } + get deviceLocalizedModel() { + return this.implementation.deviceLocalizedModel; + } + get deviceModel() { + return this.implementation.deviceModel; + } + get deviceModelFamily() { + return this.implementation.deviceModelFamily; + } + get devicePhysicalModel() { + return this.implementation.devicePhysicalModel; + } + get deviceMarketingFamilyName() { + return this.implementation.deviceMarketingFamilyName; + } + get osBuild() { + return this.implementation.osBuild; + } + get platform() { + return this.implementation.platform; + } + isOSAtLeast(majorVersion, minorVersion, patchVersion) { + return this.implementation.isOSAtLeast(majorVersion, minorVersion, patchVersion); + } + /** Returns `true` for iOS host. */ + get isiOS() { + return this.platform === "iOS"; + } + /** Returns `true` for macOS host. */ + get isMac() { + return this.platform === "macOS"; + } + /** Returns `true` for tvOS host. */ + get isTV() { + return this.platform === "tvOS"; + } + /** Returns `true` for watchOS host. */ + get isWatch() { + return this.platform === "watchOS"; + } + /** Returns `true` for web host. */ + get isWeb() { + return this.platform === "web"; + } + /** Returns `true` for Windows host. */ + get isWindows() { + return this.platform === "Windows"; + } + /** Returns `true` for visionOS host. */ + get isVision() { + return this.platform === "xrOS"; + } +} +HostWrapper.type = makeMetatype("app-store:host-wrapper"); +//# sourceMappingURL=host.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/localization.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/localization.js new file mode 100644 index 0000000..d7e0ee8 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/localization.js @@ -0,0 +1,437 @@ +import { makeMetatype } from "@jet/environment/util/metatype"; +import { AmpLocalization } from "../amp-localization/amp-localization"; +import { isNullOrEmpty } from "../json-parsing/server-data"; +import { Wrapper } from "./wrapper"; +import { isSome } from "@jet/environment/types/optional"; +import * as validation from "@jet/environment/json/validation"; +/** + * Wrapper around an object or `Localization` type. + * The wrapped object is implemented as part of a native app. + */ +export class LocalizationWrapper extends Wrapper { + constructor(loc, objectGraph) { + super(loc); + /** + * Path to localization file. + * The path is set when the localization file is loaded + * for the first time. + */ + this.locFile = null; + /** + * Instance of `AMPLocalization` providing server-side + * values for localized stirngs. + */ + this.ampLoc = new AmpLocalization(); + /** + * Localization strings cache. + * Cache and reuse values returned by + * wrapped `Localization` implementation. + */ + this.LOC_STRING_CACHE = {}; + this.objectGraph = objectGraph; + } + /** + * Returns the wrapped localization's identifier. + */ + get identifier() { + return this.implementation.identifier; + } + /** + * Returns the wrapped localization's safe identifier. + */ + get safeIdentifier() { + return this.implementation.identifier.split("_")[0]; + } + // endregion + // region Localization + /** + * Localizes a string replacing placehoders in key with values in the parameters dictionary + * @param key The loc key to look up + * @param params Parameters to replace in the loc string + * @return The localized string + */ + string(key, defaultValue) { + return this.implementation.string(key); + } + /** + * Localizes a string, and logs & throws an error if the key is a screamer. + * @param key The loc key to look up + * @return The localized string + */ + tryString(key) { + const value = this.implementation.string(key); + if (value === key || value === `**${key}**`) { + validation.context("tryString", () => { + validation.unexpectedType("coercedValue", "Localization key", key, null); + }); + throw new Error(`No value exists for localization key '${key}'`); + } + return value; + } + /** + * Localizes a string, and logs an error if the key is a screamer. + * @param key The loc key to look up + * @param fallback The fallback value for unlocalized keys, e.g. English value + * @return The localized string + */ + stringWithFallback(key, fallback) { + const value = this.implementation.string(key); + return value === `**AppStore.${key}**` ? fallback : value; + } + /** + * Localizes a string using a preferred locale. + * + * The implementation of this function is similar to `string(key:)` above, but with the option + * to prefer a particular locale. If one is provided, we augment the lookup key in the cache + * with the `locale` value. If one is not provided, we fallback to `string(key:)`. This makes it + * much easier to use this function directly, in place of `string(key:)` where necessary. + + * @param objectGraph The object graph, used to forward this call on if the required native function is unavailable. + * Can be removed for 2023. + * @param key The loc key to look up. + * @param locale The preferred locale to use for look up. Falls back to default, if unavailable. + * @param defaultValue A default value to use if nothing is found. + */ + stringForPreferredLocale(objectGraph, key, locale, defaultValue) { + if (isNullOrEmpty(locale)) { + return this.string(key, defaultValue); + } + const cacheKey = `${key}_${locale}`; + let value = this.LOC_STRING_CACHE[cacheKey]; + if (!value) { + value = this.implementation.stringForPreferredLocale(key, locale); + if (value && value !== key) { + this.LOC_STRING_CACHE[cacheKey] = value; + } + else { + const serverValue = this.ampLoc.localize(key); + if (serverValue !== key) { + value = serverValue; + } + else if (defaultValue) { + value = defaultValue; + } + else { + value = key; + } + } + } + return value; + } + /** + * Localize with appropriate plural form based on the count. + * + * Some languages have more plural forms than others. + * The full set of categories is "zero", "one", "two", "few", "many", and "other". + * + * The base loc key is used for "other" (the default). + * Otherwise the category is appended to the base loc key with a "." separator. + * + * http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html + * http://cldr.unicode.org/index/cldr-spec/plural-rules#TOC-Determining-Plural-Categories + * http://unicode.org/repos/cldr/trunk/specs/ldml/tr35-numbers.html#Language_Plural_Rules + * + * English loc keys + * key = "@@count@@ dogs"; // default, aka "plural" + * key.zero = "no dogs"; // used when count is 0 + * key.one = "@@count@@ dog"; // used when count is 1, aka "singular" + * + * @param key base loc key + * @param count number used to determine the plural form + * @param params (optional) substitution keys and values, "count" will be added if it's not already present + * @return localized string + */ + stringWithCount(key, count, params) { + let value = this.implementation.stringWithCount(key, count); + if (!value || value === key) { + const serverValue = this.ampLoc.localizeWithCount(this.objectGraph, key, count, params); + if (serverValue) { + value = serverValue; + } + } + return value; + } + /** + * A variation of `stringWithCount` that supports multiple plural forms. + * @param key base loc key + * @param counts numbers used to determine the plural forms + * @param params (optional) substitution keys and values, "count" will be added if it's not already present + * @return localized string + */ + stringWithCounts(key, counts, params) { + return this.implementation.stringWithCounts(key, counts); + } + /** + * Converts a string into its uppercased form. + * @param value The string to apply the uppercase to. + * @returns {string} The loacle-specific, uppercased form of the string. If for whatever reason the upper-casing cannot + * be applied, this function simply returns the input value. + */ + uppercased(value) { + if (!value) { + return null; + } + return value.toLocaleUpperCase(this.safeIdentifier); + } + /** + * Converts a number into a localized string + * + * @param n The number to convert + * @param decimalPlaces The number of decimal places to include. + * @return {string} The localized version of the number + */ + decimal(n, decimalPlaces) { + let value = this.implementation.decimal(n, decimalPlaces); + if (!value) { + if (typeof n === "number") { + value = `* ${n.toString()} *`; + } + else { + value = this.nullString(); + } + } + return value; + } + /** + * Converts a number of bytes into a localized file size string + * + * @param bytes The number of bytes to convert + * @return The localized file size string + */ + fileSize(bytes) { + let value = this.implementation.fileSize(bytes); + if (!value) { + value = this.nullString(); + } + return value; + } + /** + * Converts a number of bytes into a localized file size string + * + * @param count The number of bytes to convert + * @return The localized file size string + */ + formattedCount(count) { + let value = this.implementation.formattedCount(count); + if (!value) { + value = this.nullString(); + } + return value; + } + /** + * Converts a number into a formatted string representation using the preferred locale identifier. + * + * @param count The number to format. + * @param locale The locale identifier to prefer for lookup. + * @return The localized string. + */ + formattedCountForPreferredLocale(objectGraph, count, locale) { + if (isNullOrEmpty(locale)) { + return this.formattedCount(count); + } + let value = this.implementation.formattedCountForPreferredLocale(count, locale); + if (!value) { + value = this.nullString(); + } + return value; + } + /** + * Converts a date into a time ago label, showing how long ago + * the date occurred + * + * @param date The date object to convert + * @param context The context in which the date should be formatted + * @return The localized string representing the amount of time that has passed + */ + timeAgoWithContext(date, context) { + let value = this.implementation.timeAgoWithContext(date, context); + if (!value) { + value = this.nullString(); + } + return value; + } + /** + * Converts a date into a localized date string using the provided format + * + * @param format The format string describing how the date should be formatted + * @param date The date object to convert + * @return The localized string representing the date + */ + formatDate(format, date) { + let value = this.implementation.formatDate(format, date); + if (!value) { + value = this.nullString(); + } + return value; + } + formatDateWithContext(format, date, context) { + let value = this.implementation.formatDateWithContext(format, date, context); + if (!value) { + value = this.nullString(); + } + return value; + } + formatDateInSentence(sentence, format, date) { + let value = this.implementation.formatDateInSentence(sentence, format, date); + if (!value) { + value = this.nullString(); + } + return value; + } + /** + * Converts a date into a relative date, showing how long ago + * the date occurred + * + * @param date The date object to convert + * @return The localized string representing the amount of time that has passed + */ + relativeDate(date) { + let value = this.implementation.relativeDate(date); + if (!value) { + value = this.nullString(); + } + return value; + } + formatDuration(value, unit) { + let result = this.implementation.formatDuration(value, unit); + if (!result) { + result = this.nullString(); + } + return result; + } + // endregion + // region Private Methods + /** + * Applies a new localization file and localization dictionary as the new set of localizations + * + * @param file The file name of the file that is loaded + * @param localizations The localizations dictionary to use + * @param locale Current normalized locale which includes language code + */ + applyLocalizations(file, localizations, locale) { + if (this.isLocFileLoaded(file)) { + return; + } + this.locFile = file; + // The first 2 characters of normalized locale are the language code. + this.ampLoc.updateLocalizationData(localizations, locale.slice(0, 2)); + } + /** + * Checks if the named loc file is already loaded + * @param file The file name to check + * @return {boolean} True or false depending on whether the file name is loaded + */ + isLocFileLoaded(file) { + return this.locFile === file; + } + /** + * Normalizes the given bag language into a locale. + * @param language The language to normalize. + * @param storefrontIdentifier The storefront identifier to use. + * @return A locale to use. + */ + normalizedLocale(objectGraph, language, storefrontIdentifier) { + language = language.toLowerCase(); + switch (language) { + case "yue-hant": { + // Country code from the bag is not available in JS, so we use the storefront. + const macauStoreFrontIdentifier = objectGraph.props.asString("macauStorefrontIdentifier"); + if (typeof storefrontIdentifier === "string" && + typeof macauStoreFrontIdentifier === "string" && + storefrontIdentifier.indexOf(macauStoreFrontIdentifier) !== -1) { + return "zh-ma"; + } + else { + return "zh-hk"; + } + } + default: + return language; + } + } + nullString() { + return "* null *"; + } + // endregion + // region API + /** + * Loads the localizations from the JetPack. + */ + load(objectGraph) { + // Sanity check + if (objectGraph.bag.language === undefined || objectGraph.bag.language === null) { + throw new Error("Bag language is not available. Unable to load localizations."); + } + const locale = this.normalizedLocale(objectGraph, objectGraph.bag.language, objectGraph.client.storefrontIdentifier); + const locName = `local/${locale}`; + // Load localizations if needed + if (!this.isLocFileLoaded(locName)) { + const localizations = objectGraph.props.asDictionary(`localizations.${locale}`); + if (localizations !== undefined && localizations !== null) { + this.applyLocalizations(locName, localizations, locale); + } + else { + // Fallback to english + const fallbackLocalizations = objectGraph.props.asDictionary(`localizations.en-us`); + if (fallbackLocalizations !== undefined && fallbackLocalizations !== null) { + this.applyLocalizations(locName, fallbackLocalizations, locale); + } + } + } + } + /** + * Returns the localized name for the provided device type. + * The company policy seems to be to always use the branded, + * non-localized text, but this is just-in-case. + * @returns {string} The display name for the device. + */ + deviceDisplayName(objectGraph) { + if (objectGraph.client.isVision && isSome(objectGraph.host.deviceMarketingFamilyName)) { + return objectGraph.host.deviceMarketingFamilyName; + } + if (objectGraph.host.deviceLocalizedModel) { + return objectGraph.host.deviceLocalizedModel; + } + // TODO: <rdar://problem/33575833> Jet: Remove brand loc fallbacks + switch (objectGraph.client.deviceType) { + case "phone": + const localizedPhoneName = this.string("IPHONE_BRAND_NAME"); + if (localizedPhoneName === "IPHONE_BRAND_NAME") { + return "iPhone"; + } + return localizedPhoneName; + case "pad": + const localizedPadName = this.string("IPAD_BRAND_NAME"); + if (localizedPadName === "IPAD_BRAND_NAME") { + return "iPad"; + } + return localizedPadName; + case "tv": + const localizedTvName = this.string("APPLE_TV_BRAND_NAME"); + if (localizedTvName === "APPLE_TV_BRAND_NAME") { + return "Apple\u00a0TV"; + } + return localizedTvName; + case "watch": + const localizedWatchName = this.string("APPLE_WATCH_BRAND_NAME"); + if (localizedWatchName === "APPLE_WATCH_BRAND_NAME") { + return "Apple\u00a0Watch"; + } + return localizedWatchName; + case "mac": + const localizedMacName = this.string("MAC_BRAND_NAME"); + if (localizedMacName === "MAC_BRAND_NAME") { + return "Mac"; + } + return localizedMacName; + default: + return null; + } + } +} +// region Properties +/** + * Localization wrapper metatype to use with object graph. + */ +LocalizationWrapper.type = makeMetatype("app-store:loc-wrapper"); +//# sourceMappingURL=localization.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/properties.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/properties.js new file mode 100644 index 0000000..fa8b4e1 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/properties.js @@ -0,0 +1,74 @@ +/** + * Created by keithpk on 4/2/17. + */ +import { makeMetatype } from "@jet/environment/util/metatype"; +import * as serverData from "../json-parsing/server-data"; +import { Wrapper } from "./wrapper"; +export class PropertiesWrapper extends Wrapper { + /** + * Returns the raw underlying value for the key path + * @param path The path of the property to lookup + * @return {JSONValue | null} The resulting value or null + */ + value(path) { + return serverData.traverse(this.implementation, path); + } + /** + * Returns whether a property is enabled or not. This also + * looks in the clientFeatures key as well for client-enabled + * features + * + * @param key The key to look up + * @return {boolean} The boolean result or false if no value was found for the key + */ + enabled(key) { + const propertyValue = this.value(key); + if (typeof propertyValue !== "undefined") { + return Boolean(propertyValue); + } + return Boolean(this.implementation.clientFeatures[key]); + } + /** + * Syntactic sugar for !enabled(key). + * + * @param key The key to look up + * @return {boolean} The boolean result or true if no value was found for the key + */ + isNotEnabled(key) { + return !this.enabled(key); + } + /** + * Returns the value of the path coerced as a dictionary + * @param path The path to look up + * @return {JSONData|null} The dictionary or null if not found + */ + asDictionary(path) { + return serverData.asDictionary(this.implementation, path); + } + /** + * Returns the value of the path coerced as a string + * @param path The path to look up + * @return {string|null} The string or null if not found + */ + asString(path) { + return serverData.asString(this.implementation, path); + } + /** + * Returns the value of the path coerced as a number + * @param path The path to look up + * @return {string|null} The number or null if not found + */ + asNumber(path) { + return serverData.asNumber(this.implementation, path); + } + /** + * Returns the value of the path coerced as an array + * @param path The path to look up + * @return {string|null} The array or empty if not found + */ + asArray(path) { + return serverData.asArrayOrEmpty(this.implementation, path); + } +} +PropertiesWrapper.type = makeMetatype("app-store:props-wrapper"); +//# sourceMappingURL=properties.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/storage.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/storage.js new file mode 100644 index 0000000..2643e0d --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/storage.js @@ -0,0 +1,22 @@ +/** + * Creates and returns a mock Storage object. + * @return A new mock Storage object. + */ +import { makeMetatype } from "@jet/environment/util/metatype"; +import { Wrapper } from "./wrapper"; +export class StorageWrapper extends Wrapper { + retrieveString(key) { + const value = this.implementation.retrieveString(key); + if ((value === null || value === void 0 ? void 0 : value.length) > 0 && value !== "<null>") { + return value; + } + else { + return null; + } + } + storeString(key, value) { + this.implementation.storeString(value, key); // flip is deliberate. + } +} +StorageWrapper.type = makeMetatype("app-store:storage-wrapper"); +//# sourceMappingURL=storage.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/wrapper.js b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/wrapper.js new file mode 100644 index 0000000..f03e835 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/wrappers/wrapper.js @@ -0,0 +1,6 @@ +export class Wrapper { + constructor(implementation) { + this.implementation = implementation; + } +} +//# sourceMappingURL=wrapper.js.map
\ No newline at end of file |