init commit

1 files changed, 2820 insertions, 0 deletions

diff --git a/node_modules/@jet-app/app-store/tmp/src/common/content/content.js b/node_modules/@jet-app/app-store/tmp/src/common/content/content.js
new file mode 100644
index 0000000..72b5ae1
--- /dev/null
+++ b/node_modules/@jet-app/app-store/tmp/src/common/content/content.js
@@ -0,0 +1,2820 @@
+import * as validation from "@jet/environment/json/validation";
+import { isNothing, isSome, unwrapOptional as unwrap } from "@jet/environment/types/optional";
+import * as models from "../../api/models";
+import * as modelsBase from "../../api/models/base";
+import * as modelsShelves from "../../api/models/shelves";
+import { ads } from "../../api/typings/constants";
+import * as derivedData from "../../foundation/json-parsing/derived-data";
+import * as serverData from "../../foundation/json-parsing/server-data";
+import * as mediaAttributes from "../../foundation/media/attributes";
+import * as mediaDataFetching from "../../foundation/media/data-fetching";
+import * as mediaPlatformAttributes from "../../foundation/media/platform-attributes";
+import * as mediaRelationship from "../../foundation/media/relationships";
+import * as mediaUrlBuilder from "../../foundation/media/url-builder";
+import { Parameters, Path, Protocol } from "../../foundation/network/url-constants";
+import * as color from "../../foundation/util/color-util";
+import * as dateUtil from "../../foundation/util/date-util";
+import { unreachable } from "../../foundation/util/errors";
+import { isDefinedNonNullNonEmpty } from "@apple-media-services/media-api";
+import { editorialCardFromData } from "../../foundation/media/associations";
+import * as client from "../../foundation/wrappers/client";
+import * as videoDefaults from "../constants/video-constants";
+import * as filtering from "../filtering";
+import * as lockups from "../lockups/lockups";
+import * as metricsHelpersImpressions from "../metrics/helpers/impressions";
+import * as metricsHelpersLocation from "../metrics/helpers/location";
+import * as metricsHelpersMedia from "../metrics/helpers/media";
+import * as offers from "../offers/offers";
+import * as productPageVariants from "../product-page/product-page-variants";
+import * as artwork from "./artwork/artwork";
+import * as contentAttributes from "./attributes";
+import * as contentDeviceFamily from "./device-family";
+import * as sad from "./sad";
+import { isFeatureEnabledForCurrentUser } from "../util/lottery";
+class RunnabilityInfo {
+    constructor() {
+        this.runsOnIntel = true;
+        this.runsOnAppleSilicon = true;
+        this.requiresRosetta = false;
+    }
+}
+/**
+ * Determines a reasonable artwork use case from a given shelf style
+ *
+ * @param shelfStyle The shelf style to consider
+ */
+export function artworkUseCaseFromShelfStyle(objectGraph, shelfStyle) {
+    switch (shelfStyle) {
+        case "inAppPurchaseLockup":
+        case "appShowcase":
+        case "smallLockup": {
+            return 1 /* ArtworkUseCase.LockupIconSmall */;
+            break;
+        }
+        case "mediumLockup": {
+            return 2 /* ArtworkUseCase.LockupIconMedium */;
+            break;
+        }
+        case "largeLockup": {
+            return 3 /* ArtworkUseCase.LockupIconLarge */;
+            break;
+        }
+        default: {
+            return 0 /* ArtworkUseCase.Default */;
+        }
+    }
+}
+/**
+ * Convert an API artwork object into an Artwork model object.
+ * @param artwork The artwork in API format.
+ * @returns An `Artwork` object.
+ */
+export function artworkFromApiArtwork(objectGraph, artworkData, options) {
+    return validation.context("artworkFromApiArtwork", () => {
+        var _a, _b, _c;
+        const allowingTransparency = serverData.isDefinedNonNull(options.allowingTransparency)
+            ? options.allowingTransparency
+            : false;
+        const useJoeColorDefault = objectGraph.client.isVision || objectGraph.client.isWeb;
+        const withJoeColorPlaceholder = serverData.isDefinedNonNull(options.withJoeColorPlaceholder)
+            ? options.withJoeColorPlaceholder
+            : useJoeColorDefault;
+        const artworkUrl = serverData.asString(artworkData, "url");
+        if (serverData.isNull(artworkUrl)) {
+            return null;
+        }
+        // Whether wide gamut is supported
+        const supportsWideGamut = serverData.asBooleanOrFalse(artworkData, "hasP3");
+        // Add base variant
+        const variants = [
+            artwork.createArtworkVariantForClient(objectGraph, allowingTransparency, supportsWideGamut, options.useCase),
+        ];
+        // Add layered image variant
+        const supportsLayeredImage = serverData.asBooleanOrFalse(artworkData, "supportsLayeredImage");
+        if (supportsLayeredImage && (objectGraph.client.isTV || objectGraph.client.isVision)) {
+            variants.push(artwork.createArtworkVariantForFormat(objectGraph, "lcr", supportsWideGamut, options.useCase));
+        }
+        // Artwork Placeholder Color
+        // If we indicate the image could be transparent then we don't want a placeholder background
+        let placeholderBackgroundColor = null;
+        if (allowingTransparency) {
+            placeholderBackgroundColor = color.named("clear");
+        }
+        else if (withJoeColorPlaceholder) {
+            const joeColorHexSet = joeColorHexSetFromData(artworkData);
+            const placeholderColorHex = (_b = (_a = options.joeColorPlaceholderSelectionLogic) === null || _a === void 0 ? void 0 : _a.call(options, joeColorHexSet)) !== null && _b !== void 0 ? _b : serverData.asString(artworkData, "bgColor");
+            const apiBackgroundColor = color.fromHex(placeholderColorHex);
+            if (!serverData.isNull(apiBackgroundColor)) {
+                placeholderBackgroundColor = apiBackgroundColor;
+            }
+        }
+        // If we don't want clear, joe color, or joe color fails to parse then fall back to default background
+        if (serverData.isNull(placeholderBackgroundColor) && !objectGraph.client.isVision) {
+            placeholderBackgroundColor = color.named("placeholderBackground");
+        }
+        const textColorKey = (_c = options.overrideTextColorKey) !== null && _c !== void 0 ? _c : "textColor1";
+        const apiTextColor = color.fromHex(serverData.asString(artworkData, textColorKey));
+        const artworkModel = new modelsBase.Artwork(artworkUrl, options.overrideWidth || serverData.asNumber(artworkData, "width"), options.overrideHeight || serverData.asNumber(artworkData, "height"), variants);
+        artworkModel.backgroundColor = placeholderBackgroundColor;
+        artworkModel.checksum = serverData.asString(artworkData, "checksum");
+        if (serverData.isDefinedNonNull(apiTextColor)) {
+            artworkModel.textColor = apiTextColor;
+        }
+        if (serverData.isDefinedNonNull(options.style)) {
+            artworkModel.style = options.style;
+        }
+        if (serverData.isDefinedNonNull(options.cropCode)) {
+            artworkModel.crop = options.cropCode;
+        }
+        if (serverData.isDefinedNonNull(options.contentMode)) {
+            artworkModel.contentMode = options.contentMode;
+        }
+        return artworkModel;
+    });
+}
+export function impressionableAppIconFromData(objectGraph, data, metricsOptions, artworkOptions) {
+    return validation.context("impressionableAppIconFromData", () => {
+        const rawArtwork = iconFromData(objectGraph, data, artworkOptions);
+        if (!serverData.isDefinedNonNull(rawArtwork)) {
+            return null;
+        }
+        const icon = new models.ImpressionableArtwork(rawArtwork);
+        const title = mediaAttributes.attributeAsString(data, "name");
+        const metricsImpressionOptions = metricsHelpersImpressions.impressionOptions(objectGraph, data, title, metricsOptions);
+        metricsHelpersImpressions.addImpressionFields(objectGraph, icon, metricsImpressionOptions);
+        return icon;
+    });
+}
+/**
+ * Batch method for `impressionableAppIconFromData`. Doesn't push location stack or increment location counter, matching other behavior with other icon grids.
+ * @param dataCollection Data container array with app data.
+ * @param metricsOptions Metrics blob containing information about page and location.
+ * @returns Array of `ImpressionableArtwork`
+ */
+export function impressionableAppIconsFromDataCollection(objectGraph, dataCollection, metricsOptions, artworkOptions) {
+    return validation.context("impressionableAppIconFromData", () => {
+        const icons = [];
+        if (serverData.isNullOrEmpty(metricsOptions.targetType)) {
+            metricsOptions.targetType = "artwork";
+        }
+        for (const data of dataCollection) {
+            const icon = impressionableAppIconFromData(objectGraph, data, metricsOptions, artworkOptions);
+            if (icon) {
+                icons.push(icon);
+                metricsHelpersLocation.nextPosition(metricsOptions.locationTracker);
+            }
+        }
+        return icons;
+    });
+}
+/**
+ * Defines possible use cases for SearchChartOrCategoryBrick.
+ */
+export var SearchChartOrCategoryBrickUseCase;
+(function (SearchChartOrCategoryBrickUseCase) {
+    SearchChartOrCategoryBrickUseCase[SearchChartOrCategoryBrickUseCase["seeAllPage"] = 0] = "seeAllPage";
+    SearchChartOrCategoryBrickUseCase[SearchChartOrCategoryBrickUseCase["categoryBreakout"] = 1] = "categoryBreakout";
+    SearchChartOrCategoryBrickUseCase[SearchChartOrCategoryBrickUseCase["other"] = 2] = "other";
+})(SearchChartOrCategoryBrickUseCase || (SearchChartOrCategoryBrickUseCase = {}));
+/**
+ * Gets all possible artwork that this chart or category can show
+ * @param objectGraph
+ * @param data
+ * @param isForSeeAllPage Whether or not the chart or category is on the see-all page or not;
+ * this is because the see-all page should always have the `Density1` style
+ * @param style The style of the chart or category that will be rendered
+ * @returns All permutations of artowrk that the chart or category can show
+ */
+export function searchChartOrCategoryArtworkFromData(objectGraph, data, useCase, style) {
+    const artworkPath = "editorialArtwork.searchCategoryBrick";
+    const artworkData = contentAttributes.contentAttributeAsDictionary(objectGraph, data, artworkPath);
+    if (serverData.isNullOrEmpty(artworkData)) {
+        return null;
+    }
+    let artworkStyle = style;
+    if (useCase === SearchChartOrCategoryBrickUseCase.seeAllPage) {
+        artworkStyle = models.GenericSearchPageShelfDisplayStyleDensity.Density1;
+    }
+    /// Crops = [LTR crop, RTL crop]
+    /// ContentModes = [ContentMode for LTR crop, ContentMode for RTL crop]
+    /// Note: These must be the same length
+    let crops = [];
+    let contentModes = [];
+    switch (artworkStyle) {
+        /// Tile
+        case models.GenericSearchPageShelfDisplayStyleDensity.Density1:
+            const width = useCase === SearchChartOrCategoryBrickUseCase.categoryBreakout ? "1191" : "2350";
+            artworkData["width"] = width;
+            artworkData["height"] = "670";
+            crops = ["SCB.ApSCBL01", "SCB.ApSCBL03"];
+            contentModes = [modelsBase.ArtworkContentMode.right, modelsBase.ArtworkContentMode.left];
+            break;
+        /// Pill
+        case models.GenericSearchPageShelfDisplayStyleDensity.Density2:
+            artworkData["width"] = "2482";
+            artworkData["height"] = "670";
+            crops = ["SCB.ApSCBS01", "SCB.ApSCBS02"];
+            contentModes = [modelsBase.ArtworkContentMode.left, modelsBase.ArtworkContentMode.right];
+            break;
+        /// Round
+        case models.GenericSearchPageShelfDisplayStyleDensity.Density3:
+            artworkData["width"] = "670";
+            artworkData["height"] = "670";
+            crops = ["cc"];
+            contentModes = [modelsBase.ArtworkContentMode.scaleAspectFit];
+            break;
+        default:
+            break;
+    }
+    return crops.map((crop, index) => {
+        return artworkFromApiArtwork(objectGraph, artworkData, {
+            cropCode: crop,
+            contentMode: index < contentModes.length ? contentModes[index] : null,
+            useCase: 0 /* ArtworkUseCase.Default */,
+            withJoeColorPlaceholder: true,
+        });
+    });
+}
+/**
+ * Create an icon artwork from the provided data.
+ * @param objectGraph The object graph.
+ * @param data The data object to pull icon data from.
+ * @param artworkOptions The options for creating the artwork.
+ * @param clientIdentifierOverride A client identifier override.
+ * @param productVariantData The product variant data to use to select the icon.
+ * @param attributePlatformOverride An override platform, from which to fetch the icon.
+ * @returns An `Artwork` object representing the icon.
+ */
+export function iconFromData(objectGraph, data, artworkOptions, clientIdentifierOverride, productVariantData, attributePlatformOverride = undefined) {
+    return validation.context("iconFromData", () => {
+        if (!data) {
+            validation.unexpectedNull("ignoredValue", "data");
+            return null;
+        }
+        const attributePlatform = attributePlatformOverride !== null && attributePlatformOverride !== void 0 ? attributePlatformOverride : iconAttributePlatform(objectGraph, data, clientIdentifierOverride);
+        const usePrerenderedIconArtwork = shouldUsePrerenderedIconArtwork(objectGraph);
+        // The preferred client identifier to use when selecting the artwork.
+        // This client identifier here ensures that we always prefer pill artwork for messages and circular artwork for watch / vision.
+        // Unless there's an override specified where another artwork type needs to be used (for example, in developer pages).
+        const preferredClientIdentifier = clientIdentifierOverride || objectGraph.host.clientIdentifier;
+        // Watch
+        const watchIcon = watchIconFromData(objectGraph, data, artworkOptions, preferredClientIdentifier, usePrerenderedIconArtwork, attributePlatform);
+        if (isSome(watchIcon)) {
+            return watchIcon;
+        }
+        // Messages
+        const messagesIcon = messagesIconFromData(objectGraph, data, artworkOptions, preferredClientIdentifier, attributePlatform);
+        if (isSome(messagesIcon)) {
+            return messagesIcon;
+        }
+        // In-App Purchases
+        const iapIcon = inAppPurchaseIconFromData(objectGraph, data, artworkOptions);
+        if (isSome(iapIcon)) {
+            return iapIcon;
+        }
+        // Bundles
+        const bundlesIcon = bundlesIconFromData(objectGraph, data, artworkOptions, usePrerenderedIconArtwork);
+        if (isSome(bundlesIcon)) {
+            return bundlesIcon;
+        }
+        // Calculate variant data if one wasn't provided from caller.
+        if (serverData.isNull(productVariantData)) {
+            productVariantData = productPageVariants.productVariantDataForData(objectGraph, data);
+        }
+        const artworkData = contentAttributes.customAttributeAsDictionary(objectGraph, data, productVariantData, "artwork", attributePlatform);
+        // tvOS
+        const tvIcon = tvIconFromData(objectGraph, artworkData, artworkOptions, preferredClientIdentifier, attributePlatform);
+        if (isSome(tvIcon)) {
+            return tvIcon;
+        }
+        // visionOS
+        const visionIcon = visionIconFromData(objectGraph, artworkData, artworkOptions, preferredClientIdentifier, attributePlatform);
+        if (isSome(visionIcon)) {
+            return visionIcon;
+        }
+        // macOS & iOS
+        return macOSOriOSIconFromData(objectGraph, data, artworkData, artworkOptions, usePrerenderedIconArtwork, productVariantData, attributePlatform);
+    });
+}
+/**
+ * Determines if a client is capable of showing pre-rendered icon artwork, and if the relevant
+ * feature / bag flags are enabled.
+ * @param objectGraph Current object graph
+ * @returns True if we should use prerendered icon artwork.
+ */
+export function shouldUsePrerenderedIconArtwork(objectGraph) {
+    const clientSupportsPrerenderedIconArtwork = objectGraph.client.isWatch || objectGraph.client.isiOS || objectGraph.client.isMac || objectGraph.client.isWeb;
+    const isEnabledForUser = isFeatureEnabledForCurrentUser(objectGraph, objectGraph.bag.iconArtworkRolloutRate);
+    return (isEnabledForUser &&
+        objectGraph.bag.enableIconArtwork &&
+        objectGraph.client.isIconArtworkCapable &&
+        clientSupportsPrerenderedIconArtwork);
+}
+function watchIconFromData(objectGraph, data, artworkOptions, clientIdentifier, usePrerenderedIconArtwork, attributePlatform) {
+    if (clientIdentifier !== client.watchIdentifier &&
+        !contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isStandaloneForWatchOS") &&
+        !objectGraph.client.isWatch) {
+        return null;
+    }
+    // Attempt to use pre-rendered circular icon artwork first, if applicable
+    if (usePrerenderedIconArtwork) {
+        const iconArtworkData = mediaPlatformAttributes.platformAttributeAsDictionary(data, attributePlatform, "circularIconArtwork");
+        if (isSome(iconArtworkData)) {
+            return artworkFromApiArtwork(objectGraph, iconArtworkData, {
+                ...artworkOptions,
+                style: "roundPrerendered",
+                cropCode: "bb",
+                withJoeColorPlaceholder: true,
+            });
+        }
+    }
+    // Fallback to the legacy icon artwork
+    const artworkData = mediaPlatformAttributes.platformAttributeAsDictionary(data, attributePlatform, "circularArtwork");
+    if (isSome(artworkData)) {
+        const style = usePrerenderedIconArtwork ? "roundPrerendered" : "round";
+        const cropCode = usePrerenderedIconArtwork ? "ic" : undefined;
+        return artworkFromApiArtwork(objectGraph, artworkData, {
+            ...artworkOptions,
+            style: style,
+            cropCode: cropCode,
+            withJoeColorPlaceholder: true,
+        });
+    }
+    return null;
+}
+function messagesIconFromData(objectGraph, data, artworkOptions, clientIdentifier, attributePlatform) {
+    const isHiddenFromSpringboard = isHiddenFromSpringboardFromData(objectGraph, data);
+    const hasMessagesExtension = hasMessagesExtensionFromData(objectGraph, data);
+    const shouldShowMessagesIcon = hasMessagesExtension && (clientIdentifier === client.messagesIdentifier || isHiddenFromSpringboard);
+    const artworkData = mediaPlatformAttributes.platformAttributeAsDictionary(data, attributePlatform, "ovalArtwork");
+    if (shouldShowMessagesIcon && serverData.isDefinedNonNull(artworkData)) {
+        return artworkFromApiArtwork(objectGraph, artworkData, {
+            ...artworkOptions,
+            style: "pill",
+        });
+    }
+    return null;
+}
+function inAppPurchaseIconFromData(objectGraph, data, artworkOptions) {
+    if (data.type !== "in-apps") {
+        return null;
+    }
+    const artworkData = mediaAttributes.attributeAsDictionary(data, "artwork");
+    if (isSome(artworkData)) {
+        return artworkFromApiArtwork(objectGraph, artworkData, {
+            ...artworkOptions,
+            style: "iap",
+        });
+    }
+    return null;
+}
+function bundlesIconFromData(objectGraph, data, artworkOptions, usePrerenderedIconArtwork) {
+    if (data.type !== "app-bundles") {
+        return null;
+    }
+    // Attempt to use pre-rendered icon artwork first, if applicable
+    if (usePrerenderedIconArtwork) {
+        const iconArtworkData = mediaAttributes.attributeAsDictionary(data, "iconArtwork");
+        if (isSome(iconArtworkData)) {
+            return artworkFromApiArtwork(objectGraph, iconArtworkData, {
+                ...artworkOptions,
+                style: "roundedRectPrerendered",
+                cropCode: "bb",
+            });
+        }
+    }
+    // Fallback to the legacy icon artwork
+    const artworkData = mediaAttributes.attributeAsDictionary(data, "artwork");
+    if (isSome(artworkData)) {
+        const style = usePrerenderedIconArtwork ? "roundedRectPrerendered" : "roundedRect";
+        const cropCode = usePrerenderedIconArtwork ? "ia" : undefined;
+        return artworkFromApiArtwork(objectGraph, artworkData, {
+            ...artworkOptions,
+            style: style,
+            cropCode: cropCode,
+            allowingTransparency: true,
+        });
+    }
+    return null;
+}
+function tvIconFromData(objectGraph, artworkData, artworkOptions, clientIdentifier, attributePlatform) {
+    if (attributePlatform !== "appletvos" && clientIdentifier !== client.tvIdentifier) {
+        return null;
+    }
+    return artworkFromApiArtwork(objectGraph, artworkData, {
+        ...artworkOptions,
+        style: "tvRect",
+    });
+}
+function visionIconFromData(objectGraph, artworkData, artworkOptions, clientIdentifier, attributePlatform) {
+    if (attributePlatform !== "xros" && clientIdentifier !== "VisionAppStore" /* ClientIdentifier.VisionAppStore */) {
+        return null;
+    }
+    return artworkFromApiArtwork(objectGraph, artworkData, {
+        ...artworkOptions,
+        style: "round",
+    });
+}
+function macOSOriOSIconFromData(objectGraph, data, artworkData, artworkOptions, usePrerenderedIconArtwork, productVariantData, attributePlatform) {
+    const isMac = attributePlatform === "osx";
+    const allowTransparency = isMac && !preprocessor.GAMES_TARGET;
+    // Attempt to use pre-rendered icon artwork first, if applicable
+    if (usePrerenderedIconArtwork) {
+        const iconArtworkData = contentAttributes.customAttributeAsDictionary(objectGraph, data, productVariantData, "iconArtwork", attributePlatform);
+        if (isSome(iconArtworkData)) {
+            return artworkFromApiArtwork(objectGraph, iconArtworkData, {
+                ...artworkOptions,
+                style: "roundedRectPrerendered",
+                cropCode: "bb",
+                allowingTransparency: allowTransparency,
+            });
+        }
+    }
+    // Fallback to the standard icon artwork
+    let style;
+    let cropCode;
+    if (usePrerenderedIconArtwork) {
+        style = "roundedRectPrerendered";
+        cropCode = isMac ? "ib" : "ia";
+    }
+    else {
+        style = isMac ? "unadorned" : "roundedRect";
+        cropCode = "bb";
+    }
+    return artworkFromApiArtwork(objectGraph, artworkData, {
+        ...artworkOptions,
+        style: style,
+        cropCode: cropCode,
+        allowingTransparency: allowTransparency,
+    });
+}
+/**
+ * Determines the best attribute platform to use for the icon.
+ * @param objectGraph Current object graph
+ * @param data The product data
+ * @param clientIdentifierOverride The client identifier override to use, if any
+ * @returns
+ */
+export function iconAttributePlatform(objectGraph, data, clientIdentifierOverride) {
+    switch (clientIdentifierOverride) {
+        case client.watchIdentifier:
+        case client.messagesIdentifier: {
+            return "ios";
+        }
+        case client.tvIdentifier: {
+            return "appletvos";
+        }
+        case "VisionAppStore" /* ClientIdentifier.VisionAppStore */: {
+            return "xros";
+        }
+        default: {
+            return contentAttributes.bestAttributePlatformFromData(objectGraph, data, clientIdentifierOverride);
+        }
+    }
+}
+/**
+ * Determine the media platform, given the app platform and screenshot type.
+ * @param appPlatform The app platform specific to this media.
+ * @param type The response screenshot type, which is applicable for both screenshots and trailers, for this media.
+ * @param supplementaryAppPlatforms
+ * @returns {MediaPlatform} The configured media platform object.
+ * TODO: legacy_export
+ */
+export function mediaPlatformForTypeAndAppPlatform(objectGraph, appPlatform, type, supplementaryAppPlatforms) {
+    if (!appPlatform) {
+        return null;
+    }
+    const systemImageName = systemImageNameForAppPlatform(appPlatform);
+    const deviceCornerRadius = deviceCornerRadiusFactorForMediaType(objectGraph, type);
+    const deviceBorderThickness = deviceBorderThicknessForMediaType(objectGraph, type);
+    const outerDeviceCornerRadius = deviceOuterCornerRadiusFactorForMediaType(objectGraph, type);
+    return new modelsBase.MediaPlatform(appPlatform, type, systemImageName, supplementaryAppPlatforms, deviceCornerRadius, deviceBorderThickness, outerDeviceCornerRadius);
+}
+/**
+ * Configures the trailers object from the platform data.
+ * @param data The platform data to use.
+ * @param videoConfiguration config to use for the trailers
+ * @param metricsOptions The metrics options to use.
+ * @param adamId The adamId for the lockup.
+ * @param isAd Whether the trailers are for an ad lockup. Defaults to false.
+ * @param cropCode The crop code to use for the video preview.
+ * @returns {Trailers} The configured trailers object.
+ */
+export function trailersFromData(objectGraph, data, videoConfiguration, metricsOptions, adamId, isAd = false, cropCode) {
+    const platformVideos = platformVideoPreviewFromData(objectGraph, data, videoConfiguration, null, null, isAd, cropCode);
+    if (!platformVideos) {
+        return null;
+    }
+    const videoPreviews = platformVideos.videos;
+    const trailerVideos = [];
+    if (videoPreviews && videoPreviews.length > 0) {
+        for (const trailerVideo of videoPreviews) {
+            metricsHelpersMedia.addMetricsEventsToVideo(objectGraph, trailerVideo, {
+                ...metricsOptions,
+                id: adamId,
+            });
+            trailerVideos.push(trailerVideo);
+        }
+    }
+    let trailers = null;
+    if (trailerVideos.length > 0) {
+        trailers = new modelsShelves.Trailers();
+        trailers.videos = trailerVideos;
+        trailers.mediaPlatform = platformVideos.mediaPlatform;
+    }
+    return trailers;
+}
+/**
+ * A convenience class for encapsulating a `Video` that is tied to a specific `MediaPlatform`.
+ */
+class PlatformVideos {
+    constructor(videos, mediaPlatform) {
+        this.videos = videos;
+        this.mediaPlatform = mediaPlatform;
+    }
+}
+/**
+ * Finds the best platform video previews to use for the given parameters.
+ * @param data The data from which to derive the platform videos.
+ * @param videoConfiguration A video configuration to use for the videos
+ * @param includedAppPlatforms If provided, restricts the resulting platform videos to only these platforms
+ * @param productVariantData
+ * @param isAd Whether the video preview data is for an ad. Defaults to false.
+ * @param cropCode The crop code to use for the preview artwork.
+ * @returns The best available platform videos.
+ */
+export function platformVideoPreviewFromData(objectGraph, data, videoConfiguration, includedAppPlatforms = null, productVariantData = null, isAd = false, cropCode) {
+    return validation.context("platformVideoPreviewFromData", () => {
+        if (serverData.isNull(productVariantData)) {
+            productVariantData = productPageVariants.productVariantDataForData(objectGraph, data); // create variant data if not provided.
+        }
+        const videoPreviewsByTypeData = videoPreviewsByTypeFromData(objectGraph, data, productVariantData, isAd);
+        const videoPreviewsByType = {};
+        if (!videoPreviewsByTypeData) {
+            return null;
+        }
+        let sortedAppPlatforms = sortedAppPlatformsFromData(objectGraph, data, objectGraph.host.clientIdentifier, objectGraph.client.deviceType);
+        if (serverData.isDefinedNonNull(includedAppPlatforms)) {
+            // If we have a restricted set of included app platforms, use those platforms
+            // to build our sortedAppPlatforms array in the proper sort order
+            const includedSortedAppPlatforms = [];
+            for (const appPlatform of sortedAppPlatforms) {
+                if (includedAppPlatforms.includes(appPlatform)) {
+                    includedSortedAppPlatforms.push(appPlatform);
+                }
+            }
+            sortedAppPlatforms = includedSortedAppPlatforms;
+        }
+        if (sortedAppPlatforms.length === 0) {
+            return null;
+        }
+        for (const appPlatform of sortedAppPlatforms) {
+            const types = mediaTypesForAppPlatform(objectGraph, appPlatform, objectGraph.client.screenSize);
+            for (const type of Object.keys(videoPreviewsByTypeData)) {
+                const videosDataForType = serverData.asArrayOrEmpty(videoPreviewsByTypeData, type);
+                const videosForType = [];
+                for (const video of videosDataForType) {
+                    const previewFrame = serverData.asDictionary(video, "previewFrame");
+                    if (!previewFrame) {
+                        validation.unexpectedNull("ignoredValue", "object", `videoPreviewsByType.${type}.previewFrame`);
+                        continue;
+                    }
+                    const videoUrl = serverData.asString(video, "video");
+                    if (!videoUrl) {
+                        validation.unexpectedNull("ignoredValue", "string", `videoPreviewsByType.${type}.video`);
+                        continue;
+                    }
+                    const preview = artwork.createArtworkForResource(objectGraph, serverData.asString(previewFrame, "url"), serverData.asNumber(previewFrame, "width"), serverData.asNumber(previewFrame, "height"), null, null, serverData.asString(previewFrame, "checksum"));
+                    if (serverData.isDefinedNonNull(cropCode)) {
+                        preview.crop = cropCode;
+                    }
+                    videosForType.push(new modelsBase.Video(videoUrl, preview, videoConfiguration));
+                }
+                videoPreviewsByType[type] = videosForType;
+            }
+            for (const type of types) {
+                if (videoPreviewsByType[type]) {
+                    return new PlatformVideos(videoPreviewsByType[type], mediaPlatformForTypeAndAppPlatform(objectGraph, appPlatform, type));
+                }
+            }
+        }
+        return null;
+    });
+}
+/**
+ * Configures the videos from some platform data.
+ * @param data  The store platform data.
+ * @returns A list of `Video` objects.
+ */
+export function videoPreviewsFromData(objectGraph, data) {
+    return validation.context("videoPreviewsFromApiPlatformData", () => {
+        const platformVideos = platformVideoPreviewFromData(objectGraph, data, videoDefaults.defaultVideoConfiguration(objectGraph));
+        if (platformVideos) {
+            return platformVideos.videos;
+        }
+        else {
+            return [];
+        }
+    });
+}
+/**
+ * Determines the `AppPlatform` to use, in order to determine appropriate `MediaType` for media.
+ * @param {AppPlatform} appPlatform The underlying `AppPlatform`.
+ * @returns {AppPlatform} The `AppPlatform` that we map to in order to select the appropriate `MediaType`.
+ */
+function selectionAppPlatformFromAppPlatform(objectGraph, appPlatform) {
+    if (appPlatform === "messages") {
+        switch (objectGraph.client.deviceType) {
+            case "pad": {
+                return "pad";
+            }
+            default: {
+                return "phone";
+            }
+        }
+    }
+    return appPlatform;
+}
+/**
+ * Provide the caller with an ordered array of screenshots for a given context. The first object can be used in search
+ * lockups, and the array will only contain screenshots for the supported app platforms.
+ *
+ * @param data The api product data (containing supported app platforms and screenshots)
+ * @param useCase
+ * @param includedAppPlatforms Optionally, a list of app platforms to confine the screenshots to.
+ * @param clientIdentifierOverride
+ * @param productVariantData
+ * @param isAd Whether the screenshots are being gathered for an ad lockup. Defaults to false.
+ * @returns An ordered array of screenshots for display on a product page
+ * */
+export function screenshotsFromData(objectGraph, data, useCase, includedAppPlatforms = null, clientIdentifierOverride, productVariantData, isAd = false, cropCode) {
+    return validation.context("screenshotsFromData", () => {
+        const screenshots = [];
+        if (serverData.isNull(productVariantData)) {
+            productVariantData = productPageVariants.productVariantDataForData(objectGraph, data); // resolve if not resolved by caller.
+        }
+        let sortedAppPlatforms = includedAppPlatforms;
+        if (!sortedAppPlatforms || sortedAppPlatforms.length === 0) {
+            const preferredClientIdentifier = clientIdentifierOverride || objectGraph.host.clientIdentifier;
+            let preferredDeviceType = objectGraph.client.deviceType;
+            if (preferredClientIdentifier === client.watchIdentifier) {
+                preferredDeviceType = "watch";
+            }
+            if (clientIdentifierOverride === "VisionAppStore" /* ClientIdentifier.VisionAppStore */ ||
+                clientIdentifierOverride === "com.apple.visionproapp" /* ClientIdentifier.VisionCompanion */) {
+                preferredDeviceType = "vision";
+            }
+            sortedAppPlatforms = sortedAppPlatformsFromData(objectGraph, data, preferredClientIdentifier, preferredDeviceType);
+        }
+        for (const appPlatform of sortedAppPlatforms) {
+            const supplementaryAppPlatforms = [];
+            let screenshotData;
+            if (appPlatform === "messages") {
+                screenshotData = messagesScreenshotsFromData(objectGraph, data, "ios");
+                if (supportsFunCameraFromData(objectGraph, data, "ios")) {
+                    supplementaryAppPlatforms.push("faceTime");
+                }
+            }
+            else if (appPlatform === "tv" && !objectGraph.host.isTV) {
+                // For tvOS screenshots displayed on other platforms.
+                screenshotData = screenshotsByTypeFromData(objectGraph, data, productVariantData, isAd, "appletvos");
+            }
+            else if (appPlatform === "vision" && !objectGraph.host.isVision) {
+                // For visionOS screenshots displayed on other platforms.
+                screenshotData = screenshotsByTypeFromData(objectGraph, data, productVariantData, isAd, "xros");
+            }
+            else if (appPlatform === "mac" && !objectGraph.host.isMac) {
+                // For Mac screenshots displayed on other platforms.
+                screenshotData = screenshotsByTypeFromData(objectGraph, data, productVariantData, isAd, "osx");
+            }
+            else if ((appPlatform === "phone" || appPlatform === "pad" || appPlatform === "watch") &&
+                !objectGraph.host.isiOS &&
+                !objectGraph.host.isWatch) {
+                // For iPhone / iPad / watch screenshots displayed on other platforms.
+                screenshotData = screenshotsByTypeFromData(objectGraph, data, productVariantData, isAd, "ios");
+            }
+            else {
+                screenshotData = screenshotsByTypeFromData(objectGraph, data, productVariantData, isAd);
+            }
+            if (!screenshotData) {
+                continue;
+            }
+            const bestScreenshots = bestScreenshotData(objectGraph, screenshotData, appPlatform, useCase, supplementaryAppPlatforms, cropCode);
+            if (bestScreenshots) {
+                screenshots.push(bestScreenshots);
+            }
+        }
+        return screenshots;
+    });
+}
+/**
+ *  Creates an array of product media from the given screenshots. If videos are desired
+ *  to be inserted in the same media row, this must be done elsewhere.
+ *  @param objectGraph The object graph.
+ *  @param data Apps resource data.
+ *  @param screenshots The screenshots objects with which to configure the media.
+ *  @return A list of product media objects.
+ */
+function productMediaFromScreenshots(objectGraph, data, screenshots) {
+    const allMedia = [];
+    if (screenshots && screenshots.length > 0) {
+        const allPlatforms = screenshots.map((platformScreenshots) => {
+            return platformScreenshots.mediaPlatform;
+        });
+        for (const screenshotsForPlatform of screenshots) {
+            // Create media items from all the screenshots.
+            const screenshotMediaItems = [];
+            for (const screenshotArtwork of screenshotsForPlatform.artwork) {
+                const screenshotItem = new modelsShelves.ProductMediaItem();
+                screenshotItem.screenshot = screenshotArtwork;
+                screenshotMediaItems.push(screenshotItem);
+            }
+            const platform = screenshotsForPlatform.mediaPlatform;
+            const productMedia = new modelsShelves.ProductMedia(screenshotMediaItems, platform, allPlatforms, descriptionOfMediaPlatform(objectGraph, platform), descriptionOfAllMediaPlatforms(objectGraph, data, allPlatforms), placementOfAllMediaPlatformsDescription(objectGraph, data, allPlatforms));
+            allMedia.push(productMedia);
+        }
+    }
+    return allMedia;
+}
+/**
+ * Build a set of of `ProductMedia` from apps resource
+ * @param data Apps resource data
+ * @param useCase Artwork use case
+ * @param includedAppPlatforms What platforms are included.
+ * @param productVariantData A variant to use. This can be populated as an optimization to avoid re-resolving the same variant data, e.g. in a product page.
+ * @param clientIdentifierOverride
+ */
+export function productMediaFromData(objectGraph, data, useCase, includedAppPlatforms = null, productVariantData = null, clientIdentifierOverride) {
+    const screenshots = screenshotsFromData(objectGraph, data, useCase, includedAppPlatforms, clientIdentifierOverride, productVariantData);
+    return productMediaFromScreenshots(objectGraph, data, screenshots);
+}
+/**
+ * Finds the best screenshot data from a response to use for the given parameters.
+ * @param data The data from which to derive the screenshots.
+ * @param appPlatform The app platform to which the screenshots belong.
+ * @param supplementaryAppPlatforms
+ * @returns The best available screenshots.
+ */
+function bestScreenshotData(objectGraph, data, appPlatform, useCase, supplementaryAppPlatforms, cropCode) {
+    const selectionPlatform = selectionAppPlatformFromAppPlatform(objectGraph, appPlatform);
+    const screenshotTypes = mediaTypesForAppPlatform(objectGraph, selectionPlatform, objectGraph.client.screenSize);
+    let bestScreenshot = null;
+    let bestScreenshotType;
+    for (let i = 0; i < screenshotTypes.length && !serverData.isDefinedNonNullNonEmpty(bestScreenshot); i++) {
+        bestScreenshot = serverData.asArrayOrEmpty(data, screenshotTypes[i]);
+        bestScreenshotType = screenshotTypes[i];
+    }
+    if (serverData.isDefinedNonNullNonEmpty(bestScreenshot)) {
+        const artworks = bestScreenshot.map(function (screenshotArtwork) {
+            return artworkFromApiArtwork(objectGraph, screenshotArtwork, {
+                useCase: useCase,
+                cropCode: cropCode,
+            });
+        });
+        const platform = mediaPlatformForTypeAndAppPlatform(objectGraph, appPlatform, bestScreenshotType, supplementaryAppPlatforms);
+        const screenshots = new modelsBase.Screenshots(artworks, platform);
+        return screenshots;
+    }
+    return null;
+}
+/**
+ * Returns a list of sorted app platforms for displaying screenshots. This contains the sorting logic for screenshots.
+ *
+ * @param data Server data for the app
+ * @param clientIdentifier Identifier of the current client.
+ * @param deviceType Type of the current device.
+ * @returns A sorted list of AppPlatform values to use when displaying
+ * */
+export function sortedAppPlatformsFromData(objectGraph, data, clientIdentifier, deviceType) {
+    return derivedData.value(data, `sortedAppPlatformsFromData.${clientIdentifier}.${deviceType}`, () => {
+        var _a;
+        const supportedAppPlatforms = supportedAppPlatformsFromData(objectGraph, data);
+        const excludedAppPlatforms = [];
+        let sortedAppPlatforms = [];
+        const addAppPlatformIfPossible = function (appPlatform, excludePlatform) {
+            if (sortedAppPlatforms.indexOf(appPlatform) !== -1) {
+                return;
+            }
+            if (excludedAppPlatforms.indexOf(appPlatform) !== -1) {
+                return;
+            }
+            if (supportedAppPlatforms.indexOf(appPlatform) !== -1) {
+                sortedAppPlatforms.push(appPlatform);
+                if (excludePlatform) {
+                    excludedAppPlatforms.push(excludePlatform);
+                }
+            }
+        };
+        // If there is an `AppPlatform` associated with the active `Intent`, give
+        // that first priority
+        if ((_a = objectGraph.activeIntent) === null || _a === void 0 ? void 0 : _a.appPlatform) {
+            addAppPlatformIfPossible(objectGraph.activeIntent.appPlatform);
+        }
+        if (clientIdentifier === "VisionAppStore" /* ClientIdentifier.VisionAppStore */ ||
+            clientIdentifier === "com.apple.visionproapp" /* ClientIdentifier.VisionCompanion */) {
+            addAppPlatformIfPossible("vision");
+        }
+        // Next, priority is given to the client
+        switch (clientIdentifier) {
+            case client.watchIdentifier: {
+                addAppPlatformIfPossible("watch");
+                break;
+            }
+            case client.messagesIdentifier: {
+                addAppPlatformIfPossible("messages");
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+        // Next the current device type
+        switch (deviceType) {
+            case "phone": {
+                addAppPlatformIfPossible("phone");
+                break;
+            }
+            case "pad": {
+                addAppPlatformIfPossible("pad");
+                break;
+            }
+            case "tv": {
+                addAppPlatformIfPossible("tv");
+                break;
+            }
+            case "watch": {
+                addAppPlatformIfPossible("watch");
+                break;
+            }
+            case "mac": {
+                addAppPlatformIfPossible("mac");
+                break;
+            }
+            case "vision": {
+                addAppPlatformIfPossible("vision");
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+        // For Apple Silicon and visionOS, prefer iPad platform over iPhone
+        if (clientIdentifier === "VisionAppStore" /* ClientIdentifier.VisionAppStore */ ||
+            clientIdentifier === "com.apple.visionproapp" /* ClientIdentifier.VisionCompanion */) {
+            addAppPlatformIfPossible("pad");
+            addAppPlatformIfPossible("phone");
+        }
+        if (objectGraph.appleSilicon.isSupportEnabled || objectGraph.client.isVision) {
+            addAppPlatformIfPossible("pad");
+            addAppPlatformIfPossible("phone");
+        }
+        else {
+            addAppPlatformIfPossible("phone");
+            addAppPlatformIfPossible("pad");
+        }
+        addAppPlatformIfPossible("mac");
+        addAppPlatformIfPossible("vision");
+        addAppPlatformIfPossible("tv");
+        addAppPlatformIfPossible("watch");
+        addAppPlatformIfPossible("messages");
+        sortedAppPlatforms = sortedAppPlatforms.filter(function (appPlatform) {
+            return excludedAppPlatforms.indexOf(appPlatform) === -1;
+        });
+        return sortedAppPlatforms;
+    });
+}
+/**
+ * For a given server data, this will return the Game Center features that the app supports
+ *
+ * @param data Server data for the app
+ * @returns An array of supported Game Center features
+ * */
+export function supportedGameCenterFeaturesFromData(data) {
+    var _a;
+    if (isNothing(data)) {
+        return undefined;
+    }
+    return ((_a = derivedData.value(data, "supportedGameCenterFeaturesFromData", () => {
+        const features = [];
+        const supportedGameCenterFeatures = serverData.asArrayOrEmpty(data, "attributes.supportedGameCenterFeatures");
+        if (supportedGameCenterFeatures.includes("achievements")) {
+            features.push("achievements");
+        }
+        if (supportedGameCenterFeatures.includes("challenges")) {
+            features.push("challenges");
+        }
+        if (supportedGameCenterFeatures.includes("leaderboards")) {
+            features.push("leaderboards");
+        }
+        if (supportedGameCenterFeatures.includes("multiplayer-activities")) {
+            features.push("multiplayer-activities");
+        }
+        return features;
+    })) !== null && _a !== void 0 ? _a : undefined);
+}
+/**
+ * For a given server data, returns whether the game is eligible for the Games App
+ * This will default to true since we generally expect apps we view in the Games app to be games.
+ * It will be unusual that this is evaluated to `false`.
+ *
+ * @param data Server data for the app
+ * @returns A boolean indicating whether game is eligible for display
+ * */
+export function isEligibleForGamesApp(data) {
+    var _a;
+    if (isNothing(data)) {
+        return true;
+    }
+    return (_a = serverData.asBoolean(data, "attributes.isEligibleForGamesApp")) !== null && _a !== void 0 ? _a : true;
+}
+/**
+ * For a given server data, this will return the platforms that the app supports
+ *
+ * @param data Server data for the app
+ * @returns An array of supported AppPlatforms
+ * */
+export function supportedAppPlatformsFromData(objectGraph, data) {
+    if (!data) {
+        return null;
+    }
+    return derivedData.value(data, "supportedAppPlatformsFromData", () => {
+        const hasMessagesExtension = hasMessagesExtensionFromData(objectGraph, data, "ios");
+        const isHiddenFromSpringboard = isHiddenFromSpringboardFromData(objectGraph, data);
+        const isAppleWatchSupported = isAppleWatchSupportedFromData(objectGraph, data);
+        const serverDeviceFamilies = mediaAttributes.attributeAsArrayOrEmpty(data, "deviceFamilies");
+        const appPlatforms = [];
+        for (const serverDeviceFamily of serverDeviceFamilies) {
+            switch (serverDeviceFamily) {
+                case "iphone":
+                    if (!isHiddenFromSpringboard) {
+                        appPlatforms.push("phone");
+                    }
+                    break;
+                case "ipad":
+                    if (!isHiddenFromSpringboard) {
+                        appPlatforms.push("pad");
+                    }
+                    break;
+                case "tvos":
+                    appPlatforms.push("tv");
+                    break;
+                case "watch":
+                    appPlatforms.push("watch");
+                    break;
+                case "realityDevice":
+                    appPlatforms.push("vision");
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (hasMessagesExtension) {
+            appPlatforms.push("messages");
+        }
+        if (isAppleWatchSupported) {
+            appPlatforms.push("watch");
+        }
+        if (contentDeviceFamily.dataHasDeviceFamily(objectGraph, data, "mac")) {
+            appPlatforms.push("mac");
+        }
+        return appPlatforms;
+    });
+}
+/**
+ * Returns a localized, user-friendly description of all media platforms. This may be a comma delimited
+ * list of the platforms (including supplementary platforms), or it may be 'Only for ___', depending
+ * on the context.
+ *
+ * The localization keys used by this function are defined natively, and are updated using
+ * `tools/platform-media-localizations.py`. If the key doesn't exist, then the script needs to
+ * be updated to add the new combination/order of platforms.
+ *
+ * For failed attempts to localize the string, this function will fallback to a default order that is
+ * guaranteed to exist.
+ *
+ * @param objectGraph The object graph.
+ * @param data Apps resource data.
+ * @param allPlatforms The list of platforms to describe.
+ * @returns The friendly description of all platforms.
+ */
+export function descriptionOfAllMediaPlatforms(objectGraph, data, allPlatforms) {
+    if (shouldShowOnlyForPlatformDescription(objectGraph, data, allPlatforms)) {
+        const platform = allPlatforms[0];
+        const platformKey = platform.appPlatform.toUpperCase();
+        return objectGraph.loc.string(`ONLY_FOR_${platformKey}_APP`);
+    }
+    // Flatten all platform partial keys, including their supplementary platforms
+    let keys = allPlatforms.reduce((partialResult, platform) => partialResult.concat(platformLocalizationKeys(platform)), []);
+    try {
+        // Attempt to localize the constructed key
+        return objectGraph.loc.tryString(`PLATFORMS_${keys.join("_")}`);
+    }
+    catch (error) {
+        // If the key does not exist, a best attempt fallback string will be provided.
+        const fallbackOrder = ["PHONE", "PAD", "MAC", "VISION", "TV", "WATCH", "MESSAGES", "FACETIME"];
+        keys = fallbackOrder.filter((key) => keys.includes(key));
+        return objectGraph.loc.string(`PLATFORMS_${keys.join("_")}`);
+    }
+}
+/**
+ * Determines where to place the all platforms description, which is visible when the product media is collapsed, or there is only one platform.
+ * This is only used by iOS, visionOS & macOS. For tvOS & watchOS, we always put the media description at the bottom.
+ *
+ * @param objectGraph The object graph.
+ * @param data Apps resource data.
+ * @param allPlatforms The list of platforms to describe.
+ * @returns Where to place the all platforms description.
+ */
+export function placementOfAllMediaPlatformsDescription(objectGraph, data, allPlatforms) {
+    if (shouldShowOnlyForPlatformDescription(objectGraph, data, allPlatforms)) {
+        return "top";
+    }
+    else {
+        return "bottom";
+    }
+}
+/**
+ * Determines whether we want to use the 'Only for ___' text to describe `allPlatforms`.
+ *
+ * @param objectGraph The object graph.
+ * @param data Apps resource data.
+ * @param allPlatforms The list of platforms to describe.
+ * @returns Whether we want to use 'Only for ___' text to describe `allPlatforms`.
+ */
+function shouldShowOnlyForPlatformDescription(objectGraph, data, allPlatforms) {
+    if (allPlatforms.length === 1) {
+        const platform = allPlatforms[0];
+        const supportsMacOSCompatibleIOSBinary = supportsMacOSCompatibleIOSBinaryFromData(objectGraph, data, objectGraph.appleSilicon.isSupportEnabled);
+        const supportsVisionOSCompatibleIOSBinary = supportsVisionOSCompatibleIOSBinaryFromData(objectGraph, data);
+        const runnableAppPlatforms = runnableAppPlatformsForDevice(objectGraph, objectGraph.client.deviceType, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary);
+        const isRunnableOnCurrentDevice = supportsPlatform(runnableAppPlatforms, platform.appPlatform);
+        const noSupplementaryPlatforms = platform.supplementaryAppPlatforms.length === 0;
+        const isForDifferentDevice = platform.appPlatform !== objectGraph.client.deviceType;
+        if (noSupplementaryPlatforms && isForDifferentDevice && !isRunnableOnCurrentDevice) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Returns a localized description of a media platform, including any supplementary platforms.
+ * e.g. 'Mac' or 'iMessage, FaceTime'.
+ *
+ * @param objectGraph Object graph, used for localizing the string.
+ * @param allPlatforms The platform to describe.
+ * @returns The friendly description of the platform.
+ */
+export function descriptionOfMediaPlatform(objectGraph, platform) {
+    const keys = platformLocalizationKeys(platform);
+    return objectGraph.loc.string(`PLATFORMS_${keys.join("_")}`);
+}
+/**
+ * Returns an array of partial loc keys that represent a media platform.
+ * This consists the media's app platform + any supplementary platforms.
+ * e.g. ["MAC"] or ["MESSAGES", "FACETIME"]
+ *
+ * @param platform The media platform.
+ * @returns The list of partial loc key that represent the media platform.
+ */
+function platformLocalizationKeys(platform) {
+    const appPlatformKey = platform.appPlatform.toUpperCase();
+    const supplementaryPlatformKeys = platform.supplementaryAppPlatforms.map((supplementaryPlatform) => supplementaryPlatform.toUpperCase());
+    return [appPlatformKey].concat(supplementaryPlatformKeys);
+}
+/**
+ * Determines if a given app has a compatible iOS binary for this client.
+ *
+ * @param {mediaDataStructure.Data} data    The product data to use.
+ * @param {boolean} doesClientSupportMacOSCompatibleIOSBinary   Whether the client supports macOS compatible iOS binaries
+ * @returns {boolean}                       True when the app and device are halva.
+ */
+export function supportsMacOSCompatibleIOSBinaryFromData(objectGraph, data, doesClientSupportMacOSCompatibleIOSBinary) {
+    let isIOSBinaryMacOSCompatible = mediaAttributes.attributeAsBooleanOrFalse(data, "isIOSBinaryMacOSCompatible");
+    // Override for News in Moltres on Mac
+    if (preprocessor.GAMES_TARGET && data.id === "1066498020" && objectGraph.client.deviceType === "mac") {
+        isIOSBinaryMacOSCompatible = true;
+    }
+    return doesClientSupportMacOSCompatibleIOSBinary && isIOSBinaryMacOSCompatible;
+}
+/**
+ * Determines if a given app has a compatible iOS binary for the current client.
+ *
+ * @param {mediaDataStructure.Data} data The product data to use.
+ * @returns {boolean} True when the app and device are visionOS.
+ */
+export function supportsVisionOSCompatibleIOSBinaryFromData(objectGraph, data) {
+    return (objectGraph.client.isVision &&
+        mediaPlatformAttributes.platformAttributeAsBooleanOrFalse(data, "ios", "isXROSCompatible"));
+}
+/**
+ * Determines if a given app has a compatible iOS binary for arbitrary clients.
+ *
+ * @param {mediaDataStructure.Data} data The product data to use.
+ * @returns {boolean} True when the app can run on visionOS.
+ */
+export function supportsVisionOSCompatibleIOSBinaryOnAnyClient(data) {
+    return mediaPlatformAttributes.platformAttributeAsBooleanOrFalse(data, "ios", "isXROSCompatible");
+}
+/**
+ * Determines app binary traits.
+ *
+ * @param {mediaDataStructure.Data} data The product data to use.
+ * @returns {string[]} The app binary traits.
+ */
+export function appBinaryTraitsFromData(objectGraph, data) {
+    if (!objectGraph.client.isiOS) {
+        return undefined;
+    }
+    let appBinaryTraits;
+    if (objectGraph.isAvailable(ads) &&
+        ["debug", "internal"].includes(objectGraph.client.buildType) &&
+        isSome(objectGraph.ads.fetchAppBinaryTraitsOverride)) {
+        // use client override for debugging internal builds
+        appBinaryTraits = objectGraph.ads.fetchAppBinaryTraitsOverride();
+    }
+    if (isNothing(appBinaryTraits)) {
+        // parse from server response
+        appBinaryTraits = mediaPlatformAttributes.platformAttributeAsArrayOrEmpty(data, "ios", "appBinaryTraits");
+    }
+    return appBinaryTraits;
+}
+/**
+ * Determines whether the product has external browser engine.
+ * @param objectGraph Current object graph
+ * @param data The product data
+ * @returns True if the product has external browser engine
+ */
+export function hasExternalBrowserForData(objectGraph, data) {
+    var _a;
+    const appBinaryTraits = appBinaryTraitsFromData(objectGraph, data);
+    const externalBrowserTraits = new Set(["uses-non-webkit-browser-engine", "is-custom-browser-engine-app"]);
+    return (_a = appBinaryTraits === null || appBinaryTraits === void 0 ? void 0 : appBinaryTraits.some((trait) => externalBrowserTraits.has(trait))) !== null && _a !== void 0 ? _a : false;
+}
+/**
+ * Determines minimum os version
+ *
+ * @param {mediaDataStructure.Data} data      The product data to use.
+ * @param {boolean} isClientHalva             Whether the client is halva.
+ * @returns {string}                          The minimum OS version.
+ */
+export function minimumOSVersionFromData(objectGraph, data, isClientHalva) {
+    const supportsMacOSCompatibleIOSBinary = supportsMacOSCompatibleIOSBinaryFromData(objectGraph, data, isClientHalva);
+    const supportsVisionOSCompatibleIOSBinary = supportsVisionOSCompatibleIOSBinaryFromData(objectGraph, data);
+    if (supportsMacOSCompatibleIOSBinary) {
+        const minimumOSVersion = contentAttributes.contentAttributeAsString(objectGraph, data, "minimumMacOSVersion");
+        if (serverData.isDefinedNonNullNonEmpty(minimumOSVersion)) {
+            return minimumOSVersion;
+        }
+    }
+    else if (supportsVisionOSCompatibleIOSBinary) {
+        const minimumOSVersion = contentAttributes.contentAttributeAsString(objectGraph, data, "minimumXROSVersion");
+        if (serverData.isDefinedNonNullNonEmpty(minimumOSVersion)) {
+            return minimumOSVersion;
+        }
+    }
+    const attributePlatform = contentAttributes.bestAttributePlatformFromData(objectGraph, data);
+    return mediaPlatformAttributes.platformAttributeAsString(data, attributePlatform, "minimumOSVersion");
+}
+/**
+ * Determines required capabilities for device.
+ *
+ * @param {mediaDataStructure.Data} data      The product data to use.
+ * @param {boolean} isClientHalva             Whether the client is halva.
+ * @returns {string}                          The device capabilities to use.
+ */
+export function requiredCapabilitiesFromData(objectGraph, data, isClientHalva) {
+    const supportsMacOSCompatibleIOSBinary = supportsMacOSCompatibleIOSBinaryFromData(objectGraph, data, isClientHalva);
+    const supportsVisionOSCompatibleIOSBinary = supportsVisionOSCompatibleIOSBinaryFromData(objectGraph, data);
+    if (supportsMacOSCompatibleIOSBinary) {
+        return contentAttributes.contentAttributeAsString(objectGraph, data, "macRequiredCapabilities");
+    }
+    else if (supportsVisionOSCompatibleIOSBinary) {
+        return contentAttributes.contentAttributeAsString(objectGraph, data, "requiredCapabilitiesForRealityDevice");
+    }
+    else {
+        return contentAttributes.contentAttributeAsString(objectGraph, data, "requiredCapabilities");
+    }
+}
+/**
+ * Returns the app platforms you can buy for on the given device.
+ *
+ * @param objectGraph The current object graph
+ * @param data The data for the app in question
+ * @param device The device type to check
+ * @param supportsMacOSCompatibleIOSBinary Whether device and app supports macOS compatible iOS binary
+ * @param supportsVisionOSCompatibleIOSBinary Whether device and app supports visionOS compatible iOS binary
+ * @returns An array of supported app platforms
+ */
+function buyableAppPlatformsForDevice(objectGraph, data, device, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary) {
+    let systemApps;
+    switch (device) {
+        case "phone":
+            systemApps = sad.systemApps(objectGraph);
+            if (isSome(data) && systemApps.isSystemAppFromData(data)) {
+                return ["phone", "watch", "messages"];
+            }
+            else {
+                return ["phone", "watch", "messages", "tv", "vision"];
+            }
+        case "pad":
+            systemApps = sad.systemApps(objectGraph);
+            if (isSome(data) && systemApps.isSystemAppFromData(data)) {
+                return ["phone", "pad", "messages"];
+            }
+            else {
+                return ["phone", "pad", "messages", "tv", "vision"];
+            }
+        case "tv":
+            return ["tv"];
+        case "watch":
+            return ["watch"];
+        case "mac":
+            if (supportsMacOSCompatibleIOSBinary) {
+                return ["mac", "phone", "pad"];
+            }
+            else {
+                return ["mac"];
+            }
+        case "vision":
+            if (supportsVisionOSCompatibleIOSBinary) {
+                return ["vision", "phone", "pad"];
+            }
+            else {
+                return ["vision"];
+            }
+        default:
+            return [];
+    }
+}
+/**
+ * Returns the app platforms you can preorder on for the given device.
+ *
+ * @param {DeviceType} device    The device type to check
+ * @param {boolean} supportsMacOSCompatibleIOSBinary Whether device and app are support macOS compatible iOS binary
+ * @param {boolean} supportsVisionOSCompatibleIOSBinary    Whether device and app supports visionOS compatible iOS binary
+ * @returns {models.AppPlatform[]}      An array of supported app platforms
+ */
+function preorderableAppPlatformsForDevice(objectGraph, device, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary) {
+    switch (device) {
+        case "phone":
+            return ["phone", "watch", "messages"];
+        case "pad":
+            return ["phone", "pad", "messages"];
+        case "tv":
+            return ["tv"];
+        case "watch":
+            return ["watch"];
+        case "mac":
+            if (supportsMacOSCompatibleIOSBinary) {
+                return ["mac", "phone", "pad"];
+            }
+            else {
+                return ["mac"];
+            }
+        case "vision":
+            if (supportsVisionOSCompatibleIOSBinary) {
+                return ["vision", "phone", "pad"];
+            }
+            else {
+                return ["vision"];
+            }
+        default:
+            return [];
+    }
+}
+/**
+ * Returns the app platforms you can run on the given device.
+ *
+ * @param {DeviceType} device    The device type to check
+ * @param {boolean} supportsMacOSCompatibleIOSBinary    Whether device and app are support macOS compatible iOS binary
+ * @param {boolean} supportsVisionOSCompatibleIOSBinary    Whether device and app supports visionOS compatible iOS binary
+ * @returns {models.AppPlatform[]}      An array of supported app platforms
+ */
+export function runnableAppPlatformsForDevice(objectGraph, device, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary) {
+    switch (device) {
+        case "phone":
+            return ["phone", "messages"];
+        case "pad":
+            return ["phone", "pad", "messages"];
+        case "tv":
+            return ["tv"];
+        case "watch":
+            return ["watch"];
+        case "mac":
+            if (supportsMacOSCompatibleIOSBinary) {
+                return ["mac", "phone", "pad"];
+            }
+            else {
+                return ["mac"];
+            }
+        case "vision":
+            if (supportsVisionOSCompatibleIOSBinary) {
+                return ["vision", "phone", "pad"];
+            }
+            else {
+                return ["vision"];
+            }
+        default:
+            return [];
+    }
+}
+/**
+ * Determines if a given piece of content supports the provided app platform
+ *
+ * @param {models.AppPlatform[]} appPlatforms The app platforms supported by the content
+ * @param {AppPlatform} platform The platform to check
+ * @returns {boolean} True if the platform is supported, false if not
+ */
+export function supportsPlatform(appPlatforms, platform) {
+    return appPlatforms.indexOf(platform) !== -1;
+}
+/**
+ * Determines if a given piece of content is buyable on the provided device.
+ *
+ * @param {models.AppPlatform[]} appPlatforms The app platforms supported by the content
+ * @param {DeviceType} device The device type to check
+ * @param {boolean} supportsMacOSCompatibleIOSBinary Whether app and device support macOS compatible iOS binary.
+ * @param {boolean} supportsVisionOSCompatibleIOSBinary    Whether device and app supports visionOS compatible iOS binary
+ * @param {boolean} isMacOSAppBuyableOnDevice Whether a macOS app is buyable on this device (this enables additional criteria for Apple Silicon).
+ * @returns {boolean} True if any of the app platforms are buyable on the given device, false if not
+ */
+export function buyableOnDevice(objectGraph, data, appPlatforms, device, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary, isMacOSAppBuyableOnDevice = true) {
+    const platforms = buyableAppPlatformsForDevice(objectGraph, data, device, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary);
+    // Do any of the platforms supported by the device match any of the content's app platforms?
+    if (!platforms.some((platform) => supportsPlatform(appPlatforms, platform))) {
+        return false;
+    }
+    if (objectGraph.client.isMac && platforms.includes("mac")) {
+        return isMacOSAppBuyableOnDevice;
+    }
+    return true;
+}
+/**
+ * Determines macOS runnability info for apps and bundles on macOS.
+ */
+function macOSRunnabilityInfoFromData(objectGraph, data) {
+    var _a;
+    const runnabilityInfo = new RunnabilityInfo();
+    // Return most permissible runnability for non-macOS platforms.
+    if (objectGraph.client.deviceType !== "mac") {
+        return runnabilityInfo;
+    }
+    // Use media API attributes for non-bundles.
+    if (data.type !== "app-bundles") {
+        runnabilityInfo.runsOnIntel =
+            (_a = contentAttributes.contentAttributeAsBoolean(objectGraph, data, "runsOnIntel", contentAttributes.defaultAttributePlatform(objectGraph))) !== null && _a !== void 0 ? _a : true;
+        runnabilityInfo.runsOnAppleSilicon = contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "runsOnAppleSilicon", contentAttributes.defaultAttributePlatform(objectGraph));
+        runnabilityInfo.requiresRosetta = contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "requiresRosetta", contentAttributes.defaultAttributePlatform(objectGraph));
+        return runnabilityInfo;
+    }
+    const bundleAppsData = mediaRelationship.relationshipCollection(data, "apps");
+    // Return most permissible runnability when there no children available
+    if (bundleAppsData.length === 0) {
+        return runnabilityInfo;
+    }
+    // Synthesize runnability info from bundle apps
+    for (const appData of bundleAppsData) {
+        if (serverData.isNull(appData.attributes)) {
+            continue;
+        }
+        const appRunnabilityInfo = macOSRunnabilityInfoFromData(objectGraph, appData);
+        runnabilityInfo.runsOnIntel = runnabilityInfo.runsOnIntel && appRunnabilityInfo.runsOnIntel;
+        runnabilityInfo.runsOnAppleSilicon =
+            runnabilityInfo.runsOnAppleSilicon && appRunnabilityInfo.runsOnAppleSilicon;
+        runnabilityInfo.requiresRosetta = runnabilityInfo.requiresRosetta || appRunnabilityInfo.requiresRosetta;
+    }
+    return runnabilityInfo;
+}
+/**
+ * Determines if a given macOS app is buyable on this device.
+ *
+ */
+export function isMacOSAppBuyableAndRunnableFromData(objectGraph, data, isAppleSiliconSupportEnabled, isRosettaAvailable) {
+    const runnabilityInfo = macOSRunnabilityInfoFromData(objectGraph, data);
+    if (isAppleSiliconSupportEnabled) {
+        return (runnabilityInfo.runsOnAppleSilicon &&
+            (!runnabilityInfo.requiresRosetta || (runnabilityInfo.requiresRosetta && isRosettaAvailable)));
+    }
+    else {
+        return runnabilityInfo.runsOnIntel;
+    }
+}
+/**
+ * Determines if a given piece of content is preorderable on the provided device.
+ *
+ * @param {models.AppPlatform[]} appPlatforms The app platforms supported by the content
+ * @param {DeviceType} device The device type to check
+ * @param {boolean} supportsMacOSCompatibleIOSBinary Whether app and device support macOS compatible iOS binary.
+ * @param {boolean} supportsVisionOSCompatibleIOSBinary Whether app and device support visionOS compatible iOS binary.
+ * @returns {boolean} True if any of the app platforms are buyable on the given device, false if not
+ */
+export function preorderableOnDevice(objectGraph, appPlatforms, device, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary) {
+    const platforms = preorderableAppPlatformsForDevice(objectGraph, device, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary);
+    // Do any of the platforms supported by the device match any of the content's app platforms?
+    return platforms.some((platform) => supportsPlatform(appPlatforms, platform));
+}
+/**
+ * Determines if any of a given array of app platforms can be run on the provided device.
+ *
+ * @param appPlatforms The app platforms supported by a piece of content.
+ * @param device The device type to check.
+ * @param {boolean} supportsMacOSCompatibleIOSBinary Whether app and device support macOS compatible iOS binary.
+ * @param {boolean} supportsVisionOSCompatibleIOSBinary Whether app and device support visionOS compatible iOS binary.
+ * @returns `true` if any of the app platforms can be run on the given device; `false` otherwise.
+ */
+export function runnableOnDevice(objectGraph, appPlatforms, device, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary, isMacOSAppRunnableOnDevice = true) {
+    const runnablePlatforms = runnableAppPlatformsForDevice(objectGraph, device, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary);
+    // Do any of the platforms supported by the device match any of the content's app platforms?
+    if (!runnablePlatforms.some((platform) => supportsPlatform(appPlatforms, platform))) {
+        return false;
+    }
+    if (objectGraph.client.isMac && appPlatforms.includes("mac")) {
+        return isMacOSAppRunnableOnDevice;
+    }
+    return true;
+}
+/**
+ * Determines if a given piece of content is runnable on the provided device.
+ *
+ * @param data  The product data to use.
+ * @param device
+ * @param {boolean} doesClientSupportMacOSCompatibleIOSBinary Whether the client supports macOS compatible iOS binaries
+ * @returns {boolean} True if the product can be run on the provided device, false if not
+ */
+export function runnableOnDeviceWithData(objectGraph, data, device, doesClientSupportMacOSCompatibleIOSBinary) {
+    // (1) Required capabilities mismatch
+    if (!lockups.deviceHasCapabilitiesFromData(objectGraph, data)) {
+        return false;
+    }
+    // (2) 32-bit only, unsupported deletable system app, doesn't meet minimum OS requirements, or doesn't support current platform
+    // Note that Filter.UnsupportedPlatform only checks if the product is buyable, not runnable
+    const filter = 2 /* filtering.Filter.ThirtyTwoBit */ |
+        4 /* filtering.Filter.UnsupportedSystemDeletableApps */ |
+        512 /* filtering.Filter.MinimumOSRequirement */ |
+        128 /* filtering.Filter.UnsupportedPlatform */ |
+        8192 /* filtering.Filter.MacOSRosetta */;
+    if (filtering.shouldFilter(objectGraph, data, filter)) {
+        return false;
+    }
+    // (3) Finally, check if any of the product platforms are supported on this device
+    const supportsMacOSCompatibleIOSBinary = supportsMacOSCompatibleIOSBinaryFromData(objectGraph, data, doesClientSupportMacOSCompatibleIOSBinary);
+    const supportsVisionOSCompatibleIOSBinary = supportsVisionOSCompatibleIOSBinaryFromData(objectGraph, data);
+    const runnableAppPlatforms = runnableAppPlatformsForDevice(objectGraph, device, supportsMacOSCompatibleIOSBinary, supportsVisionOSCompatibleIOSBinary);
+    const productAppPlatforms = supportedAppPlatformsFromData(objectGraph, data);
+    return runnableAppPlatforms.some((platform) => supportsPlatform(productAppPlatforms, platform));
+}
+/**
+ * Determines which screenshot keys (MediaType) we need to use to pull the appropriate screenshots
+ * from the server data.
+ *
+ * @param appPlatform The app platform requested
+ * @param screenSize The size of the screen being used to display the screenshots
+ * @returns An array of ScreenshotType strings that can be used on the server data
+ * */
+export function mediaTypesForAppPlatform(objectGraph, appPlatform, screenSize) {
+    switch (appPlatform) {
+        case "mac": {
+            return ["mac"];
+        }
+        case "watch": {
+            if (screenSize.isEqualTo(screenSizeWatchUltra) || screenSize.isEqualTo(screenSizeN230)) {
+                // 2022 is the preferred dropwell for Ultra devices
+                return ["appleWatch_2022", "appleWatch_2024", "appleWatch_2021", "appleWatch_2018", "appleWatch"];
+            }
+            else {
+                return ["appleWatch_2024", "appleWatch_2022", "appleWatch_2021", "appleWatch_2018", "appleWatch"];
+            }
+        }
+        case "tv": {
+            return ["appleTV"];
+        }
+        case "vision": {
+            return ["appleVisionPro"];
+        }
+        case "pad": {
+            const types = [];
+            if ((screenSize.isEqualTo(screenSizeIPadPro2018) ||
+                screenSize.isEqualTo(screenSizeIPadPro2018Landscape) ||
+                screenSize.isEqualTo(screenSizeJ720) ||
+                screenSize.isEqualTo(screenSizeJ720Landscape)) &&
+                objectGraph.client.screenCornerRadius > 0.0) {
+                types.push("ipadPro_2018");
+                types.push("ipad_11");
+                types.push("ipadPro");
+                types.push("ipad_10_5");
+                types.push("ipad");
+            }
+            else if (screenSize.isEqualTo(screenSizeIPadPro)) {
+                types.push("ipadPro");
+                types.push("ipadPro_2018");
+                types.push("ipad_11");
+                types.push("ipad_10_5");
+                types.push("ipad");
+            }
+            else if (screenSize.isEqualTo(screenSizeIPad11) ||
+                screenSize.isEqualTo(screenSizeIPad11Landscape) ||
+                screenSize.isEqualTo(screenSizeIPadJ310) ||
+                screenSize.isEqualTo(screenSizeIPadJ310Landscape) ||
+                screenSize.isEqualTo(screenSizeJ717) ||
+                screenSize.isEqualTo(screenSizeJ717Landscape)) {
+                types.push("ipad_11");
+                types.push("ipadPro_2018");
+                types.push("ipadPro");
+                types.push("ipad_10_5");
+                types.push("ipad");
+            }
+            else if (screenSize.isEqualTo(screenSizeIPad105)) {
+                types.push("ipad_10_5");
+                types.push("ipad");
+                types.push("ipad_11");
+                types.push("ipadPro");
+                types.push("ipadPro_2018");
+            }
+            else if (screenSize.isEqualTo(screenSizeIPadAir2020)) {
+                types.push("ipad_11");
+                types.push("ipadPro");
+                types.push("ipadPro_2018");
+                types.push("ipad_10_5");
+                types.push("ipad");
+            }
+            else if (screenSize.isEqualTo(screenSizeIPad102)) {
+                types.push("ipad");
+                types.push("ipad_10_5");
+                types.push("ipad_11");
+                types.push("ipadPro");
+                types.push("ipadPro_2018");
+            }
+            else {
+                // Regardless of screen size match, we should add on 'some' iPad.
+                types.push("ipadPro_2018");
+                types.push("ipad_11");
+                types.push("ipad");
+                types.push("ipad_10_5");
+                types.push("ipadPro");
+            }
+            return types;
+        }
+        case "phone": {
+            /**                 Phone Best Match Policy                     **
+
+             The best match is given by |B| + |L| + |S|, where:
+             B: Exact type match
+             L: All types larger than the exact type, in increasing order
+             S: All types smaller than the exact type, in decreasing order
+
+             Example:
+             Types for iphone6 == [iphone6, iphone6+, iphone_5_8, iphone5, iphone]
+             Types for iphone5 == [iphone5, iphone6, iphone6+, iphone_5_8, iphone]
+
+             **                                                             */
+            // Grab the exact match.
+            let perfectMatch;
+            if (screenSize.isEqualTo(screenSizeIphone65) || screenSize.isEqualTo(screenSizeIPhone134)) {
+                perfectMatch = "iphone_6_5";
+            }
+            else if (screenSize.isEqualTo(screenSizeIPhone58) ||
+                screenSize.isEqualTo(screenSizeIPhone131) ||
+                screenSize.isEqualTo(screenSizeIPhone132)) {
+                perfectMatch = "iphone_5_8";
+            }
+            else if (screenSize.isEqualTo(screenSizeIPhoneOriginal)) {
+                perfectMatch = "iphone";
+            }
+            else if (screenSize.isEqualTo(screenSizeIPhone5)) {
+                perfectMatch = "iphone5";
+            }
+            else if (screenSize.isEqualTo(screenSizeIPhone6)) {
+                perfectMatch = "iphone6";
+            }
+            else if (screenSize.isEqualTo(screenSizeIPhone6Plus)) {
+                perfectMatch = "iphone6+";
+            }
+            else if (screenSize.isEqualTo(screenSizeIPhone61) || screenSize.isEqualTo(screenSizeD93)) {
+                perfectMatch = "iphone_d73";
+            }
+            else if (screenSize.isEqualTo(screenSizeIPhone67) ||
+                screenSize.isEqualTo(screenSizeD94) ||
+                screenSize.isEqualTo(screenSizeD23)) {
+                perfectMatch = "iphone_d74";
+            }
+            else {
+                perfectMatch = "iphone_5_8";
+            }
+            // Append remaining types to our exact match.
+            const perfectMatchIndex = decreasingPhoneTypes.indexOf(perfectMatch);
+            const largerTypes = decreasingPhoneTypes.slice(0, perfectMatchIndex);
+            largerTypes.reverse();
+            const smallerTypes = decreasingPhoneTypes.slice(perfectMatchIndex + 1);
+            const perfectMatchArray = [perfectMatch];
+            return perfectMatchArray.concat(largerTypes, smallerTypes);
+        }
+        default: {
+            return [];
+        }
+    }
+}
+export function combinedFileSizeFromData(objectGraph, data) {
+    var _a;
+    if (serverData.isNull(data)) {
+        return null;
+    }
+    // This background asset information is for the work done in SydneyB
+    const backgroundAssetsInfo = contentAttributes.contentAttributeAsDictionary(objectGraph, data, "backgroundAssetsInfo");
+    // This background asset information is for the work done in SydneyE
+    const backgroundAssetsInfoWithOptional = contentAttributes.contentAttributeAsDictionary(objectGraph, data, "backgroundAssetsInfoWithOptional");
+    const isIOSBinaryCompatibleWithMac = supportsMacOSCompatibleIOSBinaryFromData(objectGraph, data, true);
+    const isMacOnly = contentDeviceFamily.dataOnlyHasDeviceFamily(objectGraph, data, "mac");
+    const isWebViewingMac = objectGraph.client.isWeb && ((_a = objectGraph.activeIntent) === null || _a === void 0 ? void 0 : _a.platform) === "mac";
+    if ((objectGraph.client.isMac || isWebViewingMac || isMacOnly) && !isIOSBinaryCompatibleWithMac) {
+        const macFileSize = objectGraph.bag.enableProductPageInstallSize
+            ? macInstallSizeInBytesFromData(objectGraph, data)
+            : offers.macFileSizeInBytesFromData(objectGraph, data);
+        if (serverData.isDefinedNonNullNonEmpty(backgroundAssetsInfoWithOptional)) {
+            const maxEssentialInstallSizeInBytes = serverData.asNumber(backgroundAssetsInfoWithOptional, "maxEssentialInstallSizeInBytes");
+            return new modelsBase.CombinedFileSize(macFileSize, null, null, maxEssentialInstallSizeInBytes);
+        }
+        else if (serverData.isDefinedNonNullNonEmpty(backgroundAssetsInfo)) {
+            const maxDownloadSizeInBytes = serverData.asNumber(backgroundAssetsInfo, "maxDownloadSizeInBytes");
+            const maxInstallSizeInBytes = serverData.asNumber(backgroundAssetsInfo, "maxInstallSizeInBytes");
+            return new modelsBase.CombinedFileSize(macFileSize, maxDownloadSizeInBytes, maxInstallSizeInBytes, null);
+        }
+        return new modelsBase.CombinedFileSize(macFileSize, null, null, null);
+    }
+    else {
+        /* File Size: Our policy is to rely on thinned variant, device model, and universal (in that order). */
+        const fileSizeByDevice = mediaAttributes.attributeAsDictionary(data, "fileSizeByDevice");
+        if (fileSizeByDevice) {
+            /* thinnedApplicationVariantIdentifier can contain two device names. The preferred device, and a compatible device. */
+            let fileSizeKeys = [];
+            if (objectGraph.client.thinnedApplicationVariantIdentifier) {
+                fileSizeKeys = objectGraph.client.thinnedApplicationVariantIdentifier.split(" ");
+            }
+            fileSizeKeys = fileSizeKeys.concat([objectGraph.host.deviceModel, "universal"]);
+            for (const key of fileSizeKeys) {
+                const fileSizeValue = serverData.asNumber(fileSizeByDevice[key]);
+                if (fileSizeValue) {
+                    if (serverData.isDefinedNonNullNonEmpty(backgroundAssetsInfoWithOptional)) {
+                        const maxEssentialInstallSizeInBytes = serverData.asNumber(backgroundAssetsInfoWithOptional, "maxEssentialInstallSizeInBytes");
+                        return new modelsBase.CombinedFileSize(fileSizeValue, null, null, maxEssentialInstallSizeInBytes);
+                    }
+                    else if (serverData.isDefinedNonNullNonEmpty(backgroundAssetsInfo)) {
+                        const maxDownloadSizeInBytes = serverData.asNumber(backgroundAssetsInfo, "maxDownloadSizeInBytes");
+                        const maxInstallSizeInBytes = serverData.asNumber(backgroundAssetsInfo, "maxInstallSizeInBytes");
+                        return new modelsBase.CombinedFileSize(fileSizeValue, maxDownloadSizeInBytes, maxInstallSizeInBytes, null);
+                    }
+                    else {
+                        return new modelsBase.CombinedFileSize(fileSizeValue, null, null, null);
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Extract the file size and unit from a CombinedFileSize object.
+ * @param objectGraph Current object graph
+ * @param combinedFileSize The combined file size object
+ * @returns A FileSizeAndUnit object
+ */
+export function fileSizeAndUnitFromCombinedFileSize(objectGraph, combinedFileSize) {
+    let totalFileSize;
+    if (isSome(combinedFileSize.maxEssentialInstallSizeInBytes)) {
+        totalFileSize = combinedFileSize.fileSizeByDevice + combinedFileSize.maxEssentialInstallSizeInBytes;
+    }
+    else if (isSome(combinedFileSize.maxInstallSizeInBytes)) {
+        totalFileSize = combinedFileSize.fileSizeByDevice + combinedFileSize.maxInstallSizeInBytes;
+    }
+    else {
+        totalFileSize = combinedFileSize.fileSizeByDevice;
+    }
+    if (totalFileSize <= 0) {
+        return null;
+    }
+    // We split using all whitespace characters because in some locs a non-breaking space is used.
+    const parts = objectGraph.loc.fileSize(totalFileSize).trim().split(/\s+/);
+    if (parts.length !== 2) {
+        return null;
+    }
+    return {
+        size: parts[0],
+        unit: parts[1],
+    };
+}
+/**
+ * Extracts the install size for a macOS app.
+ * @param objectGraph Current object graph
+ * @param data Product page data
+ * @returns The install size for the Mac binary, in bytes
+ */
+function macInstallSizeInBytesFromData(objectGraph, data) {
+    const deviceData = mediaPlatformAttributes.platformAttributeAsDictionary(data, "osx", "installSizeByDeviceInBytes");
+    if (isNothing(deviceData)) {
+        return null;
+    }
+    // macOS does not support app thinning, so there is only ever one macOS device in this list. Unfortunately
+    // there is no known API that gives us this device name, so we resort to hard-coding for now.
+    const installSizeInBytes = deviceData["Mac"];
+    if (isNothing(installSizeInBytes)) {
+        return null;
+    }
+    return serverData.asNumber(installSizeInBytes);
+}
+/**
+ * Determines the primary langauge locale, from a given list of locales.
+ * @param objectGraph Current object graph
+ * @param locales The list of locales
+ * @returns A single LanguageLocale object, or null
+ */
+export function primaryLanguageLocaleFromLocales(objectGraph, locales) {
+    const languageCount = locales.length;
+    if (languageCount <= 0) {
+        return null;
+    }
+    return {
+        tag: serverData.asString(serverData.traverse(locales, "0.tag")).split("-")[0].toUpperCase(),
+        name: serverData.asString(serverData.traverse(locales, "0.name")),
+    };
+}
+/**
+ * Determines the uber artwork for the product, if there is any.
+ * @param {Data} The data for the product.
+ * @returns {models.Artwork} The artwork for the uber, or `null` if there is none.
+ * null.
+ */
+export function productUberFromData(objectGraph, data, options) {
+    let uberArtworkData;
+    let uberArtworkPath = null;
+    let fallbackUberArtworkPath = null;
+    let cropCode = null;
+    let fallbackCropCode = null;
+    switch (objectGraph.client.deviceType) {
+        case "mac":
+            if (options.supportsArcade) {
+                uberArtworkPath = "editorialArtwork.splashFullScreen";
+                cropCode = "sr";
+            }
+            else {
+                uberArtworkPath = "editorialArtwork.centeredFullscreenBackground";
+                cropCode = "ep";
+            }
+            break;
+        case "tv":
+            if (options.presentedInTopShelf) {
+                uberArtworkPath = "editorialArtwork.topShelf";
+                cropCode = "sr";
+            }
+            else {
+                uberArtworkPath = "editorialArtwork.splashFullScreen";
+                cropCode = "ta";
+                fallbackUberArtworkPath = "editorialArtwork.fullscreenBackground";
+                fallbackCropCode = "sr";
+            }
+            break;
+        case "vision":
+            uberArtworkPath = "editorialArtwork.productUberStatic16x9";
+            cropCode = "sr";
+            break;
+        default:
+            if (options.supportsArcade) {
+                if (options.prefersCompactVariant || objectGraph.client.isPhone) {
+                    uberArtworkPath = "editorialArtwork.splashTall";
+                    cropCode = "oc";
+                }
+                else {
+                    uberArtworkPath = "editorialArtwork.splashFullScreen";
+                    cropCode = "oh";
+                }
+            }
+            else {
+                uberArtworkPath = "editorialArtwork.bannerUber";
+                cropCode = "sr";
+            }
+            break;
+    }
+    uberArtworkData = contentAttributes.contentAttributeAsDictionary(objectGraph, data, uberArtworkPath);
+    // If we don't have the desired artwork, we sometimes attempt to use other artwork as a fallback.
+    if (fallbackUberArtworkPath !== null && serverData.isNullOrEmpty(uberArtworkData)) {
+        uberArtworkData = contentAttributes.contentAttributeAsDictionary(objectGraph, data, fallbackUberArtworkPath);
+        // Use the fallback crop if it's available.
+        if (fallbackCropCode !== null) {
+            cropCode = fallbackCropCode;
+        }
+    }
+    if (serverData.isDefinedNonNull(uberArtworkData) && serverData.isDefinedNonNull(cropCode)) {
+        return artworkFromApiArtwork(objectGraph, uberArtworkData, {
+            cropCode,
+            useCase: 21 /* ArtworkUseCase.Uber */,
+            withJoeColorPlaceholder: true,
+            overrideHeight: null,
+            overrideWidth: null,
+        });
+    }
+    return null;
+}
+/**
+ * Determines the logo artwork for the product, if there is any.
+ * @param {Data} The data for the product.
+ * @returns {models.Artwork} The artwork for the uber, or `null` if there is none.
+ * null.
+ */
+export function productLogoArtworkFromData(objectGraph, data) {
+    let artworkPath = null;
+    let cropCode = null;
+    switch (objectGraph.client.deviceType) {
+        case "tv":
+            artworkPath = "editorialArtwork.contentLogoTrimmed";
+            cropCode = "bb";
+            break;
+        default:
+            return null;
+    }
+    const artworkData = contentAttributes.contentAttributeAsDictionary(objectGraph, data, artworkPath);
+    if (serverData.isDefinedNonNull(artworkData) && serverData.isDefinedNonNull(cropCode)) {
+        return artworkFromApiArtwork(objectGraph, artworkData, {
+            cropCode,
+            useCase: 0 /* ArtworkUseCase.Default */,
+            withJoeColorPlaceholder: true,
+        });
+    }
+    return null;
+}
+/**
+ * Determines the editorial video for the product, if there is any.
+ * @returns {models.Video} The editorial video for the product, or `null` if there is none.
+ * null.
+ * @param data
+ * @param useCase
+ * @param preferredFlavorsOverride
+ */
+export function productEditorialVideoFromData(objectGraph, data, useCase, preferredFlavorsOverride, videoPreviewOverride) {
+    let preferredFlavors = [];
+    if (serverData.isDefinedNonNullNonEmpty(preferredFlavorsOverride)) {
+        preferredFlavors = preferredFlavorsOverride;
+    }
+    else {
+        switch (objectGraph.client.deviceType) {
+            case "mac":
+            case "tv":
+                preferredFlavors = ["splashVideo16x9"];
+                break;
+            case "pad":
+                preferredFlavors = ["splashVideo4x3"];
+                break;
+            case "vision":
+                preferredFlavors = ["productUberMotion16x9"];
+                break;
+            default:
+                preferredFlavors = ["splashVideo3x4"];
+        }
+    }
+    let uberEditorialVideoData = null;
+    let videoPreviewData = null;
+    for (const videoFlavor of preferredFlavors) {
+        uberEditorialVideoData = contentAttributes.contentAttributeAsDictionary(objectGraph, data, [
+            "editorialVideo",
+            videoFlavor,
+        ]);
+        videoPreviewData = contentAttributes.contentAttributeAsDictionary(objectGraph, data, [
+            "editorialVideo",
+            videoFlavor,
+            "previewFrame",
+        ]);
+        if (serverData.isDefinedNonNullNonEmpty(uberEditorialVideoData)) {
+            break;
+        }
+    }
+    // Video Preview based on data, or externally provided override if any.
+    const videoPreview = videoPreviewOverride !== null && videoPreviewOverride !== void 0 ? videoPreviewOverride : artworkFromApiArtwork(objectGraph, videoPreviewData, {
+        useCase: useCase,
+        withJoeColorPlaceholder: true,
+        cropCode: "sr",
+    });
+    if (serverData.isDefinedNonNull(uberEditorialVideoData)) {
+        const videoUrl = serverData.asString(uberEditorialVideoData, "video");
+        if (serverData.isNull(videoUrl)) {
+            return null;
+        }
+        let playbackControls;
+        let autoplayPlaybackControls;
+        if (objectGraph.host.isiOS || objectGraph.host.isMac || objectGraph.host.isTV) {
+            playbackControls = videoDefaults.standardControls(objectGraph);
+            autoplayPlaybackControls = {
+                muteUnmute: true,
+            };
+        }
+        else {
+            playbackControls = {};
+            autoplayPlaybackControls = {};
+        }
+        const configuration = {
+            allowsAutoPlay: true,
+            looping: true,
+            canPlayFullScreen: false,
+            playbackControls: playbackControls,
+            autoPlayPlaybackControls: autoplayPlaybackControls,
+        };
+        return new models.Video(videoUrl, videoPreview, configuration);
+    }
+    return null;
+}
+/**
+ * Determines the video for the poster lockup, if there is any.
+ * @param {Data} The data for the lockup.
+ * @param {useCase} The use case for this artwork.
+ * @returns {models.Video} The video for the poster lockup, or `null` if there is none.
+ * null.
+ */
+export function posterEditorialVideoFromData(objectGraph, data, useCase) {
+    const editorialVideoData = contentAttributes.contentAttributeAsDictionary(objectGraph, data, [
+        "editorialVideo",
+        "posterCardVideo16x9",
+    ]);
+    const videoPreviewData = contentAttributes.contentAttributeAsDictionary(objectGraph, data, [
+        "editorialVideo",
+        "posterCardVideo16x9",
+        "previewFrame",
+    ]);
+    const cropCode = "sr";
+    const videoPreview = artworkFromApiArtwork(objectGraph, videoPreviewData, {
+        useCase: useCase,
+        withJoeColorPlaceholder: true,
+        cropCode: cropCode,
+    });
+    if (serverData.isDefinedNonNull(editorialVideoData)) {
+        const videoUrl = serverData.asString(editorialVideoData, "video");
+        if (serverData.isNull(videoUrl)) {
+            return null;
+        }
+        const configuration = {
+            allowsAutoPlay: true,
+            looping: true,
+            canPlayFullScreen: false,
+            playbackControls: videoDefaults.noControls(objectGraph),
+            autoPlayPlaybackControls: videoDefaults.noControls(objectGraph),
+        };
+        return new models.Video(videoUrl, videoPreview, configuration);
+    }
+    return null;
+}
+/**
+ * Determines the artwork for the poster lockup, if there is any.
+ * @param {Data} The data for the lockup.
+ * @returns {models.Artwork} The artwork for the poster lockup, or `null` if there is none.
+ * null.
+ */
+export function posterArtworkFromData(objectGraph, data) {
+    const artworkData = contentAttributes.contentAttributeAsDictionary(objectGraph, data, "editorialArtwork.postCard");
+    const cropCode = "sr";
+    if (serverData.isDefinedNonNull(artworkData)) {
+        return artworkFromApiArtwork(objectGraph, artworkData, {
+            cropCode,
+            useCase: 0 /* ArtworkUseCase.Default */,
+            withJoeColorPlaceholder: true,
+        });
+    }
+    return null;
+}
+/**
+ * Determines the artwork for the epic heading on a poster lockup, if there is any.
+ * @param {Data} The data for the product.
+ * @returns {models.Artwork} The artwork for the epic heading, or `null` if there is none.
+ * null.
+ */
+export function posterEpicHeadingArtworkFromData(objectGraph, data) {
+    const artworkData = contentAttributes.contentAttributeAsDictionary(objectGraph, data, "editorialArtwork.epicHeading");
+    const cropCode = "bb";
+    if (serverData.isDefinedNonNull(artworkData) && serverData.isDefinedNonNull(cropCode)) {
+        const epicHeadingArtwork = artworkFromApiArtwork(objectGraph, artworkData, {
+            cropCode,
+            useCase: 0 /* ArtworkUseCase.Default */,
+        });
+        if (objectGraph.client.isVision) {
+            epicHeadingArtwork.backgroundColor = color.named("clear");
+        }
+        return epicHeadingArtwork;
+    }
+    return null;
+}
+/**
+ * Fetch the most-landscape media from data. Hoisted from Arcade See All.
+ * Used for:
+ * - Arcade See All Media Lockups
+ * - Continue Playing Lockups
+ */
+export function editorialSplashVideoFromData(objectGraph, data, videoPreviewOverride) {
+    let preferredEditorialVideoFlavors = null;
+    switch (objectGraph.client.deviceType) {
+        case "mac":
+        case "tv":
+        case "phone":
+        case "vision":
+            preferredEditorialVideoFlavors = ["splashVideo16x9", "splashVideo4x3", "splashVideo3x4"];
+            break;
+        default:
+            preferredEditorialVideoFlavors = ["splashVideo4x3", "splashVideo16x9", "splashVideo3x4"];
+    }
+    return productEditorialVideoFromData(objectGraph, data, 21 /* ArtworkUseCase.Uber */, preferredEditorialVideoFlavors, videoPreviewOverride);
+}
+/**
+ * Determines the URL to use for the developer page.
+ * @param {Data} developerData The data for the "developer" relationship.
+ * @returns {string} The string form of the URL for the developer page, or `null` if the developer data is undefined or
+ * null.
+ */
+export function developerUrlFromDeveloperData(objectGraph, developerData) {
+    if (!serverData.isDefinedNonNull(developerData)) {
+        return null;
+    }
+    if (objectGraph.client.isWeb) {
+        return mediaAttributes.attributeAsString(developerData, "url");
+    }
+    return `${Protocol.internal}:/${Path.developer}/${Path.href}?${Parameters.href}=${developerData.href}`;
+}
+/**
+ * Determines the URL to use for the Charts page.
+ * @param {Data} data The data for the product.
+ * @returns {string} The string form of the URL for the charts page, or `null` if the data is undefined or
+ * null.
+ */
+export function chartUrlFromData(objectGraph, genre, chart) {
+    const request = new mediaDataFetching.Request(objectGraph)
+        .forType("charts")
+        .addingQuery("types", "apps")
+        .addingQuery("chart", chart)
+        .addingQuery("genre", genre)
+        .includingMacOSCompatibleIOSAppsWhenSupported(true);
+    return mediaUrlBuilder.buildURLFromRequest(objectGraph, request).toString();
+}
+/**
+ * Returns the key into the chart-position badge data for the given client name.
+ * @param clientIdentifier Identifier of the current client.
+ * @returns {string} The relevant key in the chart-position badge JSON data.
+ */
+export function badgeChartKeyForClientIdentifier(objectGraph, clientIdentifier) {
+    switch (clientIdentifier) {
+        case client.appStoreIdentifier:
+        case client.productPageExtensionIdentifier:
+            return "appStore";
+        case client.watchIdentifier:
+            return "watch";
+        case client.messagesIdentifier:
+            return "messages";
+        case client.tvIdentifier:
+            return "appletv";
+        default:
+            return null;
+    }
+}
+/**
+ * Internal function returning the name and asset name representing the
+ * storefront content rating for the provided rank.
+ * @param objectGraph The App Store object graph.
+ * @param rank A content rating rank from CX.
+ * @returns A tuple containing the name and asset name representing the rank,
+ * or `undefined` if rank is unknown/invalid.
+ */
+function storefrontContentRatingInfoForRank(objectGraph, rank) {
+    switch (rank) {
+        // Brazil Self-Rated
+        case 6:
+            return ["L", "br.l"];
+        case 7:
+            return ["10", "br.10"];
+        case 8:
+            return ["12", "br.12"];
+        case 9:
+            return ["14", "br.14"];
+        case 10:
+            return ["16", "br.16"];
+        case 11:
+            return ["18", "br.18"];
+        // Brazil Official
+        case 12:
+            return ["AL", "br.l.official"];
+        case 13:
+            return ["A10", "br.10.official"];
+        case 14:
+            return ["A12", "br.12.official"];
+        case 15:
+            return ["A14", "br.14.official"];
+        case 16:
+            return ["A16", "br.16.official"];
+        case 17:
+            return ["A18", "br.18.official"];
+        // Korea
+        case 20:
+            return ["All", "kr.all"];
+        case 21:
+            return ["12", "kr.12"];
+        case 22:
+            return ["15", "kr.15"];
+        // Australia
+        case 31:
+            return ["15+", "AgeRating-AU-15"];
+        case 32:
+            return ["R 18+", "AgeRating-AU-18"];
+        // France
+        case 47:
+            return ["18+", "AgeRating-FR-18"];
+        default:
+            return undefined;
+    }
+}
+/// Returns a localized title for the given app platform.
+export function appPlatformTitle(objectGraph, appPlatform) {
+    switch (appPlatform) {
+        case "phone":
+            return objectGraph.loc.string("AppPlatform.Phone");
+        case "pad":
+            return objectGraph.loc.string("AppPlatform.Pad");
+        case "vision":
+            return objectGraph.loc.string("AppPlatform.Vision");
+        case "tv":
+            return objectGraph.loc.string("AppPlatform.TV");
+        case "watch":
+            return objectGraph.loc.string("AppPlatform.Watch");
+        case "messages":
+            return objectGraph.loc.string("AppPlatform.Messages");
+        case "mac":
+            return objectGraph.loc.string("AppPlatform.Mac");
+        default:
+            return "";
+    }
+}
+/**
+ * Provides the name of the asset representing the storefront content rating
+ * for the provided `rank`.
+ * @param objectGraph The App Store object graph.
+ * @param rank A content rating rank from CX.
+ * @returns The asset name representing the `rank`, corresponding to a file on
+ * device, or `undefined` if rank is unknown/invalid.
+ */
+export function storefrontContentRatingResourceForRank(objectGraph, rank) {
+    var _a;
+    return (_a = storefrontContentRatingInfoForRank(objectGraph, rank)) === null || _a === void 0 ? void 0 : _a[1];
+}
+/**
+ * Provides a textual representation of the storefront content rating for the
+ * provided `rank`, e.g. "18+". This should match the main text displayed in
+ * the content rating pictogram from `storefrontContentRatingResourceForRank`.
+ * @param objectGraph The App Store object graph.
+ * @param rank A content rating rank from CX.
+ * @returns The textual version of the storefront content rating representing
+ * the `rank`, or `undefined` if rank is unknown/invalid.
+ */
+export function storefrontContentRatingNameForRank(objectGraph, rank) {
+    var _a;
+    return (_a = storefrontContentRatingInfoForRank(objectGraph, rank)) === null || _a === void 0 ? void 0 : _a[0];
+}
+export function promotionalTextFromData(objectGraph, data, productVariantData) {
+    return contentAttributes.customAttributeAsString(objectGraph, data, productVariantData, "promotionalText");
+}
+export function hasMessagesExtensionFromData(objectGraph, data, attributePlatform) {
+    return contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "hasMessagesExtension", attributePlatform);
+}
+export function supportsFunCameraFromData(objectGraph, data, attributePlatform) {
+    return contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "supportsFunCamera", attributePlatform);
+}
+export function isHiddenFromSpringboardFromData(objectGraph, data) {
+    return contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isHiddenFromSpringboard");
+}
+function isAppleWatchSupportedFromData(objectGraph, data) {
+    return contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isAppleWatchSupported");
+}
+function messagesScreenshotsFromData(objectGraph, data, attributePlatform) {
+    return contentAttributes.contentAttributeAsDictionary(objectGraph, data, "messagesScreenshots", attributePlatform);
+}
+function screenshotsByTypeFromData(objectGraph, data, productVariantData, isAd, attributePlatform) {
+    const attributeKey = isAd ? "customScreenshotsByTypeForAd" : "screenshotsByType";
+    return contentAttributes.customAttributeAsDictionary(objectGraph, data, productVariantData, attributeKey, attributePlatform);
+}
+function videoPreviewsByTypeFromData(objectGraph, data, productVariantData, isAd, attributePlatform) {
+    const attributeKey = isAd ? "customVideoPreviewsByTypeForAd" : "videoPreviewsByType";
+    return contentAttributes.customAttributeAsDictionary(objectGraph, data, productVariantData, attributeKey, attributePlatform);
+}
+/**
+ * Whether Arcade is supported, based on the provided data.
+ * @param objectGraph The App Store object graph.
+ * @param data The data blob to check for Arcade support.
+ * @param attributePlatformOverride An override platform, from which to fetch the attribute.
+ * @returns A boolean indicating if Arcade is supported.
+ */
+export function isArcadeSupported(objectGraph, data, attributePlatformOverride = undefined) {
+    return contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "supportsArcade", attributePlatformOverride);
+}
+/**
+ * Try to get notes for some piece of content, giving preference to the enrichedEditorialnotes, falling back to editorialNotes,
+ * then finally to itunesNotes. For some data the notes are stored in the attributes not the platformAttributes.
+ * @param {Data} data
+ * @param {string} key
+ * @param {boolean} enableEditorialCardOverrides This means we will also check for editorial-cards as well before chcking the default notes locations
+ * * @param attributePlatformOverride An override platform, from which to fetch the attribute.
+ * @returns {string}
+ */
+export function notesFromData(objectGraph, data, key, enableEditorialCardOverrides = false, attributePlatformOverride = undefined) {
+    var _a, _b;
+    if (isNothing(data)) {
+        return null;
+    }
+    let note;
+    if (enableEditorialCardOverrides) {
+        const editorialCard = editorialCardFromData(data);
+        if (mediaAttributes.hasAttributes(editorialCard)) {
+            note = contentAttributes.contentAttributeAsString(objectGraph, editorialCard, ["editorialNotes", key], attributePlatformOverride);
+        }
+    }
+    note =
+        (_b = (_a = note !== null && note !== void 0 ? note : contentAttributes.contentAttributeAsString(objectGraph, data, ["enrichedEditorialNotes", key], attributePlatformOverride)) !== null && _a !== void 0 ? _a : contentAttributes.contentAttributeAsString(objectGraph, data, ["editorialNotes", key], attributePlatformOverride)) !== null && _b !== void 0 ? _b : contentAttributes.contentAttributeAsString(objectGraph, data, ["itunesNotes", key], attributePlatformOverride);
+    return note;
+}
+/**
+ * Try and get notes for some piece of content editorialNotes
+ * @param {Data} data
+ * @param {string} key
+ * @param {boolean} enableEditorialCardOverrides This means we will also check for editorial-cards as well before chcking the default notes locations
+ * @returns {string}
+ */
+export function editorialNotesFromData(objectGraph, data, key, enableEditorialCardOverrides = false) {
+    var _a;
+    let note;
+    if (enableEditorialCardOverrides) {
+        const editorialCard = editorialCardFromData(data);
+        if (mediaAttributes.hasAttributes(editorialCard)) {
+            note = contentAttributes.contentAttributeAsString(objectGraph, editorialCard, ["editorialNotes", key]);
+        }
+    }
+    note =
+        (_a = note !== null && note !== void 0 ? note : contentAttributes.contentAttributeAsString(objectGraph, data, ["enrichedEditorialNotes", key])) !== null && _a !== void 0 ? _a : contentAttributes.contentAttributeAsString(objectGraph, data, ["editorialNotes", key]);
+    return note;
+}
+/**
+ * Determines whether the provided data is for a macOS installer.
+ * @param data The data against which to check for a macOS installer.
+ */
+export function isMacOSInstaller(objectGraph, data) {
+    return derivedData.value(data, "isMacOSInstaller", () => {
+        const isMac = objectGraph.client.isMac;
+        if (!isMac) {
+            return false;
+        }
+        const bundleId = contentAttributes.contentAttributeAsString(objectGraph, data, "bundleId");
+        if (!serverData.isDefinedNonNull(bundleId)) {
+            return false;
+        }
+        return bundleId.startsWith("com.apple.InstallAssistant");
+    });
+}
+/**
+ * Check whether an app is unsupported by the current companion configuration.
+ * @param data The data representing an app listing.
+ */
+export function isUnsupportedByCurrentCompanion(objectGraph, data) {
+    const deletableApps = sad.systemApps(objectGraph);
+    if (objectGraph.host.isWatch) {
+        // AppConduit will handle determining if SAD apps are supported
+        if (deletableApps.isUnsupportedDeletableSystemAppFromData(data)) {
+            return true;
+        }
+        else if (objectGraph.client.isTinkerWatch) {
+            return (!contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isStandaloneWithCompanionForWatchOS") && !contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isStandaloneForWatchOS"));
+        }
+        return false;
+    }
+    else {
+        if (isUnsupportedDeletableSystemAppFromData(objectGraph, data, objectGraph.client.isTinkerWatch)) {
+            return true;
+        }
+        else if (objectGraph.client.isTinkerWatch) {
+            if (deletableApps.isSystemAppFromData(data)) {
+                // We don't consider whether an app is marked as standalone with companion
+                // when running in standalone mode. We always want SAD apps to be installable.
+                return (!contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isDeliveredInIOSAppForWatchOS") &&
+                    !contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isStandaloneForWatchOS"));
+            }
+            else {
+                return (!contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isStandaloneWithCompanionForWatchOS") &&
+                    !contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isStandaloneForWatchOS"));
+            }
+        }
+        else {
+            // We only allow standalone system apps to be installed when the watch
+            // is not running in standalone mode. This simplifies things for other teams.
+            return (objectGraph.client.isWatch &&
+                deletableApps.isSystemAppFromData(data) &&
+                !contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isStandaloneForWatchOS"));
+        }
+    }
+}
+/**
+ * @deprecated Use sad.isUnsupportedDeletableSystemAppFromData instead.
+ * Check whether a SAD app is unsupported by the current companion configuration.
+ *
+ * @param data The data representing an app listing.
+ * @param isTinkerWatch Whether the current device is a tinker watch
+ */
+export function isUnsupportedDeletableSystemAppFromData(objectGraph, data, isTinkerWatch) {
+    if (isTinkerWatch && sad.systemApps(objectGraph).isSystemAppFromData(data)) {
+        const watchBundleId = mediaAttributes.attributeAsString(data, "watchBundleId");
+        if (serverData.isDefinedNonNullNonEmpty(watchBundleId)) {
+            switch (watchBundleId) {
+                // rdar://63111354 (On Tinker device, able to attempt to download non-Tinker 1st and 3rd party app)
+                // These apps should prevented from installing on a Tinker device
+                case "com.apple.mobilemail.watchkitapp":
+                case "com.apple.news.watchkitapp":
+                case "com.apple.iBooks.watchkitapp":
+                    return true;
+                default:
+                    return false;
+            }
+        }
+    }
+    return false;
+}
+/**
+ *  Device Sizes
+ *
+ *  Please do not use these constants for anything but screenshots.
+ *  Our code should not depend on absolute screen sizes for anything
+ *  not related to selecting the correct screenshots to display. -km
+ */
+/// The screen size of iPhone 6.5" devices.
+export const screenSizeIphone65 = new modelsBase.Size(414.0, 896.0);
+/// The screen size of iPhone 5.8" devices.
+export const screenSizeIPhone58 = new modelsBase.Size(375.0, 812.0);
+/// The screen size of iPhone 6+ like devices.
+export const screenSizeIPhone6Plus = new modelsBase.Size(414.0, 736.0);
+/// The screen size of iPhone 6 like devices.
+export const screenSizeIPhone6 = new modelsBase.Size(375.0, 667.0);
+/// The screen size of iPhone 5 like devices.
+export const screenSizeIPhone5 = new modelsBase.Size(320.0, 568.0);
+/// The screen size of original iPhone like devices.
+export const screenSizeIPhoneOriginal = new modelsBase.Size(320.0, 480.0);
+/// The screen size of iPad and iPad mini devices.
+export const screenSizeIPad = new modelsBase.Size(768.0, 1024.0);
+/// The screen size of 7th and 8th gen 10.2" iPads.
+export const screenSizeIPad102 = new modelsBase.Size(810.0, 1080.0);
+/// The screen size of iPad pro 10.5" devices.
+export const screenSizeIPad105 = new modelsBase.Size(834.0, 1112.0);
+/// The screen size of iPad pro 11" devices.
+export const screenSizeIPad11 = new modelsBase.Size(834.0, 1194.0);
+/// The screen size of iPad Pro 11" devices in landscape orientation.
+/// See `screenSizeIPadJ310Landscape` for info about the landscape orientation.
+export const screenSizeIPad11Landscape = new modelsBase.Size(1194.0, 834.0);
+/// The screen size of iPad pro 12.9" devices.
+export const screenSizeIPadPro = new modelsBase.Size(1024.0, 1366.0);
+/// The screen size of iPad pro 12.9" devices, with rounded corners.
+export const screenSizeIPadPro2018 = new modelsBase.Size(1024.0, 1366.0);
+/// The screen size of iPad pro 12.9" devices, with rounded corners, in landscape orientation.
+/// See `screenSizeIPadJ310Landscape` for info about the landscape orientation.
+export const screenSizeIPadPro2018Landscape = new modelsBase.Size(1366.0, 1024.0);
+// The screen size of the J310 iPad device.
+export const screenSizeIPadJ310 = new modelsBase.Size(744.0, 1133.0);
+// The screen size of the J310 iPad device, in landscape orientation.
+// rdar: //83176176 (J310: kMGQMainScreenCanvasSizes reports width as largest dimension, contrary to all other iPads and UIKit)
+export const screenSizeIPadJ310Landscape = new modelsBase.Size(1133.0, 744.0);
+/// The screen size of J720/J721 devices.
+export const screenSizeJ720 = new modelsBase.Size(1032.0, 1376.0);
+/// The screen size of J720/J721, in landscape orientation.
+/// See `screenSizeIPadJ310Landscape` for info about the landscape orientation.
+export const screenSizeJ720Landscape = new modelsBase.Size(1376.0, 1032.0);
+/// The screen size of J717/J718 devices.
+export const screenSizeJ717 = new modelsBase.Size(834.0, 1210.0);
+/// The screen size of J717/J718, in landscape orientation.
+/// See `screenSizeIPadJ310Landscape` for info about the landscape orientation.
+export const screenSizeJ717Landscape = new modelsBase.Size(1210.0, 834.0);
+/// The screen size of the 42mm Apple Watch devices.
+export const screenSizeWatch = new modelsBase.Size(312.0, 390.0);
+/// The screen size of large 2018 Apple Watch devices.
+export const screenSizeWatch2018 = new modelsBase.Size(368.0, 448.0);
+// The screen size of the large 2021 Apple Watch devices.
+export const screenSizeWatch2021 = new modelsBase.Size(396.0, 484.0);
+// The screen size for the 2022 Apple Watch devices.
+export const screenSizeWatch2022 = new modelsBase.Size(410.0, 502.0);
+// The screen size for the 2024 Apple Watch devices.
+export const screenSizeWatch2024 = new modelsBase.Size(416.0, 496.0);
+// The screen size for the Apple Watch Ultra / Ultra 2 devices.
+export const screenSizeWatchUltra = new modelsBase.Size(410.0, 502.0);
+/// The screen size for iPad device.
+export const screenSizeIPadAir2020 = new modelsBase.Size(820.0, 1180.0);
+/// The screen size for iPhone devices.
+export const screenSizeIPhone131 = new modelsBase.Size(360.0, 780.0);
+export const screenSizeIPhone132 = new modelsBase.Size(390.0, 844.0);
+export const screenSizeIPhone134 = new modelsBase.Size(428.0, 926.0);
+// The screen size for a 6.1" D73-style device.
+export const screenSizeIPhone61 = new modelsBase.Size(393.0, 852.0);
+// The screen size for a 6.7" D74-style device.
+export const screenSizeIPhone67 = new modelsBase.Size(430.0, 932.0);
+/// The screen size for a D93 device.
+export const screenSizeD93 = new modelsBase.Size(402.0, 874.0);
+/// The screen size for a D94 device.
+export const screenSizeD94 = new modelsBase.Size(440.0, 956.0);
+/// The screen size for a D23 device.
+export const screenSizeD23 = new modelsBase.Size(420.0, 912.0);
+/// The screen size for a N230 device.
+export const screenSizeN230 = new modelsBase.Size(422.0, 514.0);
+/// All phone types, in order of decreasing size.
+const decreasingPhoneTypes = [
+    "iphone_d74",
+    "iphone_6_5",
+    "iphone_d73",
+    "iphone_5_8",
+    "iphone6+",
+    "iphone6",
+    "iphone5",
+    "iphone",
+];
+// region Device Corner Radius
+/**
+ * The reason we need to hardcode these is because we may want to display screenshots with rounding for a device that is
+ * not the one the user is currently browsing the store with. For example, imagine that the user is browsing the store
+ * with an iPhone 8 but ends up looking at an app that only has D22 screenshots. They should see the D22 screenshots
+ * according to the D22 corner rounding, and using the current client's `screenCornerRadius` would not give us the
+ * proper value.
+ */
+/// The device corner radius of iPad pro 12.9" devices from 2018.
+const deviceCornerRadiusIpadPro2018 = 18.0;
+/// The device corner radius of iPad pro 11" devices.
+const deviceCornerRadiusIpad11 = 18.0;
+/// The device corner radius of iPhone 6.5" devices.
+const deviceCornerRadiusIphone65 = 41.5;
+/// The device corner radius of iPhone 5.8" devices.
+const deviceCornerRadiusIphone58 = 39.0;
+/// The device corner radius of iPhone 6.1" devices.
+const deviceCornerRadiusIphone61 = 55.0;
+/// The device corner radius of iPhone 6.7" devices.
+const deviceCornerRadiusIphone67 = 55.0;
+/// The device corner radius of large 2018 Apple Watch devices.
+const deviceCornerRadiusWatch2018 = 34.0;
+/// The outer device corner radius of large Apple Watch devices.
+const outerDeviceCornerRadiusWatch = 30.0;
+/// The device border thickness for Apple Watch.
+const deviceBorderThicknessWatch = 13.0;
+/// The device border thickness for 2018 Apple Watch.
+const deviceBorderThicknessWatch2018 = 11.0;
+/// The device corner radius for 2021 Apple Watch.
+const deviceCornerRadiusWatch2021 = 55;
+/// The device border thickness for 2021 Apple Watch.
+const deviceBorderThicknessWatch2021 = 5.5;
+/// The device corner radius for 2022/2024 Apple Watch.
+const deviceCornerRadiusWatch2022 = 108;
+/// The outer device corner radius for 2022/2024 Apple Watch.
+const deviceOuterCornerRadiusWatch2022 = 112.5;
+/// The device border thickness for 2022/2024 Apple Watch.
+const deviceBorderThicknessWatch2022 = 4.5;
+export function currentAppPlatform(objectGraph) {
+    var _a;
+    switch (objectGraph.client.deviceType) {
+        case "web":
+            return unwrap((_a = objectGraph.activeIntent) === null || _a === void 0 ? void 0 : _a.appPlatform);
+        default:
+            return objectGraph.client.deviceType;
+    }
+}
+/// The SF Symbol name that represents the media type.
+export function systemImageNameForAppPlatform(appPlatform) {
+    switch (appPlatform) {
+        case "phone":
+            return "iphone";
+        case "pad":
+            return "ipad";
+        case "tv":
+            return "tv";
+        case "watch":
+            return "applewatch";
+        case "mac":
+            return "macbook";
+        case "messages":
+            return "message";
+        case "vision":
+            return "visionpro";
+        default:
+            unreachable(appPlatform);
+    }
+}
+/**
+ * Returns the factor by which to multiply an artwork's portrait-equivalent width, in order to compute the artwork's
+ * device-rounded corner radius. This is useful because we want to display screenshots for device-rounded screenshots
+ * with a corner radius that is scaled to that of the device screen.
+ *
+ *                          r = w * r'
+ *                          r' = R / W
+ *
+ *                      Where:
+ *                          r: scaled radius
+ *                          r': The return value of this function.
+ *                          R: device corner radius
+ *                          w: width at which the screenshot will be displayed
+ *                          W: device width
+ *
+ * We need to have this value here in the JS because we may need to display device-rounded screenshots on a device that
+ * does not have a device corner radius; there is no native API for querying the corner radius of various devices and,
+ * even if there were, we want to avoid specific screen-size checks in the native code.
+ * @param type The screenshot type vended by the server.
+ * @returns {number} The device corner radius factor, or null if the device does not have a corner radius.
+ */
+function deviceCornerRadiusFactorForMediaType(objectGraph, type) {
+    // Let's only bridge over and access client's properties if we need to.
+    switch (type) {
+        case "ipadPro_2018":
+            return deviceCornerRadiusIpadPro2018 / screenSizeIPadPro2018.width;
+        case "ipad_11":
+            return deviceCornerRadiusIpad11 / screenSizeIPad11.width;
+        case "iphone_6_5":
+            return deviceCornerRadiusIphone65 / screenSizeIphone65.width;
+        case "iphone_5_8":
+            return deviceCornerRadiusIphone58 / screenSizeIPhone58.width;
+        case "iphone_d73":
+            return deviceCornerRadiusIphone61 / screenSizeIPhone61.width;
+        case "iphone_d74":
+            return deviceCornerRadiusIphone67 / screenSizeIPhone67.width;
+        case "appleWatch_2018":
+            return deviceCornerRadiusWatch2018 / screenSizeWatch2018.width;
+        case "appleWatch_2021":
+            return deviceCornerRadiusWatch2021 / screenSizeWatch2021.width;
+        case "appleWatch_2022":
+            return deviceCornerRadiusWatch2022 / screenSizeWatch2022.width;
+        case "appleWatch_2024":
+            return deviceCornerRadiusWatch2022 / screenSizeWatch2024.width;
+        default:
+            return null;
+    }
+}
+function deviceOuterCornerRadiusFactorForMediaType(objectGraph, type) {
+    switch (type) {
+        case "appleWatch":
+            return outerDeviceCornerRadiusWatch / screenSizeWatch.width;
+        case "appleWatch_2022":
+            return deviceOuterCornerRadiusWatch2022 / screenSizeWatch2022.width;
+        case "appleWatch_2024":
+            return deviceOuterCornerRadiusWatch2022 / screenSizeWatch2024.width;
+        default:
+            return deviceCornerRadiusFactorForMediaType(objectGraph, type);
+    }
+}
+function deviceBorderThicknessForMediaType(objectGraph, type) {
+    switch (type) {
+        case "appleWatch":
+            return deviceBorderThicknessWatch / screenSizeWatch.width;
+        case "appleWatch_2018":
+            return deviceBorderThicknessWatch2018 / screenSizeWatch2018.width;
+        case "appleWatch_2021":
+            return deviceBorderThicknessWatch2021 / screenSizeWatch2021.width;
+        case "appleWatch_2022":
+            return deviceBorderThicknessWatch2022 / screenSizeWatch2022.width;
+        case "appleWatch_2024":
+            return deviceBorderThicknessWatch2022 / screenSizeWatch2024.width;
+        default:
+            return null;
+    }
+}
+// endregion
+/**
+ Returns a boolean indicating if the client's operating
+ system is the same or later than the specified version.
+
+ @param version    The full version number to check against
+ @returns true if the operating system is the same or newer than the specified version; false otherwise.
+ */
+export function isOSAtLeastVersion(objectGraph, version) {
+    if (serverData.isNull(version) || version.length === 0) {
+        return true;
+    }
+    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 objectGraph.host.isOSAtLeast(majorVersion, minorVersion, patchVersion);
+}
+/**
+ Returns a boolean indicating if the system version of the active, paired watch (if any) is
+ at least the provided version number.
+
+ @param version    The full version number to check against
+ @returns true if an active, paired watch exists, and its operating system  version is the same or newer than the specified version; false otherwise.
+ */
+export function isActivePairedWatchOSAtLeastVersion(objectGraph, version) {
+    if (serverData.isNull(version) || version.length === 0) {
+        return true;
+    }
+    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 objectGraph.client.isActivePairedWatchSystemVersionAtLeastMajorVersionMinorVersionPatchVersion(majorVersion, minorVersion, patchVersion);
+}
+/**
+ * Check whether the active paired device's OS is the same or greater than a given version.
+ */
+export function isActivePairedDeviceAtLeastVersion(objectGraph, version) {
+    if (serverData.isNull(version) || version.length === 0) {
+        return true;
+    }
+    return objectGraph.client.isPairedSystemVersionAtLeast(version);
+}
+/**
+ * Check whether the active paired device's OS is below a given version.
+ */
+export function isActivePairedWatchOSBelowVersion(objectGraph, version) {
+    if (serverData.isNull(version) || version.length === 0) {
+        return false;
+    }
+    return objectGraph.client.isActivePairedWatchSystemVersionBelow(version);
+}
+export function shelfContentTypeCanDisplayArcadeOfferButtons(objectGraph, shelfStyle) {
+    if (objectGraph.client.isTV) {
+        switch (shelfStyle) {
+            case "upsellBreakout":
+                return true;
+            default:
+                return false;
+        }
+    }
+    else {
+        switch (shelfStyle) {
+            case "smallLockup":
+            case "mediumLockup":
+            case "appTrailerLockup":
+            case "screenshotsLockup":
+            case "mixedMediaLockup":
+            case "upsellBreakout":
+            case "arcadeShowcase":
+                return true;
+            default:
+                return false;
+        }
+    }
+}
+export function shelfDisplayStyleCanDisplayArcadeOfferButtons(objectGraph, displayStyle) {
+    switch (displayStyle) {
+        case "LockupSmall":
+        case "LockupLarge":
+        case "BreakoutLarge":
+        case "Hero":
+        case "EditorialLockupLarge":
+        case "EditorialLockupLargeVariant":
+        case "EditorialLockupMedium":
+        case "EditorialLockupMediumVariant":
+        case "StoryMedium":
+            return true;
+        default:
+            return false;
+    }
+}
+/**
+ * The dynamic date string used by apps coming soon.
+ */
+export function dynamicPreorderDateFromData(objectGraph, data, fallbackLabel) {
+    const preorderOffer = offers.offerDataFromData(objectGraph, data);
+    const isPreorder = serverData.asString(preorderOffer, "type") === "preorder";
+    if (isPreorder) {
+        const releaseDateRaw = serverData.asString(preorderOffer, "expectedReleaseDate");
+        const dateDisplayFormat = contentAttributes.contentAttributeAsString(objectGraph, data, "expectedReleaseDateDisplayFormat");
+        if (serverData.isDefinedNonNullNonEmpty(dateDisplayFormat)) {
+            if (serverData.isDefinedNonNullNonEmpty(releaseDateRaw)) {
+                const releaseDate = dateUtil.parseDateOmittingTimeFromString(releaseDateRaw);
+                const tokenFormatMap = {
+                    "@@expectedDateMY@@": objectGraph.loc.string("PreOrder.Date.MonthYear"),
+                    "@@expectedDateMDY@@": objectGraph.loc.string("PreOrder.Date.MonthDayYear"),
+                };
+                for (const [serverToken, dateFormat] of Object.entries(tokenFormatMap)) {
+                    if (dateDisplayFormat.includes(serverToken)) {
+                        let formattedDate = objectGraph.loc.formatDateWithContext(dateFormat, releaseDate, "middleOfSentence");
+                        if (objectGraph.client.isTV) {
+                            formattedDate = formattedDate.replace(/ /g, "\u00a0");
+                        }
+                        return dateDisplayFormat.replace(serverToken, formattedDate);
+                    }
+                }
+            }
+            return dateDisplayFormat;
+        }
+    }
+    // There was no dynamic date to display
+    return fallbackLabel;
+}
+/**
+ * The primary content for an editorial item.
+ * @param data The data from which to derive the primary content.
+ */
+export function primaryContentForData(objectGraph, data) {
+    const primaryContent = mediaRelationship.relationshipData(objectGraph, data, "primary-content");
+    if (serverData.isDefinedNonNullNonEmpty(primaryContent)) {
+        return primaryContent;
+    }
+    // If an EI has canvasData, then in MAPI response its "primary-content" relationship will not include the
+    // primary content meta data. Instead, the primary content data will be included in the "card-contents" relationship.
+    if (contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, data, "isCanvasAvailable")) {
+        return mediaRelationship.relationshipData(objectGraph, data, "card-contents");
+    }
+    return null;
+}
+const grayColorHex = "#9BA9BD";
+export const grayColorCriteria = {
+    colorHex: grayColorHex,
+    maxSaturation: 4,
+    maxBrightness: 9,
+};
+/**
+ * The list of tag background colors we can use to match an app icon background color against, based on saturation and brightness
+ */
+const saturationBrightnessBasedTagColorBuckets = [
+    grayColorCriteria, // Gray
+];
+/**
+ * The list of tag background colors we can use to match an app icon background color against
+ */
+const hueBasedTagColorBuckets = [
+    { colorHex: "#F7816F", minHue: 0, maxHue: 16 },
+    { colorHex: "#FF9034", minHue: 17, maxHue: 33 },
+    { colorHex: "#E3B059", minHue: 34, maxHue: 59 },
+    { colorHex: "#74BD66", minHue: 60, maxHue: 129 },
+    { colorHex: "#72C792", minHue: 130, maxHue: 169 },
+    { colorHex: "#61BFE2", minHue: 170, maxHue: 209 },
+    { colorHex: "#6EA3E9", minHue: 210, maxHue: 239 },
+    { colorHex: "#7D69FA", minHue: 240, maxHue: 259 },
+    { colorHex: "#B363F7", minHue: 260, maxHue: 289 },
+    { colorHex: "#EE7CBD", minHue: 290, maxHue: 360 }, // Pink
+];
+/**
+ * Find the matching tag color for an icon's background color
+ *
+ * @param iconBackgroundColor The bgColor from the icon artwork data
+ * @returns The closest matching color from the HI provided set of tag background colors for this icon color
+ */
+export function closestTagBackgroundColorForIcon(iconBackgroundColor) {
+    var _a;
+    return ((_a = color.findColorBucketForColor(iconBackgroundColor, saturationBrightnessBasedTagColorBuckets, hueBasedTagColorBuckets)) !== null && _a !== void 0 ? _a : color.fromHex(grayColorHex));
+}
+/**
+ * Parses a JoeColorSet out of a MAPI EditorialArtwork JSON object
+ * @param data An EditorialArtwork JSON object from MAPI
+ * @returns A JoeColorSet from parsing the input RGB values
+ */
+export function joeColorHexSetFromData(data) {
+    var _a, _b, _c, _d, _e;
+    const textGradient = [];
+    for (const gradientColorHex of serverData.asArrayOrEmpty(data, "textGradient")) {
+        if (isSome(gradientColorHex) && serverData.isString(gradientColorHex)) {
+            textGradient.push(gradientColorHex);
+        }
+    }
+    return {
+        bgColor: (_a = serverData.asString(data, "bgColor")) !== null && _a !== void 0 ? _a : undefined,
+        textColor1: (_b = serverData.asString(data, "textColor1")) !== null && _b !== void 0 ? _b : undefined,
+        textColor2: (_c = serverData.asString(data, "textColor2")) !== null && _c !== void 0 ? _c : undefined,
+        textColor3: (_d = serverData.asString(data, "textColor3")) !== null && _d !== void 0 ? _d : undefined,
+        textColor4: (_e = serverData.asString(data, "textColor4")) !== null && _e !== void 0 ? _e : undefined,
+        textGradient: isDefinedNonNullNonEmpty(textGradient) ? textGradient : undefined,
+    };
+}
+/**
+ * Parses a JoeColorSet out of a MAPI EditorialArtwork JSON object
+ * @param data An EditorialArtwork JSON object from MAPI
+ * @returns A JoeColorSet from parsing the input RGB values
+ */
+export function joeColorSetFromData(data) {
+    var _a, _b, _c, _d, _e, _f;
+    const joeColorHexSet = joeColorHexSetFromData(data);
+    const textGradient = [];
+    for (const gradientColorHex of (_a = joeColorHexSet.textGradient) !== null && _a !== void 0 ? _a : []) {
+        const gradientColor = color.fromHex(gradientColorHex);
+        if (isSome(gradientColor)) {
+            textGradient.push(gradientColor);
+        }
+    }
+    return {
+        bgColor: (_b = color.fromHex(joeColorHexSet.bgColor)) !== null && _b !== void 0 ? _b : undefined,
+        textColor1: (_c = color.fromHex(joeColorHexSet.textColor1)) !== null && _c !== void 0 ? _c : undefined,
+        textColor2: (_d = color.fromHex(joeColorHexSet.textColor2)) !== null && _d !== void 0 ? _d : undefined,
+        textColor3: (_e = color.fromHex(joeColorHexSet.textColor3)) !== null && _e !== void 0 ? _e : undefined,
+        textColor4: (_f = color.fromHex(joeColorHexSet.textColor4)) !== null && _f !== void 0 ? _f : undefined,
+        textGradient: isDefinedNonNullNonEmpty(textGradient) ? textGradient : undefined,
+    };
+}
+/**
+ * Attempt to find the first non-gray placeholder color
+ * @param joeColorSet The joe color set for a given icon
+ * @returns The color hext value to use for the joe color placeholder
+ */
+export function bestJoeColorPlaceholderSelectionLogic(joeColorSet) {
+    const joeColorKeys = [
+        "bgColor",
+        "textColor1",
+        "textColor2",
+        "textColor3",
+        "textColor4",
+    ];
+    for (const joeColorKey of joeColorKeys) {
+        const joeColorHex = joeColorSet[joeColorKey];
+        if (!serverData.isString(joeColorHex)) {
+            continue;
+        }
+        const isGrayColor = color.doesColorMeetCriteria(color.fromHex(joeColorHex), grayColorCriteria);
+        if (!isGrayColor) {
+            return joeColorHex;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=content.js.map
\ No newline at end of file